Search is not available for this dataset
repo
stringlengths 2
152
⌀ | file
stringlengths 15
239
| code
stringlengths 0
58.4M
| file_length
int64 0
58.4M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 364
values |
|---|---|---|---|---|---|---|
null |
ceph-main/src/librbd/mirror/snapshot/PromoteRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_PROMOTE_REQUEST_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_PROMOTE_REQUEST_H
#include "include/buffer.h"
#include "include/rbd/librbd.hpp"
#include "common/ceph_mutex.h"
#include "common/Timer.h"
#include "librbd/internal.h"
#include <string>
#include <set>
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename ImageCtxT = librbd::ImageCtx>
class PromoteRequest {
public:
static PromoteRequest *create(ImageCtxT *image_ctx,
const std::string& global_image_id,
Context *on_finish) {
return new PromoteRequest(image_ctx, global_image_id, on_finish);
}
PromoteRequest(ImageCtxT *image_ctx, const std::string& global_image_id,
Context *on_finish)
: m_image_ctx(image_ctx), m_global_image_id(global_image_id),
m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* | (can promote)
* |\----------------------------------------\
* | |
* | |
* v (skip if not needed) |
* CREATE_ORPHAN_SNAPSHOT |
* | |
* | /-- UNREGISTER_UPDATE_WATCHER <-\ |
* v v | |
* LIST_WATCHERS ----> WAIT_UPDATE_NOTIFY --/ |
* | |
* | (no watchers) |
* v |
* ACQUIRE_EXCLUSIVE_LOCK |
* | (skip if not needed) |
* v |
* ROLLBACK |
* | |
* v |
* CREATE_PROMOTE_SNAPSHOT <--------------------/
* |
* v
* DISABLE_NON_PRIMARY_FEATURE
* |
* v
* RELEASE_EXCLUSIVE_LOCK (skip if not needed)
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_image_ctx;
std::string m_global_image_id;
Context *m_on_finish;
uint64_t m_rollback_snap_id = CEPH_NOSNAP;
bool m_lock_acquired = false;
NoOpProgressContext m_progress_ctx;
class UpdateWatchCtx : public librbd::UpdateWatchCtx {
public:
UpdateWatchCtx(PromoteRequest *promote_request)
: promote_request(promote_request) {
}
void handle_notify() {
promote_request->handle_update_notify();
}
private:
PromoteRequest *promote_request;
} m_update_watch_ctx = {this};
std::list<obj_watch_t> m_watchers;
uint64_t m_update_watcher_handle = 0;
uint64_t m_scheduler_ticks = 0;
SafeTimer *m_timer = nullptr;
ceph::mutex *m_timer_lock = nullptr;
void refresh_image();
void handle_refresh_image(int r);
void create_orphan_snapshot();
void handle_create_orphan_snapshot(int r);
void list_watchers();
void handle_list_watchers(int r);
void wait_update_notify();
void handle_update_notify();
void scheduler_unregister_update_watcher();
void unregister_update_watcher();
void handle_unregister_update_watcher(int r);
void acquire_exclusive_lock();
void handle_acquire_exclusive_lock(int r);
void rollback();
void handle_rollback(int r);
void create_promote_snapshot();
void handle_create_promote_snapshot(int r);
void disable_non_primary_feature();
void handle_disable_non_primary_feature(int r);
void release_exclusive_lock();
void handle_release_exclusive_lock(int r);
void finish(int r);
};
} // namespace snapshot
} // namespace mirror
} // namespace librbd
extern template class librbd::mirror::snapshot::PromoteRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_PROMOTE_REQUEST_H
| 4,036 | 25.559211 | 81 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/RemoveImageStateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/mirror/snapshot/RemoveImageStateRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/mirror/snapshot/Types.h"
#include "librbd/mirror/snapshot/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::mirror::snapshot::RemoveImageStateRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace mirror {
namespace snapshot {
using librbd::util::create_rados_callback;
template <typename I>
void RemoveImageStateRequest<I>::send() {
get_object_count();
}
template <typename I>
void RemoveImageStateRequest<I>::get_object_count() {
CephContext *cct = m_image_ctx->cct;
auto oid = util::image_state_object_name(m_image_ctx, m_snap_id, 0);
ldout(cct, 15) << oid << dendl;
librados::ObjectReadOperation op;
op.read(0, 0, &m_bl, nullptr);
librados::AioCompletion *comp = create_rados_callback<
RemoveImageStateRequest<I>,
&RemoveImageStateRequest<I>::handle_get_object_count>(this);
int r = m_image_ctx->md_ctx.aio_operate(oid, comp, &op, nullptr);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void RemoveImageStateRequest<I>::handle_get_object_count(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to read image state object: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
ImageStateHeader header(1);
auto iter = m_bl.cbegin();
try {
using ceph::decode;
decode(header, iter);
} catch (const buffer::error &err) {
lderr(cct) << "failed to decode image state object header" << dendl;
// still try to remove it
}
m_object_count = header.object_count > 0 ? header.object_count : 1;
remove_object();
}
template <typename I>
void RemoveImageStateRequest<I>::remove_object() {
CephContext *cct = m_image_ctx->cct;
ceph_assert(m_object_count > 0);
m_object_count--;
auto oid = util::image_state_object_name(m_image_ctx, m_snap_id,
m_object_count);
ldout(cct, 15) << oid << dendl;
librados::ObjectWriteOperation op;
op.remove();
librados::AioCompletion *comp = create_rados_callback<
RemoveImageStateRequest<I>,
&RemoveImageStateRequest<I>::handle_remove_object>(this);
int r = m_image_ctx->md_ctx.aio_operate(oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void RemoveImageStateRequest<I>::handle_remove_object(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to remove image state object: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
if (m_object_count == 0) {
finish(0);
return;
}
remove_object();
}
template <typename I>
void RemoveImageStateRequest<I>::finish(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace snapshot
} // namespace mirror
} // namespace librbd
template class librbd::mirror::snapshot::RemoveImageStateRequest<librbd::ImageCtx>;
| 3,387 | 24.666667 | 85 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/RemoveImageStateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_REMOVE_IMAGE_STATE_REQUEST_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_REMOVE_IMAGE_STATE_REQUEST_H
#include "include/buffer.h"
#include "include/types.h"
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename ImageCtxT = librbd::ImageCtx>
class RemoveImageStateRequest {
public:
static RemoveImageStateRequest *create(ImageCtxT *image_ctx, uint64_t snap_id,
Context *on_finish) {
return new RemoveImageStateRequest(image_ctx, snap_id, on_finish);
}
RemoveImageStateRequest(ImageCtxT *image_ctx, uint64_t snap_id,
Context *on_finish)
: m_image_ctx(image_ctx), m_snap_id(snap_id), m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* GET_OBJECT_COUNT
* |
* v
* REMOVE_OBJECT (repeat for
* | every object)
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_image_ctx;
uint64_t m_snap_id;
Context *m_on_finish;
bufferlist m_bl;
size_t m_object_count = 0;
void get_object_count();
void handle_get_object_count(int r);
void remove_object();
void handle_remove_object(int r);
void finish(int r);
};
} // namespace snapshot
} // namespace mirror
} // namespace librbd
extern template class librbd::mirror::snapshot::RemoveImageStateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_REMOVE_IMAGE_STATE_REQUEST_H
| 1,635 | 20.526316 | 90 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/SetImageStateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/mirror/snapshot/SetImageStateRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/image/GetMetadataRequest.h"
#include "librbd/mirror/snapshot/WriteImageStateRequest.h"
#include <boost/algorithm/string/predicate.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::mirror_snapshot::SetImageStateRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace mirror {
namespace snapshot {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void SetImageStateRequest<I>::send() {
get_name();
}
template <typename I>
void SetImageStateRequest<I>::get_name() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
librados::ObjectReadOperation op;
cls_client::dir_get_name_start(&op, m_image_ctx->id);
librados::AioCompletion *comp = create_rados_callback<
SetImageStateRequest<I>,
&SetImageStateRequest<I>::handle_get_name>(this);
m_bl.clear();
int r = m_image_ctx->md_ctx.aio_operate(RBD_DIRECTORY, comp, &op, &m_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void SetImageStateRequest<I>::handle_get_name(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r == 0) {
auto it = m_bl.cbegin();
r = cls_client::dir_get_name_finish(&it, &m_image_state.name);
}
if (r < 0) {
lderr(cct) << "failed to retrieve image name: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
ldout(cct, 15) << "name=" << m_image_state.name << dendl;
get_snap_limit();
}
template <typename I>
void SetImageStateRequest<I>::get_snap_limit() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
librados::ObjectReadOperation op;
cls_client::snapshot_get_limit_start(&op);
librados::AioCompletion *comp = create_rados_callback<
SetImageStateRequest<I>,
&SetImageStateRequest<I>::handle_get_snap_limit>(this);
m_bl.clear();
int r = m_image_ctx->md_ctx.aio_operate(m_image_ctx->header_oid, comp, &op,
&m_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void SetImageStateRequest<I>::handle_get_snap_limit(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r == 0) {
auto it = m_bl.cbegin();
r = cls_client::snapshot_get_limit_finish(&it, &m_image_state.snap_limit);
}
if (r < 0) {
lderr(cct) << "failed to retrieve snapshot limit: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
ldout(cct, 15) << "snap_limit=" << m_image_state.snap_limit << dendl;
get_metadata();
}
template <typename I>
void SetImageStateRequest<I>::get_metadata() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
auto ctx = create_context_callback<
SetImageStateRequest<I>,
&SetImageStateRequest<I>::handle_get_metadata>(this);
auto req = image::GetMetadataRequest<I>::create(
m_image_ctx->md_ctx, m_image_ctx->header_oid, true, "", "", 0,
&m_image_state.metadata, ctx);
req->send();
}
template <typename I>
void SetImageStateRequest<I>::handle_get_metadata(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to retrieve metadata: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
{
std::shared_lock image_locker{m_image_ctx->image_lock};
m_image_state.features =
m_image_ctx->features & ~RBD_FEATURES_IMPLICIT_ENABLE;
for (auto &[snap_id, snap_info] : m_image_ctx->snap_info) {
auto type = cls::rbd::get_snap_namespace_type(snap_info.snap_namespace);
if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_USER) {
// only replicate user snapshots -- trash snapshots will be
// replicated by an implicit delete if required
continue;
}
m_image_state.snapshots[snap_id] = {snap_info.snap_namespace,
snap_info.name,
snap_info.protection_status};
}
}
write_image_state();
}
template <typename I>
void SetImageStateRequest<I>::write_image_state() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
auto ctx = create_context_callback<
SetImageStateRequest<I>,
&SetImageStateRequest<I>::handle_write_image_state>(this);
auto req = WriteImageStateRequest<I>::create(m_image_ctx, m_snap_id,
m_image_state, ctx);
req->send();
}
template <typename I>
void SetImageStateRequest<I>::handle_write_image_state(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to write image state: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
update_primary_snapshot();
}
template <typename I>
void SetImageStateRequest<I>::update_primary_snapshot() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_snapshot_set_copy_progress(
&op, m_snap_id, true, 0);
auto aio_comp = create_rados_callback<
SetImageStateRequest<I>,
&SetImageStateRequest<I>::handle_update_primary_snapshot>(this);
int r = m_image_ctx->md_ctx.aio_operate(m_image_ctx->header_oid, aio_comp,
&op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void SetImageStateRequest<I>::handle_update_primary_snapshot(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to update primary snapshot: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void SetImageStateRequest<I>::finish(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace snapshot
} // namespace mirror
} // namespace librbd
template class librbd::mirror::snapshot::SetImageStateRequest<librbd::ImageCtx>;
| 6,489 | 26.5 | 81 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/SetImageStateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_SET_IMAGE_STATE_REQUEST_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_SET_IMAGE_STATE_REQUEST_H
#include "librbd/mirror/snapshot/Types.h"
#include <map>
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename ImageCtxT = librbd::ImageCtx>
class SetImageStateRequest {
public:
static SetImageStateRequest *create(ImageCtxT *image_ctx, uint64_t snap_id,
Context *on_finish) {
return new SetImageStateRequest(image_ctx, snap_id, on_finish);
}
SetImageStateRequest(ImageCtxT *image_ctx, uint64_t snap_id,
Context *on_finish)
: m_image_ctx(image_ctx), m_snap_id(snap_id), m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* GET_NAME
* |
* v
* GET_SNAP_LIMIT
* |
* v
* GET_METADATA
* |
* v
* WRITE_IMAGE_STATE
* |
* v
* UPDATE_PRIMARY_SNAPSHOT
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_image_ctx;
uint64_t m_snap_id;
Context *m_on_finish;
ImageState m_image_state;
bufferlist m_bl;
bufferlist m_state_bl;
void get_name();
void handle_get_name(int r);
void get_snap_limit();
void handle_get_snap_limit(int r);
void get_metadata();
void handle_get_metadata(int r);
void write_image_state();
void handle_write_image_state(int r);
void update_primary_snapshot();
void handle_update_primary_snapshot(int r);
void finish(int r);
};
} // namespace snapshot
} // namespace mirror
} // namespace librbd
extern template class librbd::mirror::snapshot::SetImageStateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_SET_IMAGE_STATE_REQUEST_H
| 1,930 | 18.907216 | 87 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/Formatter.h"
#include "include/encoding.h"
#include "include/stringify.h"
#include "librbd/mirror/snapshot/Types.h"
namespace librbd {
namespace mirror {
namespace snapshot {
void ImageStateHeader::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(object_count, bl);
ENCODE_FINISH(bl);
}
void ImageStateHeader::decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(object_count, bl);
DECODE_FINISH(bl);
}
void SnapState::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(snap_namespace, bl);
encode(name, bl);
encode(protection_status, bl);
ENCODE_FINISH(bl);
}
void SnapState::decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(snap_namespace, bl);
decode(name, bl);
decode(protection_status, bl);
DECODE_FINISH(bl);
}
void SnapState::dump(Formatter *f) const {
f->open_object_section("namespace");
snap_namespace.dump(f);
f->close_section();
f->dump_string("name", name);
f->dump_unsigned("protection_status", protection_status);
}
std::ostream& operator<<(std::ostream& os, const SnapState& snap_state) {
os << "["
<< "namespace=" << snap_state.snap_namespace << ", "
<< "name=" << snap_state.name << ", "
<< "protection=" << static_cast<int>(snap_state.protection_status)
<< "]";
return os;
}
void ImageState::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
encode(name, bl);
encode(features, bl);
encode(snap_limit, bl);
encode(snapshots, bl);
encode(metadata, bl);
ENCODE_FINISH(bl);
}
void ImageState::decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(name, bl);
decode(features, bl);
decode(snap_limit, bl);
decode(snapshots, bl);
decode(metadata, bl);
DECODE_FINISH(bl);
}
void ImageState::dump(Formatter *f) const {
f->dump_string("name", name);
f->dump_unsigned("features", features);
f->dump_unsigned("snap_limit", snap_limit);
f->open_array_section("snapshots");
for (auto &[id, snap_state] : snapshots) {
f->open_object_section(stringify(id).c_str());
snap_state.dump(f);
f->close_section(); // snap_state
}
f->close_section(); // snapshots
f->open_object_section("metadata");
for (auto &it : metadata) {
f->dump_stream(it.first.c_str()) << it.second;
}
f->close_section(); // metadata
}
std::ostream& operator<<(std::ostream& os, const ImageState& image_state) {
os << "["
<< "name=" << image_state.name << ", "
<< "features=" << image_state.features << ", "
<< "snap_limit=" << image_state.snap_limit << ", "
<< "snaps=" << image_state.snapshots << ", "
<< "metadata_count=" << image_state.metadata.size()
<< "]";
return os;
}
} // namespace snapshot
} // namespace mirror
} // namespace librbd
| 2,888 | 25.263636 | 75 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_TYPES_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_TYPES_H
#include "cls/rbd/cls_rbd_types.h"
#include "include/buffer.h"
#include "include/types.h"
#include <map>
#include <string>
namespace librbd {
namespace mirror {
namespace snapshot {
enum CreatePrimaryFlags {
CREATE_PRIMARY_FLAG_IGNORE_EMPTY_PEERS = (1 << 0),
CREATE_PRIMARY_FLAG_DEMOTED = (1 << 1),
CREATE_PRIMARY_FLAG_FORCE = (1 << 2)
};
struct ImageStateHeader {
uint32_t object_count = 0;
ImageStateHeader() {
}
ImageStateHeader(uint32_t object_count) : object_count(object_count) {
}
void encode(bufferlist &bl) const;
void decode(bufferlist::const_iterator &it);
};
WRITE_CLASS_ENCODER(ImageStateHeader);
struct SnapState {
cls::rbd::SnapshotNamespace snap_namespace;
std::string name;
uint8_t protection_status = 0;
SnapState() {
}
SnapState(const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &name, uint8_t protection_status)
: snap_namespace(snap_namespace), name(name),
protection_status(protection_status) {
}
bool operator==(const SnapState& rhs) const {
return snap_namespace == rhs.snap_namespace &&
name == rhs.name && protection_status == rhs.protection_status;
}
bool operator<(const SnapState& rhs) const {
if (snap_namespace != rhs.snap_namespace) {
return snap_namespace < rhs.snap_namespace;
}
if (name != rhs.name) {
return name < rhs.name;
}
return protection_status < rhs.protection_status;
}
void encode(bufferlist &bl) const;
void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
std::ostream& operator<<(std::ostream& os, const SnapState& snap_state);
WRITE_CLASS_ENCODER(SnapState);
struct ImageState {
std::string name;
uint64_t features = 0;
uint64_t snap_limit = 0;
std::map<uint64_t, SnapState> snapshots;
std::map<std::string, bufferlist> metadata;
ImageState() {
}
ImageState(const std::string &name, uint64_t features, uint64_t snap_limit,
const std::map<uint64_t, SnapState> &snapshots,
const std::map<std::string, bufferlist> &metadata)
: name(name), features(features), snap_limit(snap_limit),
snapshots(snapshots), metadata(metadata) {
}
bool operator==(const ImageState& rhs) const {
return name == rhs.name && features == rhs.features &&
snap_limit == rhs.snap_limit && snapshots == rhs.snapshots;
}
bool operator<(const ImageState& rhs) const {
if (name != rhs.name) {
return name < rhs.name;
}
if (features != rhs.features) {
return features < rhs.features;
}
if (snap_limit != rhs.snap_limit) {
return snap_limit < rhs.snap_limit;
}
return snapshots < rhs.snapshots;
}
void encode(bufferlist &bl) const;
void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
std::ostream& operator<<(std::ostream& os, const ImageState& image_state);
WRITE_CLASS_ENCODER(ImageState);
} // namespace snapshot
} // namespace mirror
} // namespace librbd
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_TYPES_H
| 3,272 | 25.609756 | 77 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/UnlinkPeerRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/mirror/snapshot/UnlinkPeerRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::mirror::snapshot::UnlinkPeerRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace mirror {
namespace snapshot {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void UnlinkPeerRequest<I>::send() {
if (!m_image_ctx->state->is_refresh_required()) {
unlink_peer();
return;
}
refresh_image();
}
template <typename I>
void UnlinkPeerRequest<I>::refresh_image() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
auto ctx = create_context_callback<
UnlinkPeerRequest<I>, &UnlinkPeerRequest<I>::handle_refresh_image>(this);
m_image_ctx->state->refresh(ctx);
}
template <typename I>
void UnlinkPeerRequest<I>::handle_refresh_image(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to refresh image: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
unlink_peer();
}
template <typename I>
void UnlinkPeerRequest<I>::unlink_peer() {
CephContext *cct = m_image_ctx->cct;
m_image_ctx->image_lock.lock_shared();
int r = -ENOENT;
cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
bool have_newer_mirror_snapshot = false;
for (auto snap_it = m_image_ctx->snap_info.find(m_snap_id);
snap_it != m_image_ctx->snap_info.end(); ++snap_it) {
if (snap_it->first == m_snap_id) {
r = 0;
snap_namespace = snap_it->second.snap_namespace;
snap_name = snap_it->second.name;
} else if (std::holds_alternative<cls::rbd::MirrorSnapshotNamespace>(
snap_it->second.snap_namespace)) {
ldout(cct, 15) << "located newer mirror snapshot" << dendl;
have_newer_mirror_snapshot = true;
break;
}
}
if (r == -ENOENT) {
ldout(cct, 15) << "missing snapshot: snap_id=" << m_snap_id << dendl;
m_image_ctx->image_lock.unlock_shared();
finish(r);
return;
}
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&snap_namespace);
if (mirror_ns == nullptr) {
lderr(cct) << "not mirror snapshot (snap_id=" << m_snap_id << ")" << dendl;
m_image_ctx->image_lock.unlock_shared();
finish(-EINVAL);
return;
}
// if there is or will be no more peers in the mirror snapshot and we have
// a more recent mirror snapshot, remove the older one
if ((mirror_ns->mirror_peer_uuids.empty() ||
(mirror_ns->mirror_peer_uuids.size() == 1 &&
mirror_ns->mirror_peer_uuids.count(m_mirror_peer_uuid) != 0)) &&
have_newer_mirror_snapshot) {
if (m_allow_remove) {
m_image_ctx->image_lock.unlock_shared();
remove_snapshot(snap_namespace, snap_name);
return;
} else {
ldout(cct, 15) << "skipping removal of snapshot: snap_id=" << m_snap_id
<< ", mirror_peer_uuid=" << m_mirror_peer_uuid
<< ", mirror_peer_uuids=" << mirror_ns->mirror_peer_uuids
<< dendl;
}
}
if (mirror_ns->mirror_peer_uuids.count(m_mirror_peer_uuid) == 0) {
ldout(cct, 15) << "no peer to unlink: snap_id=" << m_snap_id
<< ", mirror_peer_uuid=" << m_mirror_peer_uuid
<< ", mirror_peer_uuids=" << mirror_ns->mirror_peer_uuids
<< dendl;
m_image_ctx->image_lock.unlock_shared();
finish(0);
return;
}
m_image_ctx->image_lock.unlock_shared();
ldout(cct, 15) << "snap_id=" << m_snap_id << ", "
<< "mirror_peer_uuid=" << m_mirror_peer_uuid << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_snapshot_unlink_peer(&op, m_snap_id,
m_mirror_peer_uuid);
auto aio_comp = create_rados_callback<
UnlinkPeerRequest<I>, &UnlinkPeerRequest<I>::handle_unlink_peer>(this);
r = m_image_ctx->md_ctx.aio_operate(m_image_ctx->header_oid, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void UnlinkPeerRequest<I>::handle_unlink_peer(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r == -ERESTART || r == -ENOENT) {
if (r == -ERESTART) {
ldout(cct, 15) << "unlinking last peer not supported" << dendl;
m_allow_remove = true;
}
refresh_image();
return;
}
if (r < 0) {
lderr(cct) << "failed to unlink peer: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
notify_update();
}
template <typename I>
void UnlinkPeerRequest<I>::notify_update() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
auto ctx = create_context_callback<
UnlinkPeerRequest<I>, &UnlinkPeerRequest<I>::handle_notify_update>(this);
m_image_ctx->notify_update(ctx);
}
template <typename I>
void UnlinkPeerRequest<I>::handle_notify_update(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r == -ENOENT || r == -ETIMEDOUT) {
// non-fatel errors
lderr(cct) << "failed to notify update: " << cpp_strerror(r) << dendl;
} else if (r < 0) {
lderr(cct) << "failed to notify update: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
refresh_image();
}
template <typename I>
void UnlinkPeerRequest<I>::remove_snapshot(
const cls::rbd::SnapshotNamespace& snap_namespace,
const std::string& snap_name) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << dendl;
auto ctx = create_context_callback<
UnlinkPeerRequest<I>, &UnlinkPeerRequest<I>::handle_remove_snapshot>(this);
m_image_ctx->operations->snap_remove(snap_namespace, snap_name, ctx);
}
template <typename I>
void UnlinkPeerRequest<I>::handle_remove_snapshot(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to remove snapshot: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void UnlinkPeerRequest<I>::finish(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
auto on_finish = m_on_finish;
delete this;
on_finish->complete(r);
}
} // namespace snapshot
} // namespace mirror
} // namespace librbd
template class librbd::mirror::snapshot::UnlinkPeerRequest<librbd::ImageCtx>;
| 6,813 | 28.497835 | 79 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/UnlinkPeerRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_UNLINK_PEER_REQUEST_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_UNLINK_PEER_REQUEST_H
#include "include/buffer.h"
#include "cls/rbd/cls_rbd_client.h"
#include <string>
#include <set>
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename ImageCtxT = librbd::ImageCtx>
class UnlinkPeerRequest {
public:
static UnlinkPeerRequest *create(ImageCtxT *image_ctx, uint64_t snap_id,
const std::string &mirror_peer_uuid,
bool allow_remove, Context *on_finish) {
return new UnlinkPeerRequest(image_ctx, snap_id, mirror_peer_uuid,
allow_remove, on_finish);
}
UnlinkPeerRequest(ImageCtxT *image_ctx, uint64_t snap_id,
const std::string &mirror_peer_uuid, bool allow_remove,
Context *on_finish)
: m_image_ctx(image_ctx), m_snap_id(snap_id),
m_mirror_peer_uuid(mirror_peer_uuid), m_allow_remove(allow_remove),
m_on_finish(on_finish) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* REFRESH_IMAGE <--------------------------\
* | ^ (not found |
* | * or last) |
* | * |
* |\---------------> UNLINK_PEER --> NOTIFY_UPDATE
* | (not last peer or
* | no newer mirror
* | snap exists)
* |
* |\---------------> REMOVE_SNAPSHOT
* | (last peer and |
* | newer mirror |
* | snap exists) |
* | |
* |(peer not found) |
* v |
* <finish> <---------------/
*
* @endverbatim
*/
ImageCtxT *m_image_ctx;
uint64_t m_snap_id;
std::string m_mirror_peer_uuid;
bool m_allow_remove;
Context *m_on_finish;
void refresh_image();
void handle_refresh_image(int r);
void unlink_peer();
void handle_unlink_peer(int r);
void notify_update();
void handle_notify_update(int r);
void remove_snapshot(const cls::rbd::SnapshotNamespace& snap_namespace,
const std::string& snap_name);
void handle_remove_snapshot(int r);
void finish(int r);
};
} // namespace snapshot
} // namespace mirror
} // namespace librbd
extern template class librbd::mirror::snapshot::UnlinkPeerRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_UNLINK_PEER_REQUEST_H
| 2,629 | 25.565657 | 84 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/Utils.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/dout.h"
#include "common/errno.h"
#include "include/stringify.h"
#include "librbd/ImageCtx.h"
#include "librbd/mirror/snapshot/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::mirror::snapshot::util: " \
<< " " << __func__ << ": "
namespace librbd {
namespace mirror {
namespace snapshot {
namespace util {
namespace {
const std::string IMAGE_STATE_OBJECT_PREFIX = "rbd_mirror_snapshot.";
bool get_rollback_snap_id(
std::map<librados::snap_t, SnapInfo>::reverse_iterator it,
std::map<librados::snap_t, SnapInfo>::reverse_iterator end,
uint64_t *rollback_snap_id) {
for (; it != end; it++) {
auto mirror_ns = std::get<cls::rbd::MirrorSnapshotNamespace>(
it->second.snap_namespace);
if (mirror_ns.state != cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
break;
}
if (mirror_ns.complete) {
break;
}
}
if (it != end) {
*rollback_snap_id = it->first;
return true;
}
return false;
}
} // anonymous namespace
std::string get_image_meta_key(const std::string& mirror_uuid) {
return ".rbd_mirror." + mirror_uuid;
}
template <typename I>
bool can_create_primary_snapshot(I *image_ctx, bool demoted, bool force,
bool* requires_orphan,
uint64_t *rollback_snap_id) {
CephContext *cct = image_ctx->cct;
if (requires_orphan != nullptr) {
*requires_orphan = false;
}
if (rollback_snap_id) {
*rollback_snap_id = CEPH_NOSNAP;
}
std::shared_lock image_locker{image_ctx->image_lock};
for (auto it = image_ctx->snap_info.rbegin();
it != image_ctx->snap_info.rend(); it++) {
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&it->second.snap_namespace);
if (mirror_ns == nullptr) {
continue;
}
ldout(cct, 20) << "previous snapshot snap_id=" << it->first << " "
<< *mirror_ns << dendl;
if (mirror_ns->is_demoted() && !force) {
lderr(cct) << "trying to create primary snapshot without force "
<< "when previous primary snapshot is demoted"
<< dendl;
return false;
}
if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
if (!force) {
lderr(cct) << "trying to create primary snapshot without force "
<< "when previous snapshot is non-primary"
<< dendl;
return false;
}
if (demoted) {
lderr(cct) << "trying to create primary demoted snapshot "
<< "when previous snapshot is non-primary"
<< dendl;
return false;
}
if (requires_orphan != nullptr) {
*requires_orphan = !mirror_ns->is_demoted();
}
if (!mirror_ns->complete) {
ldout(cct, 20) << "needs rollback" << dendl;
if (!rollback_snap_id) {
lderr(cct) << "trying to create primary snapshot "
<< "when previous non-primary snapshot is not copied yet"
<< dendl;
return false;
}
if (!get_rollback_snap_id(++it, image_ctx->snap_info.rend(),
rollback_snap_id)) {
lderr(cct) << "cannot rollback" << dendl;
return false;
}
ldout(cct, 20) << "rollback_snap_id=" << *rollback_snap_id << dendl;
}
return true;
}
return true;
}
ldout(cct, 20) << "no previous mirror snapshots found" << dendl;
return true;
}
template <typename I>
bool can_create_non_primary_snapshot(I *image_ctx) {
CephContext *cct = image_ctx->cct;
std::shared_lock image_locker{image_ctx->image_lock};
for (auto it = image_ctx->snap_info.rbegin();
it != image_ctx->snap_info.rend(); it++) {
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&it->second.snap_namespace);
if (mirror_ns != nullptr) {
ldout(cct, 20) << "previous mirror snapshot snap_id=" << it->first << " "
<< *mirror_ns << dendl;
if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY) {
if (!mirror_ns->complete) {
lderr(cct) << "trying to create non-primary snapshot "
<< "when previous non-primary snapshot is not copied yet"
<< dendl;
return false;
}
return true;
}
if (mirror_ns->state == cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY) {
lderr(cct) << "trying to create non-primary snapshot "
<< "when previous primary snapshot is not in demoted state"
<< dendl;
return false;
}
return true;
}
}
ldout(cct, 20) << "no previous mirror snapshots found" << dendl;
return true;
}
template <typename I>
std::string image_state_object_name(I *image_ctx, uint64_t snap_id,
uint64_t index) {
return IMAGE_STATE_OBJECT_PREFIX + image_ctx->id + "." +
stringify(snap_id) + "." + stringify(index);
}
} // namespace util
} // namespace snapshot
} // namespace mirror
} // namespace librbd
template bool librbd::mirror::snapshot::util::can_create_primary_snapshot(
librbd::ImageCtx *image_ctx, bool demoted, bool force,
bool* requires_orphan, uint64_t *rollback_snap_id);
template bool librbd::mirror::snapshot::util::can_create_non_primary_snapshot(
librbd::ImageCtx *image_ctx);
template std::string librbd::mirror::snapshot::util::image_state_object_name(
librbd::ImageCtx *image_ctx, uint64_t snap_id, uint64_t index);
| 5,746 | 29.73262 | 79 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/Utils.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_UTILS_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_UTILS_H
#include "include/int_types.h"
#include "include/stringify.h"
#include <string>
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
namespace util {
std::string get_image_meta_key(const std::string& mirror_uuid);
template <typename ImageCtxT = librbd::ImageCtx>
bool can_create_primary_snapshot(ImageCtxT *image_ctx, bool demoted, bool force,
bool* requires_orphan,
uint64_t *rollback_snap_id);
template <typename ImageCtxT = librbd::ImageCtx>
bool can_create_non_primary_snapshot(ImageCtxT *image_ctx);
template <typename ImageCtxT = librbd::ImageCtx>
std::string image_state_object_name(ImageCtxT *image_ctx, uint64_t snap_id,
uint64_t index);
} // namespace util
} // namespace snapshot
} // namespace mirror
} // namespace librbd
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_UTILS_H
| 1,103 | 27.307692 | 80 |
h
|
null |
ceph-main/src/librbd/mirror/snapshot/WriteImageStateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/mirror/snapshot/WriteImageStateRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/mirror/snapshot/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::mirror::snapshot::WriteImageStateRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace mirror {
namespace snapshot {
namespace {
static size_t header_length() {
bufferlist bl;
ImageStateHeader header;
using ceph::encode;
encode(header, bl);
return bl.length();
}
}
using librbd::util::create_rados_callback;
template <typename I>
WriteImageStateRequest<I>::WriteImageStateRequest(I *image_ctx,
uint64_t snap_id,
const ImageState &image_state,
Context *on_finish)
: m_image_ctx(image_ctx), m_snap_id(snap_id), m_image_state(image_state),
m_on_finish(on_finish), m_object_size(
1 << image_ctx->config.template get_val<uint64_t>("rbd_default_order")) {
bufferlist bl;
encode(m_image_state, bl);
m_object_count = 1 + (header_length() + bl.length()) / m_object_size;
ImageStateHeader header(m_object_count);
encode(header, m_bl);
m_bl.claim_append(bl);
}
template <typename I>
void WriteImageStateRequest<I>::send() {
write_object();
}
template <typename I>
void WriteImageStateRequest<I>::write_object() {
CephContext *cct = m_image_ctx->cct;
ceph_assert(m_object_count > 0);
m_object_count--;
auto oid = util::image_state_object_name(m_image_ctx, m_snap_id,
m_object_count);
ldout(cct, 15) << oid << dendl;
size_t off = m_object_count * m_object_size;
size_t len = std::min(m_bl.length() - off, m_object_size);
bufferlist bl;
bl.substr_of(m_bl, off, len);
librados::ObjectWriteOperation op;
op.write_full(bl);
librados::AioCompletion *comp = create_rados_callback<
WriteImageStateRequest<I>,
&WriteImageStateRequest<I>::handle_write_object>(this);
int r = m_image_ctx->md_ctx.aio_operate(oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void WriteImageStateRequest<I>::handle_write_object(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to write object: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
if (m_object_count == 0) {
finish(0);
return;
}
write_object();
}
template <typename I>
void WriteImageStateRequest<I>::finish(int r) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 15) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace snapshot
} // namespace mirror
} // namespace librbd
template class librbd::mirror::snapshot::WriteImageStateRequest<librbd::ImageCtx>;
| 3,143 | 24.983471 | 84 |
cc
|
null |
ceph-main/src/librbd/mirror/snapshot/WriteImageStateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRROR_SNAPSHOT_WRITE_IMAGE_STATE_REQUEST_H
#define CEPH_LIBRBD_MIRROR_SNAPSHOT_WRITE_IMAGE_STATE_REQUEST_H
#include "librbd/mirror/snapshot/Types.h"
#include <map>
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename ImageCtxT = librbd::ImageCtx>
class WriteImageStateRequest {
public:
static WriteImageStateRequest *create(ImageCtxT *image_ctx, uint64_t snap_id,
const ImageState &image_state,
Context *on_finish) {
return new WriteImageStateRequest(image_ctx, snap_id, image_state,
on_finish);
}
WriteImageStateRequest(ImageCtxT *image_ctx, uint64_t snap_id,
const ImageState &image_state, Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* WRITE_OBJECT (repeat for
* | every object)
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_image_ctx;
uint64_t m_snap_id;
ImageState m_image_state;
Context *m_on_finish;
bufferlist m_bl;
const size_t m_object_size;
size_t m_object_count = 0;
void write_object();
void handle_write_object(int r);
void finish(int r);
};
} // namespace snapshot
} // namespace mirror
} // namespace librbd
extern template class librbd::mirror::snapshot::WriteImageStateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_MIRROR_SNAPSHOT_WRITE_IMAGE_STATE_REQUEST_H
| 1,664 | 21.5 | 89 |
h
|
null |
ceph-main/src/librbd/mirroring_watcher/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/Formatter.h"
#include "include/ceph_assert.h"
#include "include/stringify.h"
#include "librbd/mirroring_watcher/Types.h"
#include "librbd/watcher/Utils.h"
namespace librbd {
namespace mirroring_watcher {
namespace {
class DumpPayloadVisitor : public boost::static_visitor<void> {
public:
explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
template <typename Payload>
inline void operator()(const Payload &payload) const {
NotifyOp notify_op = Payload::NOTIFY_OP;
m_formatter->dump_string("notify_op", stringify(notify_op));
payload.dump(m_formatter);
}
private:
ceph::Formatter *m_formatter;
};
} // anonymous namespace
void ModeUpdatedPayload::encode(bufferlist &bl) const {
using ceph::encode;
encode(static_cast<uint32_t>(mirror_mode), bl);
}
void ModeUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
uint32_t mirror_mode_decode;
decode(mirror_mode_decode, iter);
mirror_mode = static_cast<cls::rbd::MirrorMode>(mirror_mode_decode);
}
void ModeUpdatedPayload::dump(Formatter *f) const {
f->dump_stream("mirror_mode") << mirror_mode;
}
void ImageUpdatedPayload::encode(bufferlist &bl) const {
using ceph::encode;
encode(static_cast<uint32_t>(mirror_image_state), bl);
encode(image_id, bl);
encode(global_image_id, bl);
}
void ImageUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
uint32_t mirror_image_state_decode;
decode(mirror_image_state_decode, iter);
mirror_image_state = static_cast<cls::rbd::MirrorImageState>(
mirror_image_state_decode);
decode(image_id, iter);
decode(global_image_id, iter);
}
void ImageUpdatedPayload::dump(Formatter *f) const {
f->dump_stream("mirror_image_state") << mirror_image_state;
f->dump_string("image_id", image_id);
f->dump_string("global_image_id", global_image_id);
}
void UnknownPayload::encode(bufferlist &bl) const {
ceph_abort();
}
void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
}
void NotifyMessage::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
ENCODE_FINISH(bl);
}
void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
case NOTIFY_OP_MODE_UPDATED:
payload = ModeUpdatedPayload();
break;
case NOTIFY_OP_IMAGE_UPDATED:
payload = ImageUpdatedPayload();
break;
default:
payload = UnknownPayload();
break;
}
apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
DECODE_FINISH(iter);
}
void NotifyMessage::dump(Formatter *f) const {
apply_visitor(DumpPayloadVisitor(f), payload);
}
void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
o.push_back(new NotifyMessage(ModeUpdatedPayload(cls::rbd::MIRROR_MODE_DISABLED)));
o.push_back(new NotifyMessage(ImageUpdatedPayload(cls::rbd::MIRROR_IMAGE_STATE_DISABLING,
"image id", "global image id")));
}
std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
switch (op) {
case NOTIFY_OP_MODE_UPDATED:
out << "ModeUpdated";
break;
case NOTIFY_OP_IMAGE_UPDATED:
out << "ImageUpdated";
break;
default:
out << "Unknown (" << static_cast<uint32_t>(op) << ")";
break;
}
return out;
}
} // namespace mirroring_watcher
} // namespace librbd
| 3,770 | 26.525547 | 91 |
cc
|
null |
ceph-main/src/librbd/mirroring_watcher/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_MIRRORING_WATCHER_TYPES_H
#define CEPH_LIBRBD_MIRRORING_WATCHER_TYPES_H
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include "cls/rbd/cls_rbd_types.h"
#include <iosfwd>
#include <list>
#include <string>
#include <boost/variant.hpp>
namespace ceph { class Formatter; }
namespace librbd {
namespace mirroring_watcher {
enum NotifyOp {
NOTIFY_OP_MODE_UPDATED = 0,
NOTIFY_OP_IMAGE_UPDATED = 1
};
struct ModeUpdatedPayload {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_MODE_UPDATED;
cls::rbd::MirrorMode mirror_mode = cls::rbd::MIRROR_MODE_DISABLED;
ModeUpdatedPayload() {
}
ModeUpdatedPayload(cls::rbd::MirrorMode mirror_mode)
: mirror_mode(mirror_mode) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct ImageUpdatedPayload {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_UPDATED;
cls::rbd::MirrorImageState mirror_image_state =
cls::rbd::MIRROR_IMAGE_STATE_ENABLED;
std::string image_id;
std::string global_image_id;
ImageUpdatedPayload() {
}
ImageUpdatedPayload(cls::rbd::MirrorImageState mirror_image_state,
const std::string &image_id,
const std::string &global_image_id)
: mirror_image_state(mirror_image_state), image_id(image_id),
global_image_id(global_image_id) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct UnknownPayload {
static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
UnknownPayload() {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
typedef boost::variant<ModeUpdatedPayload,
ImageUpdatedPayload,
UnknownPayload> Payload;
struct NotifyMessage {
NotifyMessage(const Payload &payload = UnknownPayload()) : payload(payload) {
}
Payload payload;
void encode(bufferlist& bl) const;
void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
};
WRITE_CLASS_ENCODER(NotifyMessage);
std::ostream &operator<<(std::ostream &out, const NotifyOp &op);
} // namespace mirroring_watcher
} // namespace librbd
using librbd::mirroring_watcher::encode;
using librbd::mirroring_watcher::decode;
#endif // CEPH_LIBRBD_MIRRORING_WATCHER_TYPES_H
| 2,681 | 25.038835 | 79 |
h
|
null |
ceph-main/src/librbd/object_map/CreateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/CreateRequest.h"
#include "include/ceph_assert.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "osdc/Striper.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::CreateRequest: "
namespace librbd {
namespace object_map {
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
CreateRequest<I>::CreateRequest(I *image_ctx, Context *on_finish)
: m_image_ctx(image_ctx), m_on_finish(on_finish) {
}
template <typename I>
void CreateRequest<I>::send() {
CephContext *cct = m_image_ctx->cct;
uint64_t max_size = m_image_ctx->size;
{
std::unique_lock 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);
m_snap_ids.push_back(it.first);
}
if (ObjectMap<>::is_compatible(m_image_ctx->layout, max_size)) {
send_object_map_resize();
return;
}
}
lderr(cct) << "image size not compatible with object map" << dendl;
m_on_finish->complete(-EINVAL);
}
template <typename I>
void CreateRequest<I>::send_object_map_resize() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << dendl;
Context *ctx = create_context_callback<
CreateRequest<I>, &CreateRequest<I>::handle_object_map_resize>(this);
C_Gather *gather_ctx = new C_Gather(cct, ctx);
for (auto snap_id : m_snap_ids) {
librados::ObjectWriteOperation op;
uint64_t snap_size = m_image_ctx->get_image_size(snap_id);
cls_client::object_map_resize(&op, Striper::get_num_objects(
m_image_ctx->layout, snap_size),
OBJECT_NONEXISTENT);
std::string oid(ObjectMap<>::object_map_name(m_image_ctx->id, snap_id));
librados::AioCompletion *comp = create_rados_callback(gather_ctx->new_sub());
int r = m_image_ctx->md_ctx.aio_operate(oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
gather_ctx->activate();
}
template <typename I>
Context *CreateRequest<I>::handle_object_map_resize(int *result) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "object map resize failed: " << cpp_strerror(*result)
<< dendl;
}
return m_on_finish;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::CreateRequest<librbd::ImageCtx>;
| 2,710 | 27.536842 | 81 |
cc
|
null |
ceph-main/src/librbd/object_map/CreateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_CREATE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_CREATE_REQUEST_H
#include "include/buffer.h"
#include <map>
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class CreateRequest {
public:
static CreateRequest *create(ImageCtxT *image_ctx, Context *on_finish) {
return new CreateRequest(image_ctx, on_finish);
}
void send();
private:
/**
* @verbatim
*
* <start>
* | . . .
* v v .
* OBJECT_MAP_RESIZE . (for every snapshot)
* | . .
* v . . .
* <finis>
*
* @endverbatim
*/
CreateRequest(ImageCtxT *image_ctx, Context *on_finish);
ImageCtxT *m_image_ctx;
Context *m_on_finish;
std::vector<uint64_t> m_snap_ids;
void send_object_map_resize();
Context *handle_object_map_resize(int *result);
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::CreateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_CREATE_REQUEST_H
| 1,206 | 19.116667 | 74 |
h
|
null |
ceph-main/src/librbd/object_map/DiffRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/DiffRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "osdc/Striper.h"
#include <string>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::DiffRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace object_map {
using util::create_rados_callback;
template <typename I>
void DiffRequest<I>::send() {
auto cct = m_image_ctx->cct;
if (m_snap_id_start == CEPH_NOSNAP || m_snap_id_start > m_snap_id_end) {
lderr(cct) << "invalid start/end snap ids: "
<< "snap_id_start=" << m_snap_id_start << ", "
<< "snap_id_end=" << m_snap_id_end << dendl;
finish(-EINVAL);
return;
} else if (m_snap_id_start == m_snap_id_end) {
// no delta between the same snapshot
finish(0);
return;
}
m_object_diff_state->clear();
// collect all the snap ids in the provided range (inclusive)
if (m_snap_id_start != 0) {
m_snap_ids.insert(m_snap_id_start);
}
std::shared_lock image_locker{m_image_ctx->image_lock};
auto snap_info_it = m_image_ctx->snap_info.upper_bound(m_snap_id_start);
auto snap_info_it_end = m_image_ctx->snap_info.lower_bound(m_snap_id_end);
for (; snap_info_it != snap_info_it_end; ++snap_info_it) {
m_snap_ids.insert(snap_info_it->first);
}
m_snap_ids.insert(m_snap_id_end);
load_object_map(&image_locker);
}
template <typename I>
void DiffRequest<I>::load_object_map(
std::shared_lock<ceph::shared_mutex>* image_locker) {
ceph_assert(ceph_mutex_is_locked(m_image_ctx->image_lock));
if (m_snap_ids.empty()) {
image_locker->unlock();
finish(0);
return;
}
m_current_snap_id = *m_snap_ids.begin();
m_snap_ids.erase(m_current_snap_id);
auto cct = m_image_ctx->cct;
ldout(cct, 10) << "snap_id=" << m_current_snap_id << dendl;
if ((m_image_ctx->features & RBD_FEATURE_FAST_DIFF) == 0) {
image_locker->unlock();
ldout(cct, 10) << "fast-diff feature not enabled" << dendl;
finish(-EINVAL);
return;
}
// ignore ENOENT with intermediate snapshots since deleted
// snaps will get merged with later snapshots
m_ignore_enoent = (m_current_snap_id != m_snap_id_start &&
m_current_snap_id != m_snap_id_end);
if (m_current_snap_id == CEPH_NOSNAP) {
m_current_size = m_image_ctx->size;
} else {
auto snap_it = m_image_ctx->snap_info.find(m_current_snap_id);
if (snap_it == m_image_ctx->snap_info.end()) {
ldout(cct, 10) << "snapshot " << m_current_snap_id << " does not exist"
<< dendl;
if (!m_ignore_enoent) {
image_locker->unlock();
finish(-ENOENT);
return;
}
load_object_map(image_locker);
return;
}
m_current_size = snap_it->second.size;
}
uint64_t flags = 0;
int r = m_image_ctx->get_flags(m_current_snap_id, &flags);
if (r < 0) {
image_locker->unlock();
lderr(cct) << "failed to retrieve image flags: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
image_locker->unlock();
if ((flags & RBD_FLAG_FAST_DIFF_INVALID) != 0) {
ldout(cct, 1) << "cannot perform fast diff on invalid object map"
<< dendl;
finish(-EINVAL);
return;
}
std::string oid(ObjectMap<>::object_map_name(m_image_ctx->id,
m_current_snap_id));
librados::ObjectReadOperation op;
cls_client::object_map_load_start(&op);
m_out_bl.clear();
auto aio_comp = create_rados_callback<
DiffRequest<I>, &DiffRequest<I>::handle_load_object_map>(this);
r = m_image_ctx->md_ctx.aio_operate(oid, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void DiffRequest<I>::handle_load_object_map(int r) {
auto cct = m_image_ctx->cct;
ldout(cct, 10) << "r=" << r << dendl;
if (r == 0) {
auto bl_it = m_out_bl.cbegin();
r = cls_client::object_map_load_finish(&bl_it, &m_object_map);
}
std::string oid(ObjectMap<>::object_map_name(m_image_ctx->id,
m_current_snap_id));
if (r == -ENOENT && m_ignore_enoent) {
ldout(cct, 10) << "object map " << oid << " does not exist" << dendl;
std::shared_lock image_locker{m_image_ctx->image_lock};
load_object_map(&image_locker);
return;
} else if (r < 0) {
lderr(cct) << "failed to load object map: " << oid << dendl;
finish(r);
return;
}
ldout(cct, 20) << "loaded object map " << oid << dendl;
uint64_t num_objs = Striper::get_num_objects(m_image_ctx->layout,
m_current_size);
if (m_object_map.size() < num_objs) {
ldout(cct, 1) << "object map too small: "
<< m_object_map.size() << " < " << num_objs << dendl;
finish(-EINVAL);
return;
} else {
m_object_map.resize(num_objs);
}
uint64_t prev_object_diff_state_size = m_object_diff_state->size();
if (prev_object_diff_state_size < num_objs) {
// the diff state should be the largest of all snapshots in the set
m_object_diff_state->resize(num_objs);
}
if (m_object_map.size() < m_object_diff_state->size()) {
// the image was shrunk so expanding the object map will flag end objects
// as non-existent and they will be compared against the previous object
// diff state
m_object_map.resize(m_object_diff_state->size());
}
uint64_t overlap = std::min(m_object_map.size(), prev_object_diff_state_size);
auto it = m_object_map.begin();
auto overlap_end_it = it + overlap;
auto diff_it = m_object_diff_state->begin();
uint64_t i = 0;
for (; it != overlap_end_it; ++it, ++diff_it, ++i) {
uint8_t object_map_state = *it;
uint8_t prev_object_diff_state = *diff_it;
if (object_map_state == OBJECT_EXISTS ||
object_map_state == OBJECT_PENDING ||
(object_map_state == OBJECT_EXISTS_CLEAN &&
prev_object_diff_state != DIFF_STATE_DATA &&
prev_object_diff_state != DIFF_STATE_DATA_UPDATED)) {
*diff_it = DIFF_STATE_DATA_UPDATED;
} else if (object_map_state == OBJECT_NONEXISTENT &&
prev_object_diff_state != DIFF_STATE_HOLE &&
prev_object_diff_state != DIFF_STATE_HOLE_UPDATED) {
*diff_it = DIFF_STATE_HOLE_UPDATED;
}
ldout(cct, 20) << "object state: " << i << " "
<< static_cast<uint32_t>(prev_object_diff_state)
<< "->" << static_cast<uint32_t>(*diff_it) << " ("
<< static_cast<uint32_t>(object_map_state) << ")"
<< dendl;
}
ldout(cct, 20) << "computed overlap diffs" << dendl;
bool diff_from_start = (m_snap_id_start == 0);
auto end_it = m_object_map.end();
if (m_object_map.size() > prev_object_diff_state_size) {
for (; it != end_it; ++it,++diff_it, ++i) {
uint8_t object_map_state = *it;
if (object_map_state == OBJECT_NONEXISTENT) {
*diff_it = DIFF_STATE_HOLE;
} else if (diff_from_start ||
(m_object_diff_state_valid &&
object_map_state != OBJECT_EXISTS_CLEAN)) {
*diff_it = DIFF_STATE_DATA_UPDATED;
} else {
*diff_it = DIFF_STATE_DATA;
}
ldout(cct, 20) << "object state: " << i << " "
<< "->" << static_cast<uint32_t>(*diff_it) << " ("
<< static_cast<uint32_t>(*it) << ")" << dendl;
}
}
ldout(cct, 20) << "computed resize diffs" << dendl;
m_object_diff_state_valid = true;
std::shared_lock image_locker{m_image_ctx->image_lock};
load_object_map(&image_locker);
}
template <typename I>
void DiffRequest<I>::finish(int r) {
auto cct = m_image_ctx->cct;
ldout(cct, 10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::DiffRequest<librbd::ImageCtx>;
| 8,171 | 30.552124 | 80 |
cc
|
null |
ceph-main/src/librbd/object_map/DiffRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_DIFF_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_DIFF_REQUEST_H
#include "include/int_types.h"
#include "common/bit_vector.hpp"
#include "common/ceph_mutex.h"
#include "librbd/object_map/Types.h"
#include <set>
struct Context;
namespace librbd {
struct ImageCtx;
namespace object_map {
template <typename ImageCtxT>
class DiffRequest {
public:
static DiffRequest* create(ImageCtxT* image_ctx, uint64_t snap_id_start,
uint64_t snap_id_end,
BitVector<2>* object_diff_state,
Context* on_finish) {
return new DiffRequest(image_ctx, snap_id_start, snap_id_end,
object_diff_state, on_finish);
}
DiffRequest(ImageCtxT* image_ctx, uint64_t snap_id_start,
uint64_t snap_id_end, BitVector<2>* object_diff_state,
Context* on_finish)
: m_image_ctx(image_ctx), m_snap_id_start(snap_id_start),
m_snap_id_end(snap_id_end), m_object_diff_state(object_diff_state),
m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* | /---------\
* | | |
* v v |
* LOAD_OBJECT_MAP ---/
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT* m_image_ctx;
uint64_t m_snap_id_start;
uint64_t m_snap_id_end;
BitVector<2>* m_object_diff_state;
Context* m_on_finish;
std::set<uint64_t> m_snap_ids;
uint64_t m_current_snap_id = 0;
bool m_ignore_enoent = false;
uint64_t m_current_size = 0;
BitVector<2> m_object_map;
bool m_object_diff_state_valid = false;
bufferlist m_out_bl;
void load_object_map(std::shared_lock<ceph::shared_mutex>* image_locker);
void handle_load_object_map(int r);
void finish(int r);
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::DiffRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_DIFF_REQUEST_H
| 2,104 | 22.920455 | 75 |
h
|
null |
ceph-main/src/librbd/object_map/InvalidateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/InvalidateRequest.h"
#include "common/dout.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::InvalidateRequest: "
namespace librbd {
namespace object_map {
template <typename I>
InvalidateRequest<I>* InvalidateRequest<I>::create(I &image_ctx,
uint64_t snap_id, bool force,
Context *on_finish) {
return new InvalidateRequest<I>(image_ctx, snap_id, force, on_finish);
}
template <typename I>
void InvalidateRequest<I>::send() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ceph_assert(ceph_mutex_is_wlocked(image_ctx.image_lock));
uint64_t snap_flags;
int r = image_ctx.get_flags(m_snap_id, &snap_flags);
if (r < 0 || ((snap_flags & RBD_FLAG_OBJECT_MAP_INVALID) != 0)) {
this->async_complete(r);
return;
}
CephContext *cct = image_ctx.cct;
lderr(cct) << this << " invalidating object map in-memory" << dendl;
// update in-memory flags
uint64_t flags = RBD_FLAG_OBJECT_MAP_INVALID;
if ((image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
flags |= RBD_FLAG_FAST_DIFF_INVALID;
}
r = image_ctx.update_flags(m_snap_id, flags, true);
if (r < 0) {
this->async_complete(r);
return;
}
// do not update on-disk flags if not image owner
if (image_ctx.image_watcher == nullptr ||
(!m_force && m_snap_id == CEPH_NOSNAP &&
image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner())) {
this->async_complete(-EROFS);
return;
}
lderr(cct) << this << " invalidating object map on-disk" << dendl;
librados::ObjectWriteOperation op;
cls_client::set_flags(&op, m_snap_id, flags, flags);
librados::AioCompletion *rados_completion =
this->create_callback_completion();
r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, rados_completion,
&op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
bool InvalidateRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
lderr(cct) << this << " " << __func__ << ": r=" << r << dendl;
return true;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::InvalidateRequest<librbd::ImageCtx>;
| 2,600 | 29.964286 | 80 |
cc
|
null |
ceph-main/src/librbd/object_map/InvalidateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_INVALIDATE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_INVALIDATE_REQUEST_H
#include "include/int_types.h"
#include "librbd/AsyncRequest.h"
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class InvalidateRequest : public AsyncRequest<ImageCtxT> {
public:
static InvalidateRequest* create(ImageCtxT &image_ctx, uint64_t snap_id,
bool force, Context *on_finish);
InvalidateRequest(ImageCtxT &image_ctx, uint64_t snap_id, bool force,
Context *on_finish)
: AsyncRequest<ImageCtxT>(image_ctx, on_finish),
m_snap_id(snap_id), m_force(force) {
}
void send() override;
protected:
bool should_complete(int r) override;
private:
uint64_t m_snap_id;
bool m_force;
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::InvalidateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_INVALIDATE_REQUEST_H
| 1,122 | 23.413043 | 78 |
h
|
null |
ceph-main/src/librbd/object_map/LockRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/LockRequest.h"
#include "cls/lock/cls_lock_client.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::LockRequest: "
namespace librbd {
namespace object_map {
using util::create_rados_callback;
template <typename I>
LockRequest<I>::LockRequest(I &image_ctx, Context *on_finish)
: m_image_ctx(image_ctx), m_on_finish(on_finish), m_broke_lock(false) {
}
template <typename I>
void LockRequest<I>::send() {
send_lock();
}
template <typename I>
void LockRequest<I>::send_lock() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
librados::ObjectWriteOperation op;
rados::cls::lock::lock(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "", "",
utime_t(), 0);
using klass = LockRequest<I>;
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_lock>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *LockRequest<I>::handle_lock(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val == 0) {
return m_on_finish;
} else if (*ret_val == -EEXIST) {
// already locked by myself
*ret_val = 0;
return m_on_finish;
} else if (m_broke_lock || *ret_val != -EBUSY) {
lderr(cct) << "failed to lock object map: " << cpp_strerror(*ret_val)
<< dendl;
*ret_val = 0;
return m_on_finish;
}
send_get_lock_info();
return nullptr;
}
template <typename I>
void LockRequest<I>::send_get_lock_info() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
librados::ObjectReadOperation op;
rados::cls::lock::get_lock_info_start(&op, RBD_LOCK_NAME);
using klass = LockRequest<I>;
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_get_lock_info>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op, &m_out_bl);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *LockRequest<I>::handle_get_lock_info(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val == -ENOENT) {
send_lock();
return nullptr;
}
ClsLockType lock_type;
std::string lock_tag;
if (*ret_val == 0) {
auto it = m_out_bl.cbegin();
*ret_val = rados::cls::lock::get_lock_info_finish(&it, &m_lockers,
&lock_type, &lock_tag);
}
if (*ret_val < 0) {
lderr(cct) << "failed to list object map locks: " << cpp_strerror(*ret_val)
<< dendl;
*ret_val = 0;
return m_on_finish;
}
send_break_locks();
return nullptr;
}
template <typename I>
void LockRequest<I>::send_break_locks() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << ", "
<< "num_lockers=" << m_lockers.size() << dendl;
librados::ObjectWriteOperation op;
for (auto &locker : m_lockers) {
rados::cls::lock::break_lock(&op, RBD_LOCK_NAME, locker.first.cookie,
locker.first.locker);
}
using klass = LockRequest<I>;
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_break_locks>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *LockRequest<I>::handle_break_locks(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
m_broke_lock = true;
if (*ret_val == 0 || *ret_val == -ENOENT) {
send_lock();
return nullptr;
}
lderr(cct) << "failed to break object map lock: " << cpp_strerror(*ret_val)
<< dendl;
*ret_val = 0;
return m_on_finish;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::LockRequest<librbd::ImageCtx>;
| 4,758 | 29.120253 | 80 |
cc
|
null |
ceph-main/src/librbd/object_map/LockRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_LOCK_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_LOCK_REQUEST_H
#include "include/buffer.h"
#include "cls/lock/cls_lock_types.h"
#include <map>
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class LockRequest {
public:
static LockRequest* create(ImageCtxT &image_ctx, Context *on_finish) {
return new LockRequest(image_ctx, on_finish);
}
LockRequest(ImageCtxT &image_ctx, Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start> /------------------------------------- BREAK_LOCKS * * *
* | | ^ *
* | | | *
* | | | *
* | v (EBUSY && !broke_lock) | *
* \---------> LOCK_OBJECT_MAP * * * * * * * * * * * > GET_LOCK_INFO * *
* | * ^ * *
* | * * * *
* | * * (ENOENT) * *
* | * * * * * * * * * * * * * * * * * *
* | * *
* | * (other errors) *
* | * *
* v v (other errors) *
* <finish> < * * * * * * * * * * * * * * * * * * * * * * * *
*
* @endverbatim
*/
ImageCtxT &m_image_ctx;
Context *m_on_finish;
bool m_broke_lock;
std::map<rados::cls::lock::locker_id_t,
rados::cls::lock::locker_info_t> m_lockers;
bufferlist m_out_bl;
void send_lock();
Context *handle_lock(int *ret_val);
void send_get_lock_info();
Context *handle_get_lock_info(int *ret_val);
void send_break_locks();
Context *handle_break_locks(int *ret_val);
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::LockRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_LOCK_REQUEST_H
| 2,431 | 31 | 77 |
h
|
null |
ceph-main/src/librbd/object_map/RefreshRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/RefreshRequest.h"
#include "cls/lock/cls_lock_client.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/object_map/InvalidateRequest.h"
#include "librbd/object_map/LockRequest.h"
#include "librbd/object_map/ResizeRequest.h"
#include "librbd/Utils.h"
#include "osdc/Striper.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::RefreshRequest: "
namespace librbd {
using util::create_context_callback;
using util::create_rados_callback;
namespace object_map {
template <typename I>
RefreshRequest<I>::RefreshRequest(I &image_ctx, ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map,
uint64_t snap_id, Context *on_finish)
: m_image_ctx(image_ctx), m_object_map_lock(object_map_lock),
m_object_map(object_map), m_snap_id(snap_id), m_on_finish(on_finish),
m_object_count(0), m_truncate_on_disk_object_map(false) {
}
template <typename I>
void RefreshRequest<I>::send() {
{
std::shared_lock 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));
}
CephContext *cct = m_image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": "
<< "object_count=" << m_object_count << dendl;
send_lock();
}
template <typename I>
void RefreshRequest<I>::apply() {
uint64_t num_objs;
{
std::shared_lock 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));
}
ceph_assert(m_on_disk_object_map.size() >= num_objs);
std::unique_lock object_map_locker{*m_object_map_lock};
*m_object_map = m_on_disk_object_map;
}
template <typename I>
void RefreshRequest<I>::send_lock() {
CephContext *cct = m_image_ctx.cct;
if (m_object_count > cls::rbd::MAX_OBJECT_MAP_OBJECT_COUNT) {
send_invalidate_and_close();
return;
} else if (m_snap_id != CEPH_NOSNAP) {
send_load();
return;
}
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
using klass = RefreshRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_lock>(this);
LockRequest<I> *req = LockRequest<I>::create(m_image_ctx, ctx);
req->send();
}
template <typename I>
Context *RefreshRequest<I>::handle_lock(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
ceph_assert(*ret_val == 0);
send_load();
return nullptr;
}
template <typename I>
void RefreshRequest<I>::send_load() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
librados::ObjectReadOperation op;
cls_client::object_map_load_start(&op);
using klass = RefreshRequest<I>;
m_out_bl.clear();
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_load>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op, &m_out_bl);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *RefreshRequest<I>::handle_load(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val == 0) {
auto bl_it = m_out_bl.cbegin();
*ret_val = cls_client::object_map_load_finish(&bl_it,
&m_on_disk_object_map);
}
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
if (*ret_val == -EINVAL) {
// object map is corrupt on-disk -- clear it and properly size it
// so future IO can keep the object map in sync
lderr(cct) << "object map corrupt on-disk: " << oid << dendl;
m_truncate_on_disk_object_map = true;
send_resize_invalidate();
return nullptr;
} else if (*ret_val < 0) {
lderr(cct) << "failed to load object map: " << oid << dendl;
if (*ret_val == -ETIMEDOUT &&
!cct->_conf.get_val<bool>("rbd_invalidate_object_map_on_timeout")) {
return m_on_finish;
}
send_invalidate();
return nullptr;
}
if (m_on_disk_object_map.size() < m_object_count) {
lderr(cct) << "object map smaller than current object count: "
<< m_on_disk_object_map.size() << " != "
<< m_object_count << dendl;
send_resize_invalidate();
return nullptr;
}
ldout(cct, 20) << "refreshed object map: num_objs="
<< m_on_disk_object_map.size() << dendl;
if (m_on_disk_object_map.size() > m_object_count) {
// resize op might have been interrupted
ldout(cct, 1) << "object map larger than current object count: "
<< m_on_disk_object_map.size() << " != "
<< m_object_count << dendl;
}
apply();
return m_on_finish;
}
template <typename I>
void RefreshRequest<I>::send_invalidate() {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
m_on_disk_object_map.clear();
object_map::ResizeRequest::resize(&m_on_disk_object_map, m_object_count,
OBJECT_EXISTS);
using klass = RefreshRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_invalidate>(this);
InvalidateRequest<I> *req = InvalidateRequest<I>::create(
m_image_ctx, m_snap_id, true, ctx);
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
req->send();
}
template <typename I>
Context *RefreshRequest<I>::handle_invalidate(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val < 0) {
lderr(cct) << "failed to invalidate object map: " << cpp_strerror(*ret_val)
<< dendl;
}
apply();
return m_on_finish;
}
template <typename I>
void RefreshRequest<I>::send_resize_invalidate() {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
m_on_disk_object_map.clear();
object_map::ResizeRequest::resize(&m_on_disk_object_map, m_object_count,
OBJECT_EXISTS);
using klass = RefreshRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_resize_invalidate>(this);
InvalidateRequest<I> *req = InvalidateRequest<I>::create(
m_image_ctx, m_snap_id, true, ctx);
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
req->send();
}
template <typename I>
Context *RefreshRequest<I>::handle_resize_invalidate(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val < 0) {
lderr(cct) << "failed to invalidate object map: " << cpp_strerror(*ret_val)
<< dendl;
apply();
return m_on_finish;
}
send_resize();
return nullptr;
}
template <typename I>
void RefreshRequest<I>::send_resize() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
librados::ObjectWriteOperation op;
if (m_snap_id == CEPH_NOSNAP) {
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
}
if (m_truncate_on_disk_object_map) {
op.truncate(0);
}
cls_client::object_map_resize(&op, m_object_count, OBJECT_NONEXISTENT);
using klass = RefreshRequest<I>;
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_resize>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *RefreshRequest<I>::handle_resize(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val < 0) {
lderr(cct) << "failed to adjust object map size: " << cpp_strerror(*ret_val)
<< dendl;
*ret_val = 0;
}
apply();
return m_on_finish;
}
template <typename I>
void RefreshRequest<I>::send_invalidate_and_close() {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
using klass = RefreshRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_invalidate_and_close>(this);
InvalidateRequest<I> *req = InvalidateRequest<I>::create(
m_image_ctx, m_snap_id, false, ctx);
lderr(cct) << "object map too large: " << m_object_count << dendl;
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
req->send();
}
template <typename I>
Context *RefreshRequest<I>::handle_invalidate_and_close(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val < 0) {
lderr(cct) << "failed to invalidate object map: " << cpp_strerror(*ret_val)
<< dendl;
} else {
*ret_val = -EFBIG;
}
std::unique_lock object_map_locker{*m_object_map_lock};
m_object_map->clear();
return m_on_finish;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::RefreshRequest<librbd::ImageCtx>;
| 9,804 | 30.426282 | 88 |
cc
|
null |
ceph-main/src/librbd/object_map/RefreshRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_REFRESH_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_REFRESH_REQUEST_H
#include "include/int_types.h"
#include "include/buffer.h"
#include "common/bit_vector.hpp"
#include "common/ceph_mutex.h"
class Context;
class RWLock;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class RefreshRequest {
public:
static RefreshRequest *create(ImageCtxT &image_ctx,
ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map,
uint64_t snap_id, Context *on_finish) {
return new RefreshRequest(image_ctx, object_map_lock, object_map, snap_id,
on_finish);
}
RefreshRequest(ImageCtxT &image_ctx, ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map, uint64_t snap_id,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start> -----> LOCK (skip if snapshot)
* * |
* * v (other errors)
* * LOAD * * * * * * * > INVALIDATE ------------\
* * | * |
* * | * (-EINVAL or too small) |
* * | * * * * * * > INVALIDATE_AND_RESIZE |
* * | | * |
* * | | * |
* * | v * |
* * | RESIZE * |
* * | | * |
* * | | * * * * * * * |
* * | | * |
* * | v v |
* * \--------------------> LOCK <-------------/
* * |
* v v
* INVALIDATE_AND_CLOSE ---------------> <finish>
*
* @endverbatim
*/
ImageCtxT &m_image_ctx;
ceph::shared_mutex* m_object_map_lock;
ceph::BitVector<2> *m_object_map;
uint64_t m_snap_id;
Context *m_on_finish;
uint64_t m_object_count;
ceph::BitVector<2> m_on_disk_object_map;
bool m_truncate_on_disk_object_map;
bufferlist m_out_bl;
void send_lock();
Context *handle_lock(int *ret_val);
void send_load();
Context *handle_load(int *ret_val);
void send_invalidate();
Context *handle_invalidate(int *ret_val);
void send_resize_invalidate();
Context *handle_resize_invalidate(int *ret_val);
void send_resize();
Context *handle_resize(int *ret_val);
void send_invalidate_and_close();
Context *handle_invalidate_and_close(int *ret_val);
void apply();
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::RefreshRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_REFRESH_REQUEST_H
| 3,126 | 29.359223 | 78 |
h
|
null |
ceph-main/src/librbd/object_map/RemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/RemoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::RemoveRequest: "
namespace librbd {
namespace object_map {
using util::create_rados_callback;
template <typename I>
RemoveRequest<I>::RemoveRequest(I *image_ctx, Context *on_finish)
: m_image_ctx(image_ctx), m_on_finish(on_finish) {
}
template <typename I>
void RemoveRequest<I>::send() {
send_remove_object_map();
}
template <typename I>
void RemoveRequest<I>::send_remove_object_map() {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << dendl;
std::unique_lock 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) {
snap_ids.push_back(it.first);
}
std::lock_guard locker{m_lock};
ceph_assert(m_ref_counter == 0);
for (auto snap_id : snap_ids) {
m_ref_counter++;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx->id, snap_id));
using klass = RemoveRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_remove_object_map>(this);
int r = m_image_ctx->md_ctx.aio_remove(oid, comp);
ceph_assert(r == 0);
comp->release();
}
}
template <typename I>
Context *RemoveRequest<I>::handle_remove_object_map(int *result) {
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << ": r=" << *result << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_ref_counter > 0);
m_ref_counter--;
if (*result < 0 && *result != -ENOENT) {
lderr(cct) << "failed to remove object map: " << cpp_strerror(*result)
<< dendl;
m_error_result = *result;
}
if (m_ref_counter > 0) {
return nullptr;
}
}
if (m_error_result < 0) {
*result = m_error_result;
}
return m_on_finish;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::RemoveRequest<librbd::ImageCtx>;
| 2,326 | 25.146067 | 76 |
cc
|
null |
ceph-main/src/librbd/object_map/RemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_REMOVE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_REMOVE_REQUEST_H
#include "include/buffer.h"
#include "common/ceph_mutex.h"
#include <map>
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class RemoveRequest {
public:
static RemoveRequest *create(ImageCtxT *image_ctx, Context *on_finish) {
return new RemoveRequest(image_ctx, on_finish);
}
void send();
private:
/**
* @verbatim
*
* <start>
* | . . .
* v v .
* REMOVE_OBJECT_MAP . (for every snapshot)
* | . .
* v . . .
* <finis>
*
* @endverbatim
*/
RemoveRequest(ImageCtxT *image_ctx, Context *on_finish);
ImageCtxT *m_image_ctx;
Context *m_on_finish;
int m_error_result = 0;
int m_ref_counter = 0;
mutable ceph::mutex m_lock =
ceph::make_mutex("object_map::RemoveRequest::m_lock");
void send_remove_object_map();
Context *handle_remove_object_map(int *result);
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::RemoveRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_REMOVE_REQUEST_H
| 1,347 | 20.0625 | 74 |
h
|
null |
ceph-main/src/librbd/object_map/Request.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/Request.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/RWLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/object_map/InvalidateRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::Request: "
namespace librbd {
namespace object_map {
bool Request::should_complete(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 20) << this << " should_complete: r=" << r << dendl;
switch (m_state)
{
case STATE_REQUEST:
if (r == -ETIMEDOUT &&
!cct->_conf.get_val<bool>("rbd_invalidate_object_map_on_timeout")) {
m_state = STATE_TIMEOUT;
return true;
} else if (r < 0) {
lderr(cct) << "failed to update object map: " << cpp_strerror(r)
<< dendl;
return invalidate();
}
finish_request();
return true;
case STATE_INVALIDATE:
ldout(cct, 20) << "INVALIDATE" << dendl;
if (r < 0) {
lderr(cct) << "failed to invalidate object map: " << cpp_strerror(r)
<< dendl;
}
return true;
default:
lderr(cct) << "invalid state: " << m_state << dendl;
ceph_abort();
break;
}
return false;
}
bool Request::invalidate() {
bool flags_set;
int r = m_image_ctx.test_flags(m_snap_id, RBD_FLAG_OBJECT_MAP_INVALID,
&flags_set);
if (r < 0 || flags_set) {
return true;
}
m_state = STATE_INVALIDATE;
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
InvalidateRequest<> *req = new InvalidateRequest<>(m_image_ctx, m_snap_id,
true,
create_callback_context());
req->send();
return false;
}
} // namespace object_map
} // namespace librbd
| 1,960 | 25.146667 | 80 |
cc
|
null |
ceph-main/src/librbd/object_map/Request.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_REQUEST_H
#include "include/int_types.h"
#include "librbd/AsyncRequest.h"
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
class Request : public AsyncRequest<> {
public:
Request(ImageCtx &image_ctx, uint64_t snap_id, Context *on_finish)
: AsyncRequest(image_ctx, on_finish), m_snap_id(snap_id),
m_state(STATE_REQUEST)
{
}
void send() override = 0;
protected:
const uint64_t m_snap_id;
bool should_complete(int r) override;
int filter_return_code(int r) const override {
if (m_state == STATE_REQUEST) {
// never propagate an error back to the caller
return 0;
}
return r;
}
virtual void finish_request() {
}
private:
/**
* STATE_TIMEOUT --------\
* ^ |
* | v
* <start> ---> STATE_REQUEST ---> <finish>
* | ^
* v |
* STATE_INVALIDATE -------/
*/
enum State {
STATE_REQUEST,
STATE_TIMEOUT,
STATE_INVALIDATE
};
State m_state;
bool invalidate();
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_REQUEST_H
| 1,401 | 19.925373 | 70 |
h
|
null |
ceph-main/src/librbd/object_map/ResizeRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/ResizeRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "osdc/Striper.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "cls/lock/cls_lock_client.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::ResizeRequest: "
namespace librbd {
namespace object_map {
void ResizeRequest::resize(ceph::BitVector<2> *object_map, uint64_t num_objs,
uint8_t default_state) {
size_t orig_object_map_size = object_map->size();
object_map->resize(num_objs);
if (num_objs > orig_object_map_size) {
auto it = object_map->begin() + orig_object_map_size;
auto end_it = object_map->begin() + num_objs;
for (;it != end_it; ++it) {
*it = default_state;
}
}
}
void ResizeRequest::send() {
CephContext *cct = m_image_ctx.cct;
std::unique_lock l{*m_object_map_lock};
m_num_objs = Striper::get_num_objects(m_image_ctx.layout, m_new_size);
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 5) << this << " resizing on-disk object map: "
<< "ictx=" << &m_image_ctx << ", "
<< "oid=" << oid << ", num_objs=" << m_num_objs << dendl;
librados::ObjectWriteOperation op;
if (m_snap_id == CEPH_NOSNAP) {
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
}
cls_client::object_map_resize(&op, m_num_objs, m_default_object_state);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
void ResizeRequest::finish_request() {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " resizing in-memory object map: "
<< m_num_objs << dendl;
std::unique_lock object_map_locker{*m_object_map_lock};
resize(m_object_map, m_num_objs, m_default_object_state);
}
} // namespace object_map
} // namespace librbd
| 2,144 | 31.5 | 88 |
cc
|
null |
ceph-main/src/librbd/object_map/ResizeRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_RESIZE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_RESIZE_REQUEST_H
#include "include/int_types.h"
#include "librbd/object_map/Request.h"
#include "common/bit_vector.hpp"
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
class ResizeRequest : public Request {
public:
ResizeRequest(ImageCtx &image_ctx, ceph::shared_mutex *object_map_lock,
ceph::BitVector<2> *object_map, uint64_t snap_id,
uint64_t new_size, uint8_t default_object_state,
Context *on_finish)
: Request(image_ctx, snap_id, on_finish),
m_object_map_lock(object_map_lock), m_object_map(object_map),
m_num_objs(0), m_new_size(new_size),
m_default_object_state(default_object_state)
{
}
static void resize(ceph::BitVector<2> *object_map, uint64_t num_objs,
uint8_t default_state);
void send() override;
protected:
void finish_request() override;
private:
ceph::shared_mutex* m_object_map_lock;
ceph::BitVector<2> *m_object_map;
uint64_t m_num_objs;
uint64_t m_new_size;
uint8_t m_default_object_state;
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_RESIZE_REQUEST_H
| 1,340 | 24.788462 | 73 |
h
|
null |
ceph-main/src/librbd/object_map/SnapshotCreateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/SnapshotCreateRequest.h"
#include "common/dout.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "cls/lock/cls_lock_client.h"
#include <iostream>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::SnapshotCreateRequest: "
namespace librbd {
namespace object_map {
namespace {
std::ostream& operator<<(std::ostream& os,
const SnapshotCreateRequest::State& state) {
switch(state) {
case SnapshotCreateRequest::STATE_READ_MAP:
os << "READ_MAP";
break;
case SnapshotCreateRequest::STATE_WRITE_MAP:
os << "WRITE_MAP";
break;
case SnapshotCreateRequest::STATE_ADD_SNAPSHOT:
os << "ADD_SNAPSHOT";
break;
default:
os << "UNKNOWN (" << static_cast<uint32_t>(state) << ")";
break;
}
return os;
}
} // anonymous namespace
void SnapshotCreateRequest::send() {
send_read_map();
}
bool SnapshotCreateRequest::should_complete(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
if (r < 0 && m_ret_val == 0) {
m_ret_val = r;
}
if (m_ret_val < 0) {
// pass errors down to base class to invalidate the object map
return Request::should_complete(r);
}
std::shared_lock owner_locker{m_image_ctx.owner_lock};
bool finished = false;
switch (m_state) {
case STATE_READ_MAP:
send_write_map();
break;
case STATE_WRITE_MAP:
finished = send_add_snapshot();
break;
case STATE_ADD_SNAPSHOT:
update_object_map();
finished = true;
break;
default:
ceph_abort();
break;
}
return finished;
}
void SnapshotCreateRequest::send_read_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 5) << this << " " << __func__ << ": oid=" << oid << dendl;
m_state = STATE_READ_MAP;
// IO is blocked due to the snapshot creation -- consistent to read from disk
librados::ObjectReadOperation op;
op.read(0, 0, NULL, NULL);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op,
&m_read_bl);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotCreateRequest::send_write_map() {
CephContext *cct = m_image_ctx.cct;
std::string snap_oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 5) << this << " " << __func__ << ": snap_oid=" << snap_oid
<< dendl;
m_state = STATE_WRITE_MAP;
librados::ObjectWriteOperation op;
op.write_full(m_read_bl);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(snap_oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
bool SnapshotCreateRequest::send_add_snapshot() {
std::shared_lock image_locker{m_image_ctx.image_lock};
if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) == 0) {
return true;
}
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 5) << this << " " << __func__ << ": oid=" << oid << dendl;
m_state = STATE_ADD_SNAPSHOT;
librados::ObjectWriteOperation op;
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
cls_client::object_map_snap_add(&op);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
return false;
}
void SnapshotCreateRequest::update_object_map() {
std::unique_lock object_map_locker{*m_object_map_lock};
auto it = m_object_map.begin();
auto end_it = m_object_map.end();
for (; it != end_it; ++it) {
if (*it == OBJECT_EXISTS) {
*it = OBJECT_EXISTS_CLEAN;
}
}
}
} // namespace object_map
} // namespace librbd
| 4,253 | 27.743243 | 86 |
cc
|
null |
ceph-main/src/librbd/object_map/SnapshotCreateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_CREATE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_CREATE_REQUEST_H
#include "include/int_types.h"
#include "common/bit_vector.hpp"
#include "librbd/object_map/Request.h"
class Context;
class RWLock;
namespace librbd {
class ImageCtx;
namespace object_map {
class SnapshotCreateRequest : public Request {
public:
/**
* Snapshot create goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_READ_MAP
* |
* v (skip)
* STATE_WRITE_MAP . . . . . . .
* | .
* v v
* STATE_ADD_SNAPSHOT ---> <finish>
*
* @endverbatim
*
* The _ADD_SNAPSHOT state is skipped if the FAST_DIFF feature isn't enabled.
*/
enum State {
STATE_READ_MAP,
STATE_WRITE_MAP,
STATE_ADD_SNAPSHOT
};
SnapshotCreateRequest(ImageCtx &image_ctx, ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map, uint64_t snap_id,
Context *on_finish)
: Request(image_ctx, snap_id, on_finish),
m_object_map_lock(object_map_lock), m_object_map(*object_map),
m_ret_val(0) {
}
void send() override;
protected:
bool should_complete(int r) override;
private:
ceph::shared_mutex* m_object_map_lock;
ceph::BitVector<2> &m_object_map;
State m_state = STATE_READ_MAP;
bufferlist m_read_bl;
int m_ret_val;
void send_read_map();
void send_write_map();
bool send_add_snapshot();
void update_object_map();
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_CREATE_REQUEST_H
| 1,791 | 21.123457 | 81 |
h
|
null |
ceph-main/src/librbd/object_map/SnapshotRemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/SnapshotRemoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/object_map/InvalidateRequest.h"
#include "cls/lock/cls_lock_client.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::SnapshotRemoveRequest: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace object_map {
void SnapshotRemoveRequest::send() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
ceph_assert(ceph_mutex_is_wlocked(m_image_ctx.image_lock));
if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
int r = m_image_ctx.get_flags(m_snap_id, &m_flags);
ceph_assert(r == 0);
compute_next_snap_id();
load_map();
} else {
remove_map();
}
}
void SnapshotRemoveRequest::load_map() {
CephContext *cct = m_image_ctx.cct;
std::string snap_oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 5) << "snap_oid=" << snap_oid << dendl;
librados::ObjectReadOperation op;
cls_client::object_map_load_start(&op);
auto rados_completion = librbd::util::create_rados_callback<
SnapshotRemoveRequest, &SnapshotRemoveRequest::handle_load_map>(this);
int r = m_image_ctx.md_ctx.aio_operate(snap_oid, rados_completion, &op,
&m_out_bl);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotRemoveRequest::handle_load_map(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == 0) {
auto it = m_out_bl.cbegin();
r = cls_client::object_map_load_finish(&it, &m_snap_object_map);
}
if (r == -ENOENT) {
// implies we have already deleted this snapshot and handled the
// necessary fast-diff cleanup
complete(0);
return;
} else if (r < 0) {
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
lderr(cct) << "failed to load object map " << oid << ": "
<< cpp_strerror(r) << dendl;
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
invalidate_next_map();
return;
}
remove_snapshot();
}
void SnapshotRemoveRequest::remove_snapshot() {
if ((m_flags & RBD_FLAG_OBJECT_MAP_INVALID) != 0) {
// snapshot object map exists on disk but is invalid. cannot clean fast-diff
// on next snapshot if current snapshot was invalid.
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
invalidate_next_map();
return;
}
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_next_snap_id));
ldout(cct, 5) << "oid=" << oid << dendl;
librados::ObjectWriteOperation op;
if (m_next_snap_id == CEPH_NOSNAP) {
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
}
cls_client::object_map_snap_remove(&op, m_snap_object_map);
auto rados_completion = librbd::util::create_rados_callback<
SnapshotRemoveRequest,
&SnapshotRemoveRequest::handle_remove_snapshot>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotRemoveRequest::handle_remove_snapshot(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id,
m_next_snap_id));
lderr(cct) << "failed to remove object map snapshot " << oid << ": "
<< cpp_strerror(r) << dendl;
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
invalidate_next_map();
return;
}
std::shared_lock image_locker{m_image_ctx.image_lock};
update_object_map();
remove_map();
}
void SnapshotRemoveRequest::invalidate_next_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
ceph_assert(ceph_mutex_is_wlocked(m_image_ctx.image_lock));
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << dendl;
auto ctx = librbd::util::create_context_callback<
SnapshotRemoveRequest,
&SnapshotRemoveRequest::handle_invalidate_next_map>(this);
InvalidateRequest<> *req = new InvalidateRequest<>(m_image_ctx,
m_next_snap_id, true, ctx);
req->send();
}
void SnapshotRemoveRequest::handle_invalidate_next_map(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id,
m_next_snap_id));
lderr(cct) << "failed to invalidate object map " << oid << ": "
<< cpp_strerror(r) << dendl;
complete(r);
return;
}
remove_map();
}
void SnapshotRemoveRequest::remove_map() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 5) << "oid=" << oid << dendl;
librados::ObjectWriteOperation op;
op.remove();
auto rados_completion = librbd::util::create_rados_callback<
SnapshotRemoveRequest, &SnapshotRemoveRequest::handle_remove_map>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotRemoveRequest::handle_remove_map(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
lderr(cct) << "failed to remove object map " << oid << ": "
<< cpp_strerror(r) << dendl;
complete(r);
return;
}
complete(0);
}
void SnapshotRemoveRequest::compute_next_snap_id() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
m_next_snap_id = CEPH_NOSNAP;
std::map<librados::snap_t, SnapInfo>::const_iterator it =
m_image_ctx.snap_info.find(m_snap_id);
ceph_assert(it != m_image_ctx.snap_info.end());
++it;
if (it != m_image_ctx.snap_info.end()) {
m_next_snap_id = it->first;
}
}
void SnapshotRemoveRequest::update_object_map() {
assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
std::unique_lock object_map_locker{*m_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;
ldout(cct, 5) << dendl;
auto it = m_object_map.begin();
auto end_it = m_object_map.end();
auto snap_it = m_snap_object_map.begin();
uint64_t i = 0;
for (; it != end_it; ++it) {
if (*it == OBJECT_EXISTS_CLEAN &&
(i >= m_snap_object_map.size() ||
*snap_it == OBJECT_EXISTS)) {
*it = OBJECT_EXISTS;
}
if (i < m_snap_object_map.size()) {
++snap_it;
}
++i;
}
}
}
} // namespace object_map
} // namespace librbd
| 7,246 | 30.785088 | 88 |
cc
|
null |
ceph-main/src/librbd/object_map/SnapshotRemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_REMOVE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_REMOVE_REQUEST_H
#include "include/int_types.h"
#include "include/buffer.h"
#include "common/bit_vector.hpp"
#include "librbd/AsyncRequest.h"
namespace librbd {
namespace object_map {
class SnapshotRemoveRequest : public AsyncRequest<> {
public:
/**
* Snapshot rollback goes through the following state machine:
*
* @verbatim
*
* <start> -----------> STATE_LOAD_MAP ----\
* . * |
* . * (error) |
* . (invalid object map) v |
* . . . > STATE_INVALIDATE_NEXT_MAP |
* . | |
* . | |
* . (fast diff disabled) v v
* . . . . . . . . . . > STATE_REMOVE_MAP
* |
* v
* <finish>
*
* @endverbatim
*
* The _LOAD_MAP state is skipped if the fast diff feature is disabled.
* If the fast diff feature is enabled and the snapshot is flagged as
* invalid, the next snapshot / HEAD object mapis flagged as invalid;
* otherwise, the state machine proceeds to remove the object map.
*/
SnapshotRemoveRequest(ImageCtx &image_ctx, ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map, uint64_t snap_id,
Context *on_finish)
: AsyncRequest(image_ctx, on_finish),
m_object_map_lock(object_map_lock), m_object_map(*object_map),
m_snap_id(snap_id), m_next_snap_id(CEPH_NOSNAP) {
}
void send() override;
protected:
bool should_complete(int r) override {
return true;
}
private:
ceph::shared_mutex* m_object_map_lock;
ceph::BitVector<2> &m_object_map;
uint64_t m_snap_id;
uint64_t m_next_snap_id;
uint64_t m_flags = 0;
ceph::BitVector<2> m_snap_object_map;
bufferlist m_out_bl;
void load_map();
void handle_load_map(int r);
void remove_snapshot();
void handle_remove_snapshot(int r);
void invalidate_next_map();
void handle_invalidate_next_map(int r);
void remove_map();
void handle_remove_map(int r);
void compute_next_snap_id();
void update_object_map();
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_REMOVE_REQUEST_H
| 2,517 | 27.292135 | 81 |
h
|
null |
ceph-main/src/librbd/object_map/SnapshotRollbackRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/SnapshotRollbackRequest.h"
#include "common/dout.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/object_map/InvalidateRequest.h"
#include "cls/lock/cls_lock_client.h"
#include <iostream>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::SnapshotRollbackRequest: "
namespace librbd {
namespace object_map {
namespace {
std::ostream& operator<<(std::ostream& os,
const SnapshotRollbackRequest::State& state) {
switch(state) {
case SnapshotRollbackRequest::STATE_READ_MAP:
os << "READ_MAP";
break;
case SnapshotRollbackRequest::STATE_INVALIDATE_MAP:
os << "INVALIDATE_MAP";
break;
case SnapshotRollbackRequest::STATE_WRITE_MAP:
os << "WRITE_MAP";
break;
default:
os << "UNKNOWN (" << static_cast<uint32_t>(state) << ")";
break;
}
return os;
}
} // anonymous namespace
void SnapshotRollbackRequest::send() {
send_read_map();
}
bool SnapshotRollbackRequest::should_complete(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
if (r < 0 && m_ret_val == 0) {
m_ret_val = r;
}
bool finished = false;
switch (m_state) {
case STATE_READ_MAP:
if (r < 0) {
// invalidate the snapshot object map
send_invalidate_map();
} else {
send_write_map();
}
break;
case STATE_INVALIDATE_MAP:
// invalidate the HEAD object map as well
finished = Request::should_complete(m_ret_val);
break;
case STATE_WRITE_MAP:
finished = Request::should_complete(r);
break;
default:
ceph_abort();
break;
}
return finished;
}
void SnapshotRollbackRequest::send_read_map() {
std::string snap_oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": snap_oid=" << snap_oid
<< dendl;
m_state = STATE_READ_MAP;
librados::ObjectReadOperation op;
op.read(0, 0, NULL, NULL);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(snap_oid, rados_completion, &op,
&m_read_bl);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotRollbackRequest::send_write_map() {
std::shared_lock owner_locker{m_image_ctx.owner_lock};
CephContext *cct = m_image_ctx.cct;
std::string snap_oid(ObjectMap<>::object_map_name(m_image_ctx.id,
CEPH_NOSNAP));
ldout(cct, 5) << this << " " << __func__ << ": snap_oid=" << snap_oid
<< dendl;
m_state = STATE_WRITE_MAP;
librados::ObjectWriteOperation op;
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
op.write_full(m_read_bl);
librados::AioCompletion *rados_completion = create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(snap_oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
void SnapshotRollbackRequest::send_invalidate_map() {
std::shared_lock owner_locker{m_image_ctx.owner_lock};
std::unique_lock image_locker{m_image_ctx.image_lock};
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_INVALIDATE_MAP;
InvalidateRequest<> *req = new InvalidateRequest<>(m_image_ctx, m_snap_id,
false,
create_callback_context());
req->send();
}
} // namespace object_map
} // namespace librbd
| 3,848 | 28.159091 | 86 |
cc
|
null |
ceph-main/src/librbd/object_map/SnapshotRollbackRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_ROLLBACK_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_ROLLBACK_REQUEST_H
#include "include/int_types.h"
#include "librbd/object_map/Request.h"
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
class SnapshotRollbackRequest : public Request {
public:
/**
* Snapshot rollback goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v (error)
* STATE_READ_MAP * * * * > STATE_INVALIDATE_MAP
* | |
* v v
* STATE_WRITE_MAP -------> <finish>
*
* @endverbatim
*
* If an error occurs within the READ_MAP state, the associated snapshot's
* object map will be flagged as invalid. Otherwise, an error from any state
* will result in the HEAD object map being flagged as invalid via the base
* class.
*/
enum State {
STATE_READ_MAP,
STATE_INVALIDATE_MAP,
STATE_WRITE_MAP
};
SnapshotRollbackRequest(ImageCtx &image_ctx, uint64_t snap_id,
Context *on_finish)
: Request(image_ctx, CEPH_NOSNAP, on_finish),
m_snap_id(snap_id), m_ret_val(0) {
ceph_assert(snap_id != CEPH_NOSNAP);
}
void send() override;
protected:
bool should_complete(int r) override;
private:
State m_state = STATE_READ_MAP;
uint64_t m_snap_id;
int m_ret_val;
bufferlist m_read_bl;
void send_read_map();
void send_invalidate_map();
void send_write_map();
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_SNAPSHOT_ROLLBACK_REQUEST_H
| 1,727 | 22.04 | 79 |
h
|
null |
ceph-main/src/librbd/object_map/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_TYPES_H
#define CEPH_LIBRBD_OBJECT_MAP_TYPES_H
namespace librbd {
namespace object_map {
enum DiffState {
DIFF_STATE_HOLE = 0, /* unchanged hole */
DIFF_STATE_DATA = 1, /* unchanged data */
DIFF_STATE_HOLE_UPDATED = 2, /* new hole */
DIFF_STATE_DATA_UPDATED = 3 /* new data */
};
} // namespace object_map
} // namespace librbd
#endif // CEPH_LIBRBD_OBJECT_MAP_TYPES_H
| 528 | 24.190476 | 70 |
h
|
null |
ceph-main/src/librbd/object_map/UnlockRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/UnlockRequest.h"
#include "cls/lock/cls_lock_client.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::UnlockRequest: "
namespace librbd {
namespace object_map {
using util::create_rados_callback;
template <typename I>
UnlockRequest<I>::UnlockRequest(I &image_ctx, Context *on_finish)
: m_image_ctx(image_ctx), m_on_finish(on_finish) {
}
template <typename I>
void UnlockRequest<I>::send() {
send_unlock();
}
template <typename I>
void UnlockRequest<I>::send_unlock() {
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
ldout(cct, 10) << this << " " << __func__ << ": oid=" << oid << dendl;
librados::ObjectWriteOperation op;
rados::cls::lock::unlock(&op, RBD_LOCK_NAME, "");
using klass = UnlockRequest<I>;
librados::AioCompletion *rados_completion =
create_rados_callback<klass, &klass::handle_unlock>(this);
int r = m_image_ctx.md_ctx.aio_operate(oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *UnlockRequest<I>::handle_unlock(int *ret_val) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val < 0 && *ret_val != -ENOENT) {
lderr(m_image_ctx.cct) << "failed to release object map lock: "
<< cpp_strerror(*ret_val) << dendl;
}
*ret_val = 0;
return m_on_finish;
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::UnlockRequest<librbd::ImageCtx>;
| 1,885 | 27.149254 | 77 |
cc
|
null |
ceph-main/src/librbd/object_map/UnlockRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_UNLOCK_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_UNLOCK_REQUEST_H
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = ImageCtx>
class UnlockRequest {
public:
static UnlockRequest *create(ImageCtxT &image_ctx, Context *on_finish) {
return new UnlockRequest(image_ctx, on_finish);
}
UnlockRequest(ImageCtxT &image_ctx, Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start> ----> UNLOCK ----> <finish>
*
* @endverbatim
*/
ImageCtxT &m_image_ctx;
Context *m_on_finish;
void send_unlock();
Context* handle_unlock(int *ret_val);
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::UnlockRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_UNLOCK_REQUEST_H
| 950 | 18.8125 | 74 |
h
|
null |
ceph-main/src/librbd/object_map/UpdateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/object_map/UpdateRequest.h"
#include "include/rbd/object_map_types.h"
#include "include/stringify.h"
#include "common/dout.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "cls/lock/cls_lock_client.h"
#include <string>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::object_map::UpdateRequest: " << this \
<< " " << __func__ << ": "
namespace librbd {
namespace object_map {
namespace {
// keep aligned to bit_vector 4K block sizes
const uint64_t MAX_OBJECTS_PER_UPDATE = 256 * (1 << 10);
}
template <typename I>
void UpdateRequest<I>::send() {
update_object_map();
}
template <typename I>
void UpdateRequest<I>::update_object_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
ceph_assert(ceph_mutex_is_locked(*m_object_map_lock));
CephContext *cct = m_image_ctx.cct;
// break very large requests into manageable batches
m_update_end_object_no = std::min(
m_end_object_no, m_update_start_object_no + MAX_OBJECTS_PER_UPDATE);
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, m_snap_id));
ldout(cct, 20) << "ictx=" << &m_image_ctx << ", oid=" << oid << ", "
<< "[" << m_update_start_object_no << ","
<< m_update_end_object_no << ") = "
<< (m_current_state ?
stringify(static_cast<uint32_t>(*m_current_state)) : "")
<< "->" << static_cast<uint32_t>(m_new_state)
<< dendl;
librados::ObjectWriteOperation op;
if (m_snap_id == CEPH_NOSNAP) {
rados::cls::lock::assert_locked(&op, RBD_LOCK_NAME, ClsLockType::EXCLUSIVE, "", "");
}
cls_client::object_map_update(&op, m_update_start_object_no,
m_update_end_object_no, m_new_state,
m_current_state);
auto rados_completion = librbd::util::create_rados_callback<
UpdateRequest<I>, &UpdateRequest<I>::handle_update_object_map>(this);
std::vector<librados::snap_t> snaps;
int r = m_image_ctx.md_ctx.aio_operate(
oid, rados_completion, &op, 0, snaps,
(m_trace.valid() ? m_trace.get_info() : nullptr));
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
void UpdateRequest<I>::handle_update_object_map(int r) {
ldout(m_image_ctx.cct, 20) << "r=" << r << dendl;
if (r == -ENOENT && m_ignore_enoent) {
r = 0;
}
if (r < 0 && m_ret_val == 0) {
m_ret_val = r;
}
{
std::shared_lock image_locker{m_image_ctx.image_lock};
std::unique_lock object_map_locker{*m_object_map_lock};
update_in_memory_object_map();
if (m_update_end_object_no < m_end_object_no) {
m_update_start_object_no = m_update_end_object_no;
update_object_map();
return;
}
}
// no more batch updates to send
complete(m_ret_val);
}
template <typename I>
void UpdateRequest<I>::update_in_memory_object_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
ceph_assert(ceph_mutex_is_locked(*m_object_map_lock));
// rebuilding the object map might update on-disk only
if (m_snap_id == m_image_ctx.snap_id) {
ldout(m_image_ctx.cct, 20) << dendl;
auto it = m_object_map.begin() +
std::min(m_update_start_object_no, m_object_map.size());
auto end_it = m_object_map.begin() +
std::min(m_update_end_object_no, m_object_map.size());
for (; it != end_it; ++it) {
auto state_ref = *it;
uint8_t state = state_ref;
if (!m_current_state || state == *m_current_state ||
(*m_current_state == OBJECT_EXISTS && state == OBJECT_EXISTS_CLEAN)) {
state_ref = m_new_state;
}
}
}
}
template <typename I>
void UpdateRequest<I>::finish_request() {
}
} // namespace object_map
} // namespace librbd
template class librbd::object_map::UpdateRequest<librbd::ImageCtx>;
| 3,980 | 29.623077 | 88 |
cc
|
null |
ceph-main/src/librbd/object_map/UpdateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OBJECT_MAP_UPDATE_REQUEST_H
#define CEPH_LIBRBD_OBJECT_MAP_UPDATE_REQUEST_H
#include "include/int_types.h"
#include "librbd/object_map/Request.h"
#include "common/bit_vector.hpp"
#include "common/zipkin_trace.h"
#include "librbd/Utils.h"
#include <boost/optional.hpp>
class Context;
namespace librbd {
class ImageCtx;
namespace object_map {
template <typename ImageCtxT = librbd::ImageCtx>
class UpdateRequest : public Request {
public:
static UpdateRequest *create(ImageCtx &image_ctx,
ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map,
uint64_t snap_id, uint64_t start_object_no,
uint64_t end_object_no, uint8_t new_state,
const boost::optional<uint8_t> ¤t_state,
const ZTracer::Trace &parent_trace,
bool ignore_enoent, Context *on_finish) {
return new UpdateRequest(image_ctx, object_map_lock, object_map, snap_id,
start_object_no, end_object_no, new_state,
current_state, parent_trace, ignore_enoent,
on_finish);
}
UpdateRequest(ImageCtx &image_ctx, ceph::shared_mutex* object_map_lock,
ceph::BitVector<2> *object_map, uint64_t snap_id,
uint64_t start_object_no, uint64_t end_object_no,
uint8_t new_state,
const boost::optional<uint8_t> ¤t_state,
const ZTracer::Trace &parent_trace, bool ignore_enoent,
Context *on_finish)
: Request(image_ctx, snap_id, on_finish),
m_object_map_lock(object_map_lock), m_object_map(*object_map),
m_start_object_no(start_object_no), m_end_object_no(end_object_no),
m_update_start_object_no(start_object_no), m_new_state(new_state),
m_current_state(current_state),
m_trace(util::create_trace(image_ctx, "update object map", parent_trace)),
m_ignore_enoent(ignore_enoent)
{
m_trace.event("start");
}
virtual ~UpdateRequest() {
m_trace.event("finish");
}
void send() override;
protected:
void finish_request() override;
private:
/**
* @verbatim
*
* <start>
* |
* |/------------------\
* v | (repeat in batches)
* UPDATE_OBJECT_MAP -----/
* |
* v
* <finish>
*
* @endverbatim
*/
ceph::shared_mutex* m_object_map_lock;
ceph::BitVector<2> &m_object_map;
uint64_t m_start_object_no;
uint64_t m_end_object_no;
uint64_t m_update_start_object_no;
uint64_t m_update_end_object_no = 0;
uint8_t m_new_state;
boost::optional<uint8_t> m_current_state;
ZTracer::Trace m_trace;
bool m_ignore_enoent;
int m_ret_val = 0;
void update_object_map();
void handle_update_object_map(int r);
void update_in_memory_object_map();
};
} // namespace object_map
} // namespace librbd
extern template class librbd::object_map::UpdateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OBJECT_MAP_UPDATE_REQUEST_H
| 3,250 | 29.383178 | 80 |
h
|
null |
ceph-main/src/librbd/operation/DisableFeaturesRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/DisableFeaturesRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/journal/RemoveRequest.h"
#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/DisableRequest.h"
#include "librbd/object_map/RemoveRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::DisableFeaturesRequest: "
namespace librbd {
namespace operation {
using util::create_async_context_callback;
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
DisableFeaturesRequest<I>::DisableFeaturesRequest(I &image_ctx,
Context *on_finish,
uint64_t journal_op_tid,
uint64_t features,
bool force)
: Request<I>(image_ctx, on_finish, journal_op_tid), m_features(features),
m_force(force) {
}
template <typename I>
void DisableFeaturesRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ldout(cct, 20) << this << " " << __func__ << ": features=" << m_features
<< dendl;
send_prepare_lock();
}
template <typename I>
bool DisableFeaturesRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << " r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void DisableFeaturesRequest<I>::send_prepare_lock() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
image_ctx.state->prepare_lock(create_async_context_callback(
image_ctx, create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_prepare_lock>(this)));
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_prepare_lock(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to lock image: " << cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_block_writes();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_block_writes() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
std::unique_lock locker{image_ctx.owner_lock};
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_block_writes>(this));
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_block_writes(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
m_writes_blocked = true;
{
std::unique_lock locker{image_ctx.owner_lock};
// avoid accepting new requests from peers while we manipulate
// the image features
if (image_ctx.exclusive_lock != nullptr &&
(image_ctx.journal == nullptr ||
!image_ctx.journal->is_journal_replaying())) {
image_ctx.exclusive_lock->block_requests(0);
m_requests_blocked = true;
}
}
return send_acquire_exclusive_lock(result);
}
template <typename I>
Context *DisableFeaturesRequest<I>::send_acquire_exclusive_lock(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
{
std::unique_lock locker{image_ctx.owner_lock};
// if disabling features w/ exclusive lock supported, we need to
// acquire the lock to temporarily block IO against the image
if (image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner()) {
m_acquired_lock = true;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_acquire_exclusive_lock>(
this, image_ctx.exclusive_lock);
image_ctx.exclusive_lock->acquire_lock(ctx);
return nullptr;
}
}
return handle_acquire_exclusive_lock(result);
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_acquire_exclusive_lock(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
image_ctx.owner_lock.lock_shared();
if (*result < 0) {
lderr(cct) << "failed to lock image: " << cpp_strerror(*result) << dendl;
image_ctx.owner_lock.unlock_shared();
return handle_finish(*result);
} else if (image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner()) {
lderr(cct) << "failed to acquire exclusive lock" << dendl;
*result = image_ctx.exclusive_lock->get_unlocked_op_error();
image_ctx.owner_lock.unlock_shared();
return handle_finish(*result);
}
do {
m_features &= image_ctx.features;
// interlock object-map and fast-diff together
if (((m_features & RBD_FEATURE_OBJECT_MAP) != 0) ||
((m_features & RBD_FEATURE_FAST_DIFF) != 0)) {
m_features |= (RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF);
}
m_new_features = image_ctx.features & ~m_features;
m_features_mask = m_features;
if ((m_features & RBD_FEATURE_EXCLUSIVE_LOCK) != 0) {
if ((m_new_features & RBD_FEATURE_OBJECT_MAP) != 0 ||
(m_new_features & RBD_FEATURE_JOURNALING) != 0) {
lderr(cct) << "cannot disable exclusive-lock. object-map "
"or journaling must be disabled before "
"disabling exclusive-lock." << dendl;
*result = -EINVAL;
break;
}
m_features_mask |= (RBD_FEATURE_OBJECT_MAP |
RBD_FEATURE_FAST_DIFF |
RBD_FEATURE_JOURNALING);
}
if ((m_features & RBD_FEATURE_FAST_DIFF) != 0) {
m_disable_flags |= RBD_FLAG_FAST_DIFF_INVALID;
}
if ((m_features & RBD_FEATURE_OBJECT_MAP) != 0) {
m_disable_flags |= RBD_FLAG_OBJECT_MAP_INVALID;
}
} while (false);
image_ctx.owner_lock.unlock_shared();
if (*result < 0) {
return handle_finish(*result);
}
send_get_mirror_mode();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_get_mirror_mode() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if ((m_features & RBD_FEATURE_JOURNALING) == 0) {
send_append_op_event();
return;
}
ldout(cct, 20) << this << " " << __func__ << dendl;
librados::ObjectReadOperation op;
cls_client::mirror_mode_get_start(&op);
using klass = DisableFeaturesRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_get_mirror_mode>(this);
m_out_bl.clear();
int r = image_ctx.md_ctx.aio_operate(RBD_MIRRORING, comp, &op, &m_out_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_get_mirror_mode(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
auto it = m_out_bl.cbegin();
*result = cls_client::mirror_mode_get_finish(&it, &m_mirror_mode);
}
if (*result < 0 && *result != -ENOENT) {
lderr(cct) << "failed to retrieve pool mirror mode: "
<< cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
ldout(cct, 20) << this << " " << __func__ << ": m_mirror_mode="
<< m_mirror_mode << dendl;
send_get_mirror_image();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_get_mirror_image() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_mirror_mode != cls::rbd::MIRROR_MODE_IMAGE) {
send_disable_mirror_image();
return;
}
ldout(cct, 20) << this << " " << __func__ << dendl;
librados::ObjectReadOperation op;
cls_client::mirror_image_get_start(&op, image_ctx.id);
using klass = DisableFeaturesRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_get_mirror_image>(this);
m_out_bl.clear();
int r = image_ctx.md_ctx.aio_operate(RBD_MIRRORING, comp, &op, &m_out_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_get_mirror_image(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
cls::rbd::MirrorImage mirror_image;
if (*result == 0) {
auto it = m_out_bl.cbegin();
*result = cls_client::mirror_image_get_finish(&it, &mirror_image);
}
if (*result < 0 && *result != -ENOENT) {
lderr(cct) << "failed to retrieve pool mirror image: "
<< cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
if (mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_ENABLED &&
mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_JOURNAL && !m_force) {
lderr(cct) << "cannot disable journaling: journal-based mirroring "
<< "enabled and mirror pool mode set to image"
<< dendl;
*result = -EINVAL;
return handle_finish(*result);
}
if (mirror_image.mode != cls::rbd::MIRROR_IMAGE_MODE_JOURNAL) {
send_close_journal();
} else {
send_disable_mirror_image();
}
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_disable_mirror_image() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_disable_mirror_image>(this);
mirror::DisableRequest<I> *req =
mirror::DisableRequest<I>::create(&image_ctx, m_force, true, ctx);
req->send();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_disable_mirror_image(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to disable image mirroring: " << cpp_strerror(*result)
<< dendl;
// not fatal
}
send_close_journal();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_close_journal() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
{
std::unique_lock locker{image_ctx.owner_lock};
if (image_ctx.journal != nullptr) {
ldout(cct, 20) << this << " " << __func__ << dendl;
std::swap(m_journal, image_ctx.journal);
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_close_journal>(this);
m_journal->close(ctx);
return;
}
}
send_remove_journal();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_close_journal(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to close image journal: " << cpp_strerror(*result)
<< dendl;
}
ceph_assert(m_journal != nullptr);
m_journal->put();
m_journal = nullptr;
send_remove_journal();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_remove_journal() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_remove_journal>(this);
typename journal::TypeTraits<I>::ContextWQ* context_wq;
Journal<I>::get_work_queue(cct, &context_wq);
journal::RemoveRequest<I> *req = journal::RemoveRequest<I>::create(
image_ctx.md_ctx, image_ctx.id, librbd::Journal<>::IMAGE_CLIENT_ID,
context_wq, ctx);
req->send();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_remove_journal(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to remove image journal: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_append_op_event();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_append_op_event() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (!this->template append_op_event<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_append_op_event>(this)) {
send_remove_object_map();
}
ldout(cct, 20) << this << " " << __func__ << dendl;
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_append_op_event(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to commit journal entry: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_remove_object_map();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_remove_object_map() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
if ((m_features & RBD_FEATURE_OBJECT_MAP) == 0) {
send_set_features();
return;
}
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_remove_object_map>(this);
object_map::RemoveRequest<I> *req =
object_map::RemoveRequest<I>::create(&image_ctx, ctx);
req->send();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_remove_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0 && *result != -ENOENT) {
lderr(cct) << "failed to remove object map: " << cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
send_set_features();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_set_features() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": new_features="
<< m_new_features << ", features_mask=" << m_features_mask
<< dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::set_features(&op, m_new_features, m_features_mask);
using klass = DisableFeaturesRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_set_features>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_set_features(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == -EINVAL && (m_features_mask & RBD_FEATURE_JOURNALING) != 0) {
// NOTE: infernalis OSDs will not accept a mask with new features, so
// re-attempt with a reduced mask.
ldout(cct, 5) << this << " " << __func__
<< ": re-attempt with a reduced mask" << dendl;
m_features_mask &= ~RBD_FEATURE_JOURNALING;
send_set_features();
}
if (*result < 0) {
lderr(cct) << "failed to update features: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_update_flags();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_update_flags() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_disable_flags == 0) {
send_notify_update();
return;
}
ldout(cct, 20) << this << " " << __func__ << ": disable_flags="
<< m_disable_flags << dendl;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_update_flags>(this);
image::SetFlagsRequest<I> *req =
image::SetFlagsRequest<I>::create(&image_ctx, 0, m_disable_flags, ctx);
req->send();
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_update_flags(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to update image flags: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_notify_update();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_notify_update() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_notify_update>(this);
image_ctx.notify_update(ctx);
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_notify_update(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (image_ctx.exclusive_lock == nullptr || !m_acquired_lock) {
return handle_finish(*result);
}
send_release_exclusive_lock();
return nullptr;
}
template <typename I>
void DisableFeaturesRequest<I>::send_release_exclusive_lock() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_release_exclusive_lock>(
this, image_ctx.exclusive_lock);
image_ctx.exclusive_lock->release_lock(ctx);
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_release_exclusive_lock(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
return handle_finish(*result);
}
template <typename I>
Context *DisableFeaturesRequest<I>::handle_finish(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << r << dendl;
{
std::unique_lock locker{image_ctx.owner_lock};
if (image_ctx.exclusive_lock != nullptr && m_requests_blocked) {
image_ctx.exclusive_lock->unblock_requests();
}
image_ctx.io_image_dispatcher->unblock_writes();
}
image_ctx.state->handle_prepare_lock_complete();
return this->create_context_finisher(r);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::DisableFeaturesRequest<librbd::ImageCtx>;
| 19,969 | 29.442073 | 84 |
cc
|
null |
ceph-main/src/librbd/operation/DisableFeaturesRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_DISABLE_FEATURES_REQUEST_H
#define CEPH_LIBRBD_OPERATION_DISABLE_FEATURES_REQUEST_H
#include "librbd/ImageCtx.h"
#include "librbd/operation/Request.h"
#include "cls/rbd/cls_rbd_client.h"
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class DisableFeaturesRequest : public Request<ImageCtxT> {
public:
static DisableFeaturesRequest *create(ImageCtxT &image_ctx, Context *on_finish,
uint64_t journal_op_tid,
uint64_t features, bool force) {
return new DisableFeaturesRequest(image_ctx, on_finish, journal_op_tid,
features, force);
}
DisableFeaturesRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t journal_op_tid, uint64_t features, bool force);
protected:
void send_op() override;
bool should_complete(int r) override;
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::UpdateFeaturesEvent(op_tid, m_features, false);
}
private:
/**
* DisableFeatures goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_PREPARE_LOCK
* |
* v
* STATE_BLOCK_WRITES
* |
* v
* STATE_ACQUIRE_EXCLUSIVE_LOCK (skip if not
* | required)
* | (disabling journaling)
* \-------------------\
* | |
* | V
* | STATE_GET_MIRROR_MODE
* |(not |
* | disabling v
* | journaling) STATE_GET_MIRROR_IMAGE
* | |
* | v
* | STATE_DISABLE_MIRROR_IMAGE (skip if not
* | | required)
* | v
* | STATE_CLOSE_JOURNAL
* | |
* | v
* | STATE_REMOVE_JOURNAL
* | |
* |/-------------------/
* |
* v
* STATE_APPEND_OP_EVENT (skip if journaling
* | disabled)
* v
* STATE_REMOVE_OBJECT_MAP (skip if not
* | disabling object map)
* v
* STATE_SET_FEATURES
* |
* v
* STATE_UPDATE_FLAGS
* |
* v
* STATE_NOTIFY_UPDATE
* |
* v
* STATE_RELEASE_EXCLUSIVE_LOCK (skip if not
* | required)
* | (unblock writes)
* v
* <finish>
*
* @endverbatim
*
*/
uint64_t m_features;
bool m_force;
bool m_acquired_lock = false;
bool m_writes_blocked = false;
bool m_image_lock_acquired = false;
bool m_requests_blocked = false;
uint64_t m_new_features = 0;
uint64_t m_disable_flags = 0;
uint64_t m_features_mask = 0;
decltype(ImageCtxT::journal) m_journal = nullptr;
cls::rbd::MirrorMode m_mirror_mode = cls::rbd::MIRROR_MODE_DISABLED;
bufferlist m_out_bl;
void send_prepare_lock();
Context *handle_prepare_lock(int *result);
void send_block_writes();
Context *handle_block_writes(int *result);
Context *send_acquire_exclusive_lock(int *result);
Context *handle_acquire_exclusive_lock(int *result);
void send_get_mirror_mode();
Context *handle_get_mirror_mode(int *result);
void send_get_mirror_image();
Context *handle_get_mirror_image(int *result);
void send_disable_mirror_image();
Context *handle_disable_mirror_image(int *result);
void send_close_journal();
Context *handle_close_journal(int *result);
void send_remove_journal();
Context *handle_remove_journal(int *result);
void send_append_op_event();
Context *handle_append_op_event(int *result);
void send_remove_object_map();
Context *handle_remove_object_map(int *result);
void send_set_features();
Context *handle_set_features(int *result);
void send_update_flags();
Context *handle_update_flags(int *result);
void send_notify_update();
Context *handle_notify_update(int *result);
void send_release_exclusive_lock();
Context *handle_release_exclusive_lock(int *result);
Context *handle_finish(int r);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::DisableFeaturesRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_DISABLE_FEATURES_REQUEST_H
| 4,650 | 26.040698 | 82 |
h
|
null |
ceph-main/src/librbd/operation/EnableFeaturesRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/EnableFeaturesRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/journal/CreateRequest.h"
#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/EnableRequest.h"
#include "librbd/object_map/CreateRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::EnableFeaturesRequest: "
namespace librbd {
namespace operation {
using util::create_async_context_callback;
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
EnableFeaturesRequest<I>::EnableFeaturesRequest(I &image_ctx,
Context *on_finish,
uint64_t journal_op_tid,
uint64_t features)
: Request<I>(image_ctx, on_finish, journal_op_tid), m_features(features) {
}
template <typename I>
void EnableFeaturesRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ldout(cct, 20) << this << " " << __func__ << ": features=" << m_features
<< dendl;
send_prepare_lock();
}
template <typename I>
bool EnableFeaturesRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << " r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void EnableFeaturesRequest<I>::send_prepare_lock() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
image_ctx.state->prepare_lock(create_async_context_callback(
image_ctx, create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_prepare_lock>(this)));
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_prepare_lock(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to lock image: " << cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_block_writes();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_block_writes() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
std::unique_lock locker{image_ctx.owner_lock};
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_block_writes>(this));
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_block_writes(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
m_writes_blocked = true;
send_get_mirror_mode();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_get_mirror_mode() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if ((m_features & RBD_FEATURE_JOURNALING) == 0) {
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_get_mirror_mode>(this);
ctx->complete(-ENOENT);
return;
}
ldout(cct, 20) << this << " " << __func__ << dendl;
librados::ObjectReadOperation op;
cls_client::mirror_mode_get_start(&op);
using klass = EnableFeaturesRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_get_mirror_mode>(this);
m_out_bl.clear();
int r = image_ctx.md_ctx.aio_operate(RBD_MIRRORING, comp, &op, &m_out_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_get_mirror_mode(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
cls::rbd::MirrorMode mirror_mode = cls::rbd::MIRROR_MODE_DISABLED;
if (*result == 0) {
auto it = m_out_bl.cbegin();
*result = cls_client::mirror_mode_get_finish(&it, &mirror_mode);
} else if (*result == -ENOENT) {
*result = 0;
}
if (*result < 0) {
lderr(cct) << "failed to retrieve pool mirror mode: "
<< cpp_strerror(*result) << dendl;
return handle_finish(*result);
}
m_enable_mirroring = (mirror_mode == cls::rbd::MIRROR_MODE_POOL);
bool create_journal = false;
do {
std::unique_lock locker{image_ctx.owner_lock};
// avoid accepting new requests from peers while we manipulate
// the image features
if (image_ctx.exclusive_lock != nullptr &&
(image_ctx.journal == nullptr ||
!image_ctx.journal->is_journal_replaying())) {
image_ctx.exclusive_lock->block_requests(0);
m_requests_blocked = true;
}
m_features &= ~image_ctx.features;
// interlock object-map and fast-diff together
if (((m_features & RBD_FEATURE_OBJECT_MAP) != 0) ||
((m_features & RBD_FEATURE_FAST_DIFF) != 0)) {
m_features |= (RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF);
}
m_new_features = image_ctx.features | m_features;
m_features_mask = m_features;
if ((m_features & RBD_FEATURE_OBJECT_MAP) != 0) {
if ((m_new_features & RBD_FEATURE_EXCLUSIVE_LOCK) == 0) {
lderr(cct) << "cannot enable object-map. exclusive-lock must be "
"enabled before enabling object-map." << dendl;
*result = -EINVAL;
break;
}
m_enable_flags |= RBD_FLAG_OBJECT_MAP_INVALID;
m_features_mask |= (RBD_FEATURE_EXCLUSIVE_LOCK | RBD_FEATURE_FAST_DIFF);
}
if ((m_features & RBD_FEATURE_FAST_DIFF) != 0) {
m_enable_flags |= RBD_FLAG_FAST_DIFF_INVALID;
m_features_mask |= (RBD_FEATURE_EXCLUSIVE_LOCK | RBD_FEATURE_OBJECT_MAP);
}
if ((m_features & RBD_FEATURE_JOURNALING) != 0) {
if ((m_new_features & RBD_FEATURE_EXCLUSIVE_LOCK) == 0) {
lderr(cct) << "cannot enable journaling. exclusive-lock must be "
"enabled before enabling journaling." << dendl;
*result = -EINVAL;
break;
}
m_features_mask |= RBD_FEATURE_EXCLUSIVE_LOCK;
create_journal = true;
}
} while (false);
if (*result < 0) {
return handle_finish(*result);
}
if (create_journal) {
send_create_journal();
return nullptr;
}
send_append_op_event();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_create_journal() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
journal::TagData tag_data(librbd::Journal<>::LOCAL_MIRROR_UUID);
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_create_journal>(this);
typename journal::TypeTraits<I>::ContextWQ* context_wq;
Journal<I>::get_work_queue(cct, &context_wq);
journal::CreateRequest<I> *req = journal::CreateRequest<I>::create(
image_ctx.md_ctx, image_ctx.id,
image_ctx.config.template get_val<uint64_t>("rbd_journal_order"),
image_ctx.config.template get_val<uint64_t>("rbd_journal_splay_width"),
image_ctx.config.template get_val<std::string>("rbd_journal_pool"),
cls::journal::Tag::TAG_CLASS_NEW, tag_data,
librbd::Journal<>::IMAGE_CLIENT_ID, context_wq, ctx);
req->send();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_create_journal(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to create journal: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_append_op_event();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_append_op_event() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (!this->template append_op_event<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_append_op_event>(this)) {
send_update_flags();
}
ldout(cct, 20) << this << " " << __func__ << dendl;
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_append_op_event(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to commit journal entry: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_update_flags();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_update_flags() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_enable_flags == 0) {
send_set_features();
return;
}
ldout(cct, 20) << this << " " << __func__ << ": enable_flags="
<< m_enable_flags << dendl;
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_update_flags>(this);
image::SetFlagsRequest<I> *req =
image::SetFlagsRequest<I>::create(&image_ctx, m_enable_flags,
m_enable_flags, ctx);
req->send();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_update_flags(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to update image flags: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_set_features();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_set_features() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": new_features="
<< m_new_features << ", features_mask=" << m_features_mask
<< dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::set_features(&op, m_new_features, m_features_mask);
using klass = EnableFeaturesRequest<I>;
librados::AioCompletion *comp =
create_rados_callback<klass, &klass::handle_set_features>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_set_features(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to update features: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_create_object_map();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_create_object_map() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (((image_ctx.features & RBD_FEATURE_OBJECT_MAP) != 0) ||
((m_features & RBD_FEATURE_OBJECT_MAP) == 0)) {
send_enable_mirror_image();
return;
}
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_create_object_map>(this);
object_map::CreateRequest<I> *req =
object_map::CreateRequest<I>::create(&image_ctx, ctx);
req->send();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_create_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to create object map: " << cpp_strerror(*result)
<< dendl;
return handle_finish(*result);
}
send_enable_mirror_image();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_enable_mirror_image() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (!m_enable_mirroring) {
send_notify_update();
return;
}
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_enable_mirror_image>(this);
auto req = mirror::EnableRequest<I>::create(
&image_ctx, cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, "", false, ctx);
req->send();
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_enable_mirror_image(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to enable mirroring: " << cpp_strerror(*result)
<< dendl;
// not fatal
}
send_notify_update();
return nullptr;
}
template <typename I>
void EnableFeaturesRequest<I>::send_notify_update() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_notify_update>(this);
image_ctx.notify_update(ctx);
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_notify_update(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
return handle_finish(*result);
}
template <typename I>
Context *EnableFeaturesRequest<I>::handle_finish(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << ": r=" << r << dendl;
{
std::unique_lock locker{image_ctx.owner_lock};
if (image_ctx.exclusive_lock != nullptr && m_requests_blocked) {
image_ctx.exclusive_lock->unblock_requests();
}
if (m_writes_blocked) {
image_ctx.io_image_dispatcher->unblock_writes();
}
}
image_ctx.state->handle_prepare_lock_complete();
return this->create_context_finisher(r);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::EnableFeaturesRequest<librbd::ImageCtx>;
| 14,977 | 29.258586 | 79 |
cc
|
null |
ceph-main/src/librbd/operation/EnableFeaturesRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_ENABLE_FEATURES_REQUEST_H
#define CEPH_LIBRBD_OPERATION_ENABLE_FEATURES_REQUEST_H
#include "librbd/operation/Request.h"
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class EnableFeaturesRequest : public Request<ImageCtxT> {
public:
static EnableFeaturesRequest *create(ImageCtxT &image_ctx, Context *on_finish,
uint64_t journal_op_tid,
uint64_t features) {
return new EnableFeaturesRequest(image_ctx, on_finish, journal_op_tid,
features);
}
EnableFeaturesRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t journal_op_tid, uint64_t features);
protected:
void send_op() override;
bool should_complete(int r) override;
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::UpdateFeaturesEvent(op_tid, m_features, true);
}
private:
/**
* EnableFeatures goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_PREPARE_LOCK
* |
* v
* STATE_BLOCK_WRITES
* |
* v
* STATE_GET_MIRROR_MODE
* |
* v
* STATE_CREATE_JOURNAL (skip if not
* | required)
* v
* STATE_APPEND_OP_EVENT (skip if journaling
* | disabled)
* v
* STATE_UPDATE_FLAGS
* |
* v
* STATE_SET_FEATURES
* |
* v
* STATE_CREATE_OBJECT_MAP (skip if not
* | required)
* v
* STATE_ENABLE_MIRROR_IMAGE
* |
* V
* STATE_NOTIFY_UPDATE
* |
* | (unblock writes)
* v
* <finish>
* @endverbatim
*
*/
uint64_t m_features;
bool m_enable_mirroring = false;
bool m_requests_blocked = false;
bool m_writes_blocked = false;
uint64_t m_new_features = 0;
uint64_t m_enable_flags = 0;
uint64_t m_features_mask = 0;
bufferlist m_out_bl;
void send_prepare_lock();
Context *handle_prepare_lock(int *result);
void send_block_writes();
Context *handle_block_writes(int *result);
void send_get_mirror_mode();
Context *handle_get_mirror_mode(int *result);
void send_create_journal();
Context *handle_create_journal(int *result);
void send_append_op_event();
Context *handle_append_op_event(int *result);
void send_update_flags();
Context *handle_update_flags(int *result);
void send_set_features();
Context *handle_set_features(int *result);
void send_create_object_map();
Context *handle_create_object_map(int *result);
void send_enable_mirror_image();
Context *handle_enable_mirror_image(int *result);
void send_notify_update();
Context *handle_notify_update(int *result);
Context *handle_finish(int r);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::EnableFeaturesRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_ENABLE_FEATURES_REQUEST_H
| 3,231 | 22.764706 | 81 |
h
|
null |
ceph-main/src/librbd/operation/FlattenRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/FlattenRequest.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/crypto/CryptoInterface.h"
#include "librbd/crypto/EncryptionFormat.h"
#include "librbd/image/DetachChildRequest.h"
#include "librbd/image/DetachParentRequest.h"
#include "librbd/Types.h"
#include "librbd/io/ObjectRequest.h"
#include "librbd/io/Utils.h"
#include "common/dout.h"
#include "common/errno.h"
#include "osdc/Striper.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::operation::FlattenRequest: " << this \
<< " " << __func__ << ": "
namespace librbd {
namespace operation {
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
class C_FlattenObject : public C_AsyncObjectThrottle<I> {
public:
C_FlattenObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
IOContext io_context, uint64_t object_no)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no) {
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
if (image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner()) {
ldout(cct, 1) << "lost exclusive lock during flatten" << dendl;
return -ERESTART;
}
{
std::shared_lock 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
return 1;
}
}
if (!io::util::trigger_copyup(
&image_ctx, m_object_no, m_io_context, this)) {
// stop early if the parent went away - it just means
// another flatten finished first or the image was resized
return 1;
}
return 0;
}
private:
IOContext m_io_context;
uint64_t m_object_no;
};
template <typename I>
bool FlattenRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void FlattenRequest<I>::send_op() {
flatten_objects();
}
template <typename I>
void FlattenRequest<I>::flatten_objects() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
assert(ceph_mutex_is_locked(image_ctx.owner_lock));
auto ctx = create_context_callback<
FlattenRequest<I>,
&FlattenRequest<I>::handle_flatten_objects>(this);
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_FlattenObject<I> >(),
boost::lambda::_1, &image_ctx, image_ctx.get_data_io_context(),
boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, m_start_object_no,
m_start_object_no + m_overlap_objects);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
void FlattenRequest<I>::handle_flatten_objects(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == -ERESTART) {
ldout(cct, 5) << "flatten operation interrupted" << dendl;
this->complete(r);
return;
} else if (r < 0) {
lderr(cct) << "flatten encountered an error: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
crypto_flatten();
}
template <typename I>
void FlattenRequest<I>::crypto_flatten() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
auto encryption_format = image_ctx.encryption_format.get();
if (encryption_format == nullptr) {
detach_child();
return;
}
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
FlattenRequest<I>,
&FlattenRequest<I>::handle_crypto_flatten>(this);
encryption_format->flatten(&image_ctx, ctx);
}
template <typename I>
void FlattenRequest<I>::handle_crypto_flatten(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "error flattening crypto: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
detach_child();
}
template <typename I>
void FlattenRequest<I>::detach_child() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
// should have been canceled prior to releasing lock
image_ctx.owner_lock.lock_shared();
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
// 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.image_lock.lock_shared();
if ((image_ctx.features & RBD_FEATURE_DEEP_FLATTEN) == 0 &&
!image_ctx.snaps.empty()) {
image_ctx.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
detach_parent();
return;
}
image_ctx.image_lock.unlock_shared();
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
FlattenRequest<I>,
&FlattenRequest<I>::handle_detach_child>(this);
auto req = image::DetachChildRequest<I>::create(image_ctx, ctx);
req->send();
image_ctx.owner_lock.unlock_shared();
}
template <typename I>
void FlattenRequest<I>::handle_detach_child(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "detach encountered an error: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
detach_parent();
}
template <typename I>
void FlattenRequest<I>::detach_parent() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
// should have been canceled prior to releasing lock
image_ctx.owner_lock.lock_shared();
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
// stop early if the parent went away - it just means
// another flatten finished first, so this one is useless.
image_ctx.image_lock.lock_shared();
if (!image_ctx.parent) {
ldout(cct, 5) << "image already flattened" << dendl;
image_ctx.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
this->complete(0);
return;
}
image_ctx.image_lock.unlock_shared();
// remove parent from this (base) image
auto ctx = create_context_callback<
FlattenRequest<I>,
&FlattenRequest<I>::handle_detach_parent>(this);
auto req = image::DetachParentRequest<I>::create(image_ctx, ctx);
req->send();
image_ctx.owner_lock.unlock_shared();
}
template <typename I>
void FlattenRequest<I>::handle_detach_parent(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "remove parent encountered an error: " << cpp_strerror(r)
<< dendl;
}
this->complete(r);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::FlattenRequest<librbd::ImageCtx>;
| 7,802 | 28.334586 | 82 |
cc
|
null |
ceph-main/src/librbd/operation/FlattenRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
#define CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
#include "librbd/operation/Request.h"
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class FlattenRequest : public Request<ImageCtxT>
{
public:
FlattenRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t start_object_no, uint64_t overlap_objects,
ProgressContext& prog_ctx)
: Request<ImageCtxT>(image_ctx, on_finish),
m_start_object_no(start_object_no),
m_overlap_objects(overlap_objects),
m_prog_ctx(prog_ctx) {}
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::FlattenEvent(op_tid);
}
private:
/**
* @verbatim
*
* <start>
* |
* v
* FLATTEN_OBJECTS
* |
* v
* CRYPTO_FLATTEN
* |
* v
* DETACH_CHILD
* |
* v
* DETACH_PARENT
* |
* v
* <finish>
*
* @endverbatim
*/
uint64_t m_start_object_no;
uint64_t m_overlap_objects;
ProgressContext &m_prog_ctx;
void flatten_objects();
void handle_flatten_objects(int r);
void crypto_flatten();
void handle_crypto_flatten(int r);
void detach_child();
void handle_detach_child(int r);
void detach_parent();
void handle_detach_parent(int r);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::FlattenRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
| 1,739 | 19.714286 | 74 |
h
|
null |
ceph-main/src/librbd/operation/MetadataRemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/MetadataRemoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::MetadataRemoveRequest: "
namespace librbd {
namespace operation {
template <typename I>
MetadataRemoveRequest<I>::MetadataRemoveRequest(I &image_ctx,
Context *on_finish,
const std::string &key)
: Request<I>(image_ctx, on_finish), m_key(key) {
}
template <typename I>
void MetadataRemoveRequest<I>::send_op() {
send_metadata_remove();
}
template <typename I>
bool MetadataRemoveRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << " r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void MetadataRemoveRequest<I>::send_metadata_remove() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
librados::ObjectWriteOperation op;
cls_client::metadata_remove(&op, m_key);
librados::AioCompletion *comp = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
} // namespace operation
} // namespace librbd
template class librbd::operation::MetadataRemoveRequest<librbd::ImageCtx>;
| 1,748 | 27.672131 | 74 |
cc
|
null |
ceph-main/src/librbd/operation/MetadataRemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offremove:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_METADATA_REMOVE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_METADATA_REMOVE_REQUEST_H
#include "librbd/operation/Request.h"
#include <iosfwd>
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class MetadataRemoveRequest : public Request<ImageCtxT> {
public:
MetadataRemoveRequest(ImageCtxT &image_ctx, Context *on_finish,
const std::string &key);
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::MetadataRemoveEvent(op_tid, m_key);
}
private:
std::string m_key;
void send_metadata_remove();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::MetadataRemoveRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_METADATA_REMOVE_REQUEST_H
| 1,048 | 22.311111 | 81 |
h
|
null |
ceph-main/src/librbd/operation/MetadataSetRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/MetadataSetRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::MetadataSetRequest: "
namespace librbd {
namespace operation {
template <typename I>
MetadataSetRequest<I>::MetadataSetRequest(I &image_ctx,
Context *on_finish,
const std::string &key,
const std::string &value)
: Request<I>(image_ctx, on_finish), m_key(key), m_value(value) {
}
template <typename I>
void MetadataSetRequest<I>::send_op() {
send_metadata_set();
}
template <typename I>
bool MetadataSetRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << " r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void MetadataSetRequest<I>::send_metadata_set() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << this << " " << __func__ << dendl;
m_data[m_key].append(m_value);
librados::ObjectWriteOperation op;
cls_client::metadata_set(&op, m_data);
librados::AioCompletion *comp = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
} // namespace operation
} // namespace librbd
template class librbd::operation::MetadataSetRequest<librbd::ImageCtx>;
| 1,821 | 27.920635 | 72 |
cc
|
null |
ceph-main/src/librbd/operation/MetadataSetRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_METADATA_SET_REQUEST_H
#define CEPH_LIBRBD_OPERATION_METADATA_SET_REQUEST_H
#include "librbd/operation/Request.h"
#include "include/buffer.h"
#include <string>
#include <map>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class MetadataSetRequest : public Request<ImageCtxT> {
public:
MetadataSetRequest(ImageCtxT &image_ctx, Context *on_finish,
const std::string &key, const std::string &value);
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::MetadataSetEvent(op_tid, m_key, m_value);
}
private:
std::string m_key;
std::string m_value;
std::map<std::string, bufferlist> m_data;
void send_metadata_set();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::MetadataSetRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_METADATA_SET_REQUEST_H
| 1,145 | 22.875 | 78 |
h
|
null |
ceph-main/src/librbd/operation/MigrateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/MigrateRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/deep_copy/ObjectCopyRequest.h"
#include "librbd/io/AsyncOperation.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/io/ObjectRequest.h"
#include "osdc/Striper.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::MigrateRequest: " << this << " " \
<< __func__ << ": "
namespace librbd {
namespace operation {
using util::create_context_callback;
using util::create_async_context_callback;
namespace {
template <typename I>
class C_MigrateObject : public C_AsyncObjectThrottle<I> {
public:
C_MigrateObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
IOContext io_context, uint64_t object_no)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no) {
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
if (image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner()) {
ldout(cct, 1) << "lost exclusive lock during migrate" << dendl;
return -ERESTART;
}
start_async_op();
return 0;
}
private:
IOContext m_io_context;
uint64_t m_object_no;
io::AsyncOperation *m_async_op = nullptr;
void start_async_op() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << dendl;
ceph_assert(m_async_op == nullptr);
m_async_op = new io::AsyncOperation();
m_async_op->start_op(image_ctx);
if (!image_ctx.io_image_dispatcher->writes_blocked()) {
migrate_object();
return;
}
auto ctx = create_async_context_callback(
image_ctx, create_context_callback<
C_MigrateObject<I>, &C_MigrateObject<I>::handle_start_async_op>(this));
m_async_op->finish_op();
delete m_async_op;
m_async_op = nullptr;
image_ctx.io_image_dispatcher->wait_on_writes_unblocked(ctx);
}
void handle_start_async_op(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to start async op: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
std::shared_lock owner_locker{image_ctx.owner_lock};
start_async_op();
}
bool is_within_overlap_bounds() {
I &image_ctx = this->m_image_ctx;
std::shared_lock image_locker{image_ctx.image_lock};
auto overlap = std::min(image_ctx.size, image_ctx.migration_info.overlap);
return overlap > 0 &&
Striper::get_num_objects(image_ctx.layout, overlap) > m_object_no;
}
void migrate_object() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
auto ctx = create_context_callback<
C_MigrateObject<I>, &C_MigrateObject<I>::handle_migrate_object>(this);
if (is_within_overlap_bounds()) {
bufferlist bl;
auto req = new io::ObjectWriteRequest<I>(&image_ctx, m_object_no, 0,
std::move(bl), m_io_context, 0,
0, std::nullopt, {}, ctx);
ldout(cct, 20) << "copyup object req " << req << ", object_no "
<< m_object_no << dendl;
req->send();
} else {
ceph_assert(image_ctx.parent != nullptr);
uint32_t flags = deep_copy::OBJECT_COPY_REQUEST_FLAG_MIGRATION;
if (image_ctx.migration_info.flatten) {
flags |= deep_copy::OBJECT_COPY_REQUEST_FLAG_FLATTEN;
}
auto req = deep_copy::ObjectCopyRequest<I>::create(
image_ctx.parent, &image_ctx, 0, 0, image_ctx.migration_info.snap_map,
m_object_no, flags, nullptr, ctx);
ldout(cct, 20) << "deep copy object req " << req << ", object_no "
<< m_object_no << dendl;
req->send();
}
}
void handle_migrate_object(int r) {
CephContext *cct = this->m_image_ctx.cct;
ldout(cct, 10) << "r=" << r << dendl;
if (r == -ENOENT) {
r = 0;
}
m_async_op->finish_op();
delete m_async_op;
this->complete(r);
}
};
} // anonymous namespace
template <typename I>
void MigrateRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << dendl;
migrate_objects();
}
template <typename I>
bool MigrateRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void MigrateRequest<I>::migrate_objects() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
uint64_t overlap_objects = get_num_overlap_objects();
ldout(cct, 10) << "from 0 to " << overlap_objects << dendl;
auto ctx = create_context_callback<
MigrateRequest<I>, &MigrateRequest<I>::handle_migrate_objects>(this);
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_MigrateObject<I> >(),
boost::lambda::_1, &image_ctx, image_ctx.get_data_io_context(),
boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, overlap_objects);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
void MigrateRequest<I>::handle_migrate_objects(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to migrate objects: " << cpp_strerror(r) << dendl;
}
this->complete(r);
}
template <typename I>
uint64_t MigrateRequest<I>::get_num_overlap_objects() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << dendl;
std::shared_lock image_locker{image_ctx.image_lock};
auto overlap = image_ctx.migration_info.overlap;
return overlap > 0 ?
Striper::get_num_objects(image_ctx.layout, overlap) : 0;
}
} // namespace operation
} // namespace librbd
template class librbd::operation::MigrateRequest<librbd::ImageCtx>;
| 6,993 | 28.263598 | 82 |
cc
|
null |
ceph-main/src/librbd/operation/MigrateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_MIGRATE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_MIGRATE_REQUEST_H
#include "librbd/operation/Request.h"
#include "librbd/Types.h"
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class MigrateRequest : public Request<ImageCtxT>
{
public:
MigrateRequest(ImageCtxT &image_ctx, Context *on_finish,
ProgressContext &prog_ctx)
: Request<ImageCtxT>(image_ctx, on_finish), m_prog_ctx(prog_ctx) {
}
protected:
void send_op() override;
bool should_complete(int r) override;
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
ceph_abort();
return journal::UnknownEvent();
}
private:
/**
* Migrate goes through the following state machine to copy objects
* from the parent (migrating source) image:
*
* @verbatim
*
* <start>
* |
* v
* MIGRATE_OBJECTS
* |
* v
* <finish>
*
* @endverbatim
*
*/
ProgressContext &m_prog_ctx;
void migrate_objects();
void handle_migrate_objects(int r);
uint64_t get_num_overlap_objects();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::MigrateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_MIGRATE_REQUEST_H
| 1,477 | 20.42029 | 74 |
h
|
null |
ceph-main/src/librbd/operation/ObjectMapIterate.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/ObjectMapIterate.h"
#include "common/dout.h"
#include "common/errno.h"
#include "osdc/Striper.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageWatcher.h"
#include "librbd/internal.h"
#include "librbd/ObjectMap.h"
#include "librbd/operation/ResizeRequest.h"
#include "librbd/object_map/InvalidateRequest.h"
#include "librbd/Utils.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::ObjectMapIterateRequest: "
namespace librbd {
namespace operation {
namespace {
template <typename I>
class C_VerifyObjectCallback : public C_AsyncObjectThrottle<I> {
public:
C_VerifyObjectCallback(AsyncObjectThrottle<I> &throttle, I *image_ctx,
uint64_t snap_id, uint64_t object_no,
ObjectIterateWork<I> handle_mismatch,
std::atomic_flag *invalidate)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx),
m_snap_id(snap_id), m_object_no(object_no),
m_oid(image_ctx->get_object_name(m_object_no)),
m_handle_mismatch(handle_mismatch),
m_invalidate(invalidate)
{
m_io_ctx.dup(image_ctx->data_ctx);
m_io_ctx.snap_set_read(CEPH_SNAPDIR);
}
void complete(int r) override {
I &image_ctx = this->m_image_ctx;
if (should_complete(r)) {
ldout(image_ctx.cct, 20) << m_oid << " C_VerifyObjectCallback completed "
<< dendl;
m_io_ctx.close();
this->finish(r);
delete this;
}
}
int send() override {
send_list_snaps();
return 0;
}
private:
librados::IoCtx m_io_ctx;
uint64_t m_snap_id;
uint64_t m_object_no;
std::string m_oid;
ObjectIterateWork<I> m_handle_mismatch;
std::atomic_flag *m_invalidate;
librados::snap_set_t m_snap_set;
int m_snap_list_ret = 0;
bool should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (r == 0) {
r = m_snap_list_ret;
}
if (r < 0 && r != -ENOENT) {
lderr(cct) << m_oid << " C_VerifyObjectCallback::should_complete: "
<< "encountered an error: " << cpp_strerror(r) << dendl;
return true;
}
ldout(cct, 20) << m_oid << " C_VerifyObjectCallback::should_complete: "
<< " r="
<< r << dendl;
return object_map_action(get_object_state());
}
void send_list_snaps() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ldout(image_ctx.cct, 5) << m_oid
<< " C_VerifyObjectCallback::send_list_snaps"
<< dendl;
librados::ObjectReadOperation op;
op.list_snaps(&m_snap_set, &m_snap_list_ret);
librados::AioCompletion *comp = util::create_rados_callback(this);
int r = m_io_ctx.aio_operate(m_oid, comp, &op, NULL);
ceph_assert(r == 0);
comp->release();
}
uint8_t get_object_state() {
I &image_ctx = this->m_image_ctx;
std::shared_lock 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;
librados::snap_t to_snap_id;
if (r->cloneid == librados::SNAP_HEAD) {
from_snap_id = next_valid_snap_id(m_snap_set.seq + 1);
to_snap_id = librados::SNAP_HEAD;
} else {
from_snap_id = next_valid_snap_id(r->snaps[0]);
to_snap_id = r->snaps[r->snaps.size()-1];
}
if (to_snap_id < m_snap_id) {
continue;
} else if (m_snap_id < from_snap_id) {
break;
}
if ((image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0 &&
from_snap_id != m_snap_id) {
return OBJECT_EXISTS_CLEAN;
}
return OBJECT_EXISTS;
}
return OBJECT_NONEXISTENT;
}
uint64_t next_valid_snap_id(uint64_t snap_id) {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
std::map<librados::snap_t, SnapInfo>::iterator it =
image_ctx.snap_info.lower_bound(snap_id);
if (it == image_ctx.snap_info.end()) {
return CEPH_NOSNAP;
}
return it->first;
}
bool object_map_action(uint8_t new_state) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
std::shared_lock owner_locker{image_ctx.owner_lock};
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
std::shared_lock image_locker{image_ctx.image_lock};
ceph_assert(image_ctx.object_map != nullptr);
uint8_t state = (*image_ctx.object_map)[m_object_no];
ldout(cct, 10) << "C_VerifyObjectCallback::object_map_action"
<< " object " << image_ctx.get_object_name(m_object_no)
<< " state " << (int)state
<< " new_state " << (int)new_state << dendl;
if (state != new_state) {
int r = 0;
ceph_assert(m_handle_mismatch);
r = m_handle_mismatch(image_ctx, m_object_no, state, new_state);
if (r) {
lderr(cct) << "object map error: object "
<< image_ctx.get_object_name(m_object_no)
<< " marked as " << (int)state << ", but should be "
<< (int)new_state << dendl;
m_invalidate->test_and_set();
} else {
ldout(cct, 1) << "object map inconsistent: object "
<< image_ctx.get_object_name(m_object_no)
<< " marked as " << (int)state << ", but should be "
<< (int)new_state << dendl;
}
}
return true;
}
};
} // anonymous namespace
template <typename I>
void ObjectMapIterateRequest<I>::send() {
if (!m_image_ctx.data_ctx.is_valid()) {
this->async_complete(-ENODEV);
return;
}
send_verify_objects();
}
template <typename I>
bool ObjectMapIterateRequest<I>::should_complete(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " should_complete: " << " r=" << r << dendl;
if (r == -ENODEV) {
lderr(cct) << "missing data pool" << dendl;
return true;
}
if (r < 0) {
lderr(cct) << "object map operation encountered an error: "
<< cpp_strerror(r) << dendl;
}
std::shared_lock owner_lock{m_image_ctx.owner_lock};
switch (m_state) {
case STATE_VERIFY_OBJECTS:
if (m_invalidate.test_and_set()) {
send_invalidate_object_map();
return false;
} else if (r == 0) {
return true;
}
break;
case STATE_INVALIDATE_OBJECT_MAP:
if (r == 0) {
return true;
}
break;
default:
ceph_abort();
break;
}
if (r < 0) {
return true;
}
return false;
}
template <typename I>
void ObjectMapIterateRequest<I>::send_verify_objects() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
CephContext *cct = m_image_ctx.cct;
uint64_t snap_id;
uint64_t num_objects;
{
std::shared_lock 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));
}
ldout(cct, 5) << this << " send_verify_objects" << dendl;
m_state = STATE_VERIFY_OBJECTS;
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_VerifyObjectCallback<I> >(),
boost::lambda::_1, &m_image_ctx, snap_id,
boost::lambda::_2, m_handle_mismatch, &m_invalidate));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, m_image_ctx, context_factory, this->create_callback_context(),
&m_prog_ctx, 0, num_objects);
throttle->start_ops(
m_image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
uint64_t ObjectMapIterateRequest<I>::get_image_size() const {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.image_lock));
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();
} else {
return m_image_ctx.size;
}
}
return m_image_ctx.get_image_size(m_image_ctx.snap_id);
}
template <typename I>
void ObjectMapIterateRequest<I>::send_invalidate_object_map() {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " send_invalidate_object_map" << dendl;
m_state = STATE_INVALIDATE_OBJECT_MAP;
object_map::InvalidateRequest<I>*req =
object_map::InvalidateRequest<I>::create(m_image_ctx, m_image_ctx.snap_id,
true,
this->create_callback_context());
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
std::unique_lock image_locker{m_image_ctx.image_lock};
req->send();
}
} // namespace operation
} // namespace librbd
template class librbd::operation::ObjectMapIterateRequest<librbd::ImageCtx>;
| 8,962 | 28.006472 | 84 |
cc
|
null |
ceph-main/src/librbd/operation/ObjectMapIterate.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_OBJECT_MAP_ITERATE_H
#define CEPH_LIBRBD_OPERATION_OBJECT_MAP_ITERATE_H
#include <iostream>
#include <atomic>
#include "include/int_types.h"
#include "include/rbd/object_map_types.h"
#include "librbd/AsyncRequest.h"
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
using ObjectIterateWork = bool(*)(ImageCtxT &image_ctx,
uint64_t object_no,
uint8_t current_state,
uint8_t new_state);
template <typename ImageCtxT = ImageCtx>
class ObjectMapIterateRequest : public AsyncRequest<ImageCtxT> {
public:
ObjectMapIterateRequest(ImageCtxT &image_ctx, Context *on_finish,
ProgressContext &prog_ctx,
ObjectIterateWork<ImageCtxT> handle_mismatch)
: AsyncRequest<ImageCtxT>(image_ctx, on_finish), m_image_ctx(image_ctx),
m_prog_ctx(prog_ctx), m_handle_mismatch(handle_mismatch)
{
}
void send() override;
protected:
bool should_complete(int r) override;
private:
enum State {
STATE_VERIFY_OBJECTS,
STATE_INVALIDATE_OBJECT_MAP
};
ImageCtxT &m_image_ctx;
ProgressContext &m_prog_ctx;
ObjectIterateWork<ImageCtxT> m_handle_mismatch;
std::atomic_flag m_invalidate = ATOMIC_FLAG_INIT;
State m_state = STATE_VERIFY_OBJECTS;
void send_verify_objects();
void send_invalidate_object_map();
uint64_t get_image_size() const;
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::ObjectMapIterateRequest<librbd::ImageCtx>;
#endif
| 1,633 | 23.757576 | 83 |
h
|
null |
ceph-main/src/librbd/operation/RebuildObjectMapRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/RebuildObjectMapRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "osdc/Striper.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/ObjectMap.h"
#include "librbd/operation/ResizeRequest.h"
#include "librbd/operation/TrimRequest.h"
#include "librbd/operation/ObjectMapIterate.h"
#include "librbd/Utils.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::RebuildObjectMapRequest: "
namespace librbd {
namespace operation {
using util::create_context_callback;
template <typename I>
void RebuildObjectMapRequest<I>::send() {
send_resize_object_map();
}
template <typename I>
bool RebuildObjectMapRequest<I>::should_complete(int r) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " should_complete: " << " r=" << r << dendl;
std::shared_lock owner_lock{m_image_ctx.owner_lock};
switch (m_state) {
case STATE_RESIZE_OBJECT_MAP:
ldout(cct, 5) << "RESIZE_OBJECT_MAP" << dendl;
if (r == -ESTALE && !m_attempted_trim) {
// objects are still flagged as in-use -- delete them
m_attempted_trim = true;
send_trim_image();
return false;
} else if (r == 0) {
send_verify_objects();
}
break;
case STATE_TRIM_IMAGE:
ldout(cct, 5) << "TRIM_IMAGE" << dendl;
if (r == 0) {
send_resize_object_map();
}
break;
case STATE_VERIFY_OBJECTS:
ldout(cct, 5) << "VERIFY_OBJECTS" << dendl;
if (r == 0) {
send_save_object_map();
}
break;
case STATE_SAVE_OBJECT_MAP:
ldout(cct, 5) << "SAVE_OBJECT_MAP" << dendl;
if (r == 0) {
send_update_header();
}
break;
case STATE_UPDATE_HEADER:
ldout(cct, 5) << "UPDATE_HEADER" << dendl;
if (r == 0) {
return true;
}
break;
default:
ceph_abort();
break;
}
if (r == -ERESTART) {
ldout(cct, 5) << "rebuild object map operation interrupted" << dendl;
return true;
} else if (r < 0) {
lderr(cct) << "rebuild object map encountered an error: " << cpp_strerror(r)
<< dendl;
return true;
}
return false;
}
template <typename I>
void RebuildObjectMapRequest<I>::send_resize_object_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
CephContext *cct = m_image_ctx.cct;
m_image_ctx.image_lock.lock_shared();
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.image_lock.unlock_shared();
send_verify_objects();
return;
}
ldout(cct, 5) << this << " send_resize_object_map" << dendl;
m_state = STATE_RESIZE_OBJECT_MAP;
// should have been canceled prior to releasing lock
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
m_image_ctx.object_map->aio_resize(size, OBJECT_NONEXISTENT,
this->create_callback_context());
m_image_ctx.image_lock.unlock_shared();
}
template <typename I>
void RebuildObjectMapRequest<I>::send_trim_image() {
CephContext *cct = m_image_ctx.cct;
std::shared_lock l{m_image_ctx.owner_lock};
// should have been canceled prior to releasing lock
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
ldout(cct, 5) << this << " send_trim_image" << dendl;
m_state = STATE_TRIM_IMAGE;
uint64_t new_size;
uint64_t orig_size;
{
std::shared_lock l{m_image_ctx.image_lock};
ceph_assert(m_image_ctx.object_map != nullptr);
new_size = get_image_size();
orig_size = m_image_ctx.get_object_size() *
m_image_ctx.object_map->size();
}
TrimRequest<I> *req = TrimRequest<I>::create(m_image_ctx,
this->create_callback_context(),
orig_size, new_size, m_prog_ctx);
req->send();
}
template <typename I>
bool update_object_map(I& image_ctx, uint64_t object_no, uint8_t current_state,
uint8_t new_state) {
CephContext *cct = image_ctx.cct;
uint64_t snap_id = image_ctx.snap_id;
current_state = (*image_ctx.object_map)[object_no];
if (current_state == OBJECT_EXISTS && new_state == OBJECT_NONEXISTENT &&
snap_id == CEPH_NOSNAP) {
// might be writing object to OSD concurrently
new_state = current_state;
}
if (new_state != current_state) {
ldout(cct, 15) << image_ctx.get_object_name(object_no)
<< " rebuild updating object map "
<< static_cast<uint32_t>(current_state) << "->"
<< static_cast<uint32_t>(new_state) << dendl;
image_ctx.object_map->set_state(object_no, new_state, current_state);
}
return false;
}
template <typename I>
void RebuildObjectMapRequest<I>::send_verify_objects() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
CephContext *cct = m_image_ctx.cct;
m_state = STATE_VERIFY_OBJECTS;
ldout(cct, 5) << this << " send_verify_objects" << dendl;
ObjectMapIterateRequest<I> *req =
new ObjectMapIterateRequest<I>(m_image_ctx,
this->create_callback_context(),
m_prog_ctx, update_object_map);
req->send();
}
template <typename I>
void RebuildObjectMapRequest<I>::send_save_object_map() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " send_save_object_map" << dendl;
m_state = STATE_SAVE_OBJECT_MAP;
// should have been canceled prior to releasing lock
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
std::shared_lock 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());
}
template <typename I>
void RebuildObjectMapRequest<I>::send_update_header() {
ceph_assert(ceph_mutex_is_locked(m_image_ctx.owner_lock));
// should have been canceled prior to releasing lock
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
ldout(m_image_ctx.cct, 5) << this << " send_update_header" << dendl;
m_state = STATE_UPDATE_HEADER;
librados::ObjectWriteOperation op;
uint64_t flags = RBD_FLAG_OBJECT_MAP_INVALID | RBD_FLAG_FAST_DIFF_INVALID;
cls_client::set_flags(&op, m_image_ctx.snap_id, 0, flags);
librados::AioCompletion *comp = this->create_callback_completion();
int r = m_image_ctx.md_ctx.aio_operate(m_image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
std::unique_lock 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(ceph_mutex_is_locked(m_image_ctx.image_lock));
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();
} else {
return m_image_ctx.size;
}
}
return m_image_ctx.get_image_size(m_image_ctx.snap_id);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::RebuildObjectMapRequest<librbd::ImageCtx>;
| 7,683 | 29.613546 | 80 |
cc
|
null |
ceph-main/src/librbd/operation/RebuildObjectMapRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_REBUILD_OBJECT_MAP_REQUEST_H
#define CEPH_LIBRBD_OPERATION_REBUILD_OBJECT_MAP_REQUEST_H
#include "include/int_types.h"
#include "librbd/AsyncRequest.h"
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class RebuildObjectMapRequest : public AsyncRequest<ImageCtxT> {
public:
RebuildObjectMapRequest(ImageCtxT &image_ctx, Context *on_finish,
ProgressContext &prog_ctx)
: AsyncRequest<ImageCtxT>(image_ctx, on_finish), m_image_ctx(image_ctx),
m_prog_ctx(prog_ctx), m_attempted_trim(false)
{
}
void send() override;
protected:
bool should_complete(int r) override;
private:
/**
* Rebuild object map goes through the following state machine to
* verify per-object state:
*
* <start>
* . | . . . . . . . . . .
* . | . .
* . v v .
* . STATE_RESIZE_OBJECT_MAP . . . > STATE_TRIM_IMAGE
* . |
* . v
* . . . > STATE_VERIFY_OBJECTS
* |
* v
* STATE_SAVE_OBJECT_MAP
* |
* v
* STATE_UPDATE_HEADER
*
* The _RESIZE_OBJECT_MAP state will be skipped if the object map
* is appropriately sized for the image. The _TRIM_IMAGE state will
* only be hit if the resize failed due to an in-use object.
*/
enum State {
STATE_RESIZE_OBJECT_MAP,
STATE_TRIM_IMAGE,
STATE_VERIFY_OBJECTS,
STATE_SAVE_OBJECT_MAP,
STATE_UPDATE_HEADER
};
ImageCtxT &m_image_ctx;
ProgressContext &m_prog_ctx;
State m_state = STATE_RESIZE_OBJECT_MAP;
bool m_attempted_trim;
void send_resize_object_map();
void send_trim_image();
void send_verify_objects();
void send_save_object_map();
void send_update_header();
uint64_t get_image_size() const;
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::RebuildObjectMapRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_REBUILD_OBJECT_MAP_REQUEST_H
| 2,232 | 25.270588 | 83 |
h
|
null |
ceph-main/src/librbd/operation/RenameRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/RenameRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "include/rados/librados.hpp"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::operation::RenameRequest: "
namespace librbd {
namespace operation {
namespace {
template <typename I>
std::ostream& operator<<(std::ostream& os,
const typename RenameRequest<I>::State& state) {
switch(state) {
case RenameRequest<I>::STATE_READ_DIRECTORY:
os << "READ_DIRECTORY";
break;
case RenameRequest<I>::STATE_READ_SOURCE_HEADER:
os << "READ_SOURCE_HEADER";
break;
case RenameRequest<I>::STATE_WRITE_DEST_HEADER:
os << "WRITE_DEST_HEADER";
break;
case RenameRequest<I>::STATE_UPDATE_DIRECTORY:
os << "UPDATE_DIRECTORY";
break;
case RenameRequest<I>::STATE_REMOVE_SOURCE_HEADER:
os << "REMOVE_SOURCE_HEADER";
break;
default:
os << "UNKNOWN (" << static_cast<uint32_t>(state) << ")";
break;
}
return os;
}
} // anonymous namespace
template <typename I>
RenameRequest<I>::RenameRequest(I &image_ctx, Context *on_finish,
const std::string &dest_name)
: Request<I>(image_ctx, on_finish), m_dest_name(dest_name),
m_source_oid(image_ctx.old_format ? util::old_header_name(image_ctx.name) :
util::id_obj_name(image_ctx.name)),
m_dest_oid(image_ctx.old_format ? util::old_header_name(dest_name) :
util::id_obj_name(dest_name)) {
}
template <typename I>
void RenameRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
if (image_ctx.old_format) {
send_read_source_header();
return;
}
send_read_directory();
}
template <typename I>
bool RenameRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
r = filter_return_code(r);
if (r < 0) {
if (r == -EEXIST) {
ldout(cct, 1) << "image already exists" << dendl;
} else {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
if (m_state == STATE_READ_DIRECTORY) {
std::string name;
auto it = m_source_name_bl.cbegin();
r = cls_client::dir_get_name_finish(&it, &name);
if (r < 0) {
lderr(cct) << "could not read directory: " << cpp_strerror(r) << dendl;
return true;
}
bool update = false;
{
std::shared_lock image_locker{image_ctx.image_lock};
update = image_ctx.name != name;
}
if (update) {
image_ctx.set_image_name(name);
m_source_oid = util::id_obj_name(name);
}
} else if (m_state == STATE_UPDATE_DIRECTORY) {
// update in-memory name before removing source header
apply();
} else if (m_state == STATE_REMOVE_SOURCE_HEADER) {
return true;
}
std::shared_lock owner_lock{image_ctx.owner_lock};
switch (m_state) {
case STATE_READ_DIRECTORY:
send_read_source_header();
break;
case STATE_READ_SOURCE_HEADER:
send_write_destination_header();
break;
case STATE_WRITE_DEST_HEADER:
send_update_directory();
break;
case STATE_UPDATE_DIRECTORY:
send_remove_source_header();
break;
default:
ceph_abort();
break;
}
return false;
}
template <typename I>
int RenameRequest<I>::filter_return_code(int r) const {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_state == STATE_READ_SOURCE_HEADER && r == -ENOENT) {
std::shared_lock image_locker{image_ctx.image_lock};
if (image_ctx.name == m_dest_name) {
// signal that replay raced with itself
return -EEXIST;
}
} else if (m_state == STATE_REMOVE_SOURCE_HEADER && r < 0) {
if (r != -ENOENT) {
lderr(cct) << "warning: couldn't remove old source object ("
<< m_source_oid << ")" << dendl;
}
return 0;
}
return r;
}
template <typename I>
void RenameRequest<I>::send_read_directory() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_READ_DIRECTORY;
librados::ObjectReadOperation op;
cls_client::dir_get_name_start(&op, image_ctx.id);
auto comp = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(RBD_DIRECTORY, comp, &op,
&m_source_name_bl);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void RenameRequest<I>::send_read_source_header() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_READ_SOURCE_HEADER;
librados::ObjectReadOperation op;
op.read(0, 0, NULL, NULL);
// TODO: old code read omap values but there are no omap values on the
// old format header nor the new format id object
librados::AioCompletion *rados_completion = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(m_source_oid, rados_completion, &op,
&m_header_bl);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
void RenameRequest<I>::send_write_destination_header() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_WRITE_DEST_HEADER;
librados::ObjectWriteOperation op;
op.create(true);
op.write_full(m_header_bl);
librados::AioCompletion *rados_completion = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(m_dest_oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
void RenameRequest<I>::send_update_directory() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_UPDATE_DIRECTORY;
librados::ObjectWriteOperation op;
if (image_ctx.old_format) {
bufferlist cmd_bl;
bufferlist empty_bl;
encode(static_cast<__u8>(CEPH_OSD_TMAP_SET), cmd_bl);
encode(m_dest_name, cmd_bl);
encode(empty_bl, cmd_bl);
encode(static_cast<__u8>(CEPH_OSD_TMAP_RM), cmd_bl);
encode(image_ctx.name, cmd_bl);
op.tmap_update(cmd_bl);
} else {
cls_client::dir_rename_image(&op, image_ctx.name, m_dest_name,
image_ctx.id);
}
librados::AioCompletion *rados_completion = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(RBD_DIRECTORY, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
void RenameRequest<I>::send_remove_source_header() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_REMOVE_SOURCE_HEADER;
librados::ObjectWriteOperation op;
op.remove();
librados::AioCompletion *rados_completion = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(m_source_oid, rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
void RenameRequest<I>::apply() {
I &image_ctx = this->m_image_ctx;
image_ctx.set_image_name(m_dest_name);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::RenameRequest<librbd::ImageCtx>;
| 7,682 | 28.77907 | 81 |
cc
|
null |
ceph-main/src/librbd/operation/RenameRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_RENAME_REQUEST_H
#define CEPH_LIBRBD_RENAME_REQUEST_H
#include "librbd/operation/Request.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class RenameRequest : public Request<ImageCtxT>
{
public:
/**
* Rename goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_READ_DIRECTORY
* |
* v
* STATE_READ_SOURCE_HEADER
* |
* v
* STATE_WRITE_DEST_HEADER
* |
* v
* STATE_UPDATE_DIRECTORY
* |
* v
* STATE_REMOVE_SOURCE_HEADER
* |
* v
* <finish>
*
* @endverbatim
*
*/
enum State {
STATE_READ_DIRECTORY,
STATE_READ_SOURCE_HEADER,
STATE_WRITE_DEST_HEADER,
STATE_UPDATE_DIRECTORY,
STATE_REMOVE_SOURCE_HEADER
};
RenameRequest(ImageCtxT &image_ctx, Context *on_finish,
const std::string &dest_name);
protected:
void send_op() override;
bool should_complete(int r) override;
int filter_return_code(int r) const override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::RenameEvent(op_tid, m_dest_name);
}
private:
std::string m_dest_name;
std::string m_source_oid;
std::string m_dest_oid;
State m_state = STATE_READ_DIRECTORY;
bufferlist m_source_name_bl;
bufferlist m_header_bl;
void send_read_directory();
void send_read_source_header();
void send_write_destination_header();
void send_update_directory();
void send_remove_source_header();
void apply();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::RenameRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_RENAME_REQUEST_H
| 1,884 | 18.635417 | 73 |
h
|
null |
ceph-main/src/librbd/operation/Request.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/Request.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::Request: "
namespace librbd {
namespace operation {
template <typename I>
Request<I>::Request(I &image_ctx, Context *on_finish, uint64_t journal_op_tid)
: AsyncRequest<I>(image_ctx, on_finish), m_op_tid(journal_op_tid) {
}
template <typename I>
void Request<I>::send() {
[[maybe_unused]] I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
// automatically create the event if we don't need to worry
// about affecting concurrent IO ops
if (can_affect_io() || !append_op_event()) {
send_op();
}
}
template <typename I>
Context *Request<I>::create_context_finisher(int r) {
// automatically commit the event if required (delete after commit)
if (m_appended_op_event && !m_committed_op_event &&
commit_op_event(r)) {
return nullptr;
}
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
return util::create_context_callback<Request<I>, &Request<I>::finish>(this);
}
template <typename I>
void Request<I>::finish_and_destroy(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << r << dendl;
// automatically commit the event if required (delete after commit)
if (m_appended_op_event && !m_committed_op_event &&
commit_op_event(r)) {
return;
}
AsyncRequest<I>::finish_and_destroy(r);
}
template <typename I>
void Request<I>::finish(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << r << dendl;
ceph_assert(!m_appended_op_event || m_committed_op_event);
AsyncRequest<I>::finish(r);
}
template <typename I>
bool Request<I>::append_op_event() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
std::shared_lock image_locker{image_ctx.image_lock};
if (image_ctx.journal != nullptr &&
image_ctx.journal->is_journal_appending()) {
append_op_event(util::create_context_callback<
Request<I>, &Request<I>::handle_op_event_safe>(this));
return true;
}
return false;
}
template <typename I>
bool Request<I>::commit_op_event(int r) {
I &image_ctx = this->m_image_ctx;
std::shared_lock image_locker{image_ctx.image_lock};
if (!m_appended_op_event) {
return false;
}
ceph_assert(m_op_tid != 0);
ceph_assert(!m_committed_op_event);
m_committed_op_event = true;
if (image_ctx.journal != nullptr &&
image_ctx.journal->is_journal_appending()) {
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << r << dendl;
// ops will be canceled / completed before closing journal
ceph_assert(image_ctx.journal->is_journal_ready());
image_ctx.journal->commit_op_event(m_op_tid, r,
new C_CommitOpEvent(this, r));
return true;
}
return false;
}
template <typename I>
void Request<I>::handle_commit_op_event(int r, int original_ret_val) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to commit op event to journal: " << cpp_strerror(r)
<< dendl;
}
if (original_ret_val < 0) {
r = original_ret_val;
}
finish(r);
}
template <typename I>
void Request<I>::replay_op_ready(Context *on_safe) {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
ceph_assert(m_op_tid != 0);
m_appended_op_event = true;
image_ctx.journal->replay_op_ready(
m_op_tid, util::create_async_context_callback(image_ctx, on_safe));
}
template <typename I>
void Request<I>::append_op_event(Context *on_safe) {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
m_op_tid = image_ctx.journal->allocate_op_tid();
image_ctx.journal->append_op_event(
m_op_tid, journal::EventEntry{create_event(m_op_tid)},
new C_AppendOpEvent(this, on_safe));
}
template <typename I>
void Request<I>::handle_op_event_safe(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << ": r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to commit op event to journal: " << cpp_strerror(r)
<< dendl;
this->finish(r);
delete this;
} else {
ceph_assert(!can_affect_io());
// haven't started the request state machine yet
std::shared_lock owner_locker{image_ctx.owner_lock};
send_op();
}
}
} // namespace operation
} // namespace librbd
#ifndef TEST_F
template class librbd::operation::Request<librbd::ImageCtx>;
#endif
| 5,347 | 28.065217 | 78 |
cc
|
null |
ceph-main/src/librbd/operation/Request.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_REQUEST_H
#define CEPH_LIBRBD_OPERATION_REQUEST_H
#include "librbd/AsyncRequest.h"
#include "include/Context.h"
#include "librbd/Utils.h"
#include "librbd/Journal.h"
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class Request : public AsyncRequest<ImageCtxT> {
public:
Request(ImageCtxT &image_ctx, Context *on_finish,
uint64_t journal_op_tid = 0);
void send();
protected:
void finish(int r) override;
virtual void send_op() = 0;
virtual bool can_affect_io() const {
return false;
}
virtual journal::Event create_event(uint64_t op_tid) const = 0;
template <typename T, Context*(T::*MF)(int*)>
bool append_op_event(T *request) {
ImageCtxT &image_ctx = this->m_image_ctx;
ceph_assert(can_affect_io());
std::scoped_lock locker{image_ctx.owner_lock, 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);
replay_op_ready(ctx);
return true;
} else if (image_ctx.journal->is_journal_appending()) {
Context *ctx = util::create_context_callback<T, MF>(request);
append_op_event(ctx);
return true;
}
}
return false;
}
bool append_op_event();
// NOTE: temporary until converted to new state machine format
Context *create_context_finisher(int r);
void finish_and_destroy(int r) override;
private:
struct C_AppendOpEvent : public Context {
Request *request;
Context *on_safe;
C_AppendOpEvent(Request *request, Context *on_safe)
: request(request), on_safe(on_safe) {
}
void finish(int r) override {
if (r >= 0) {
request->m_appended_op_event = true;
}
on_safe->complete(r);
}
};
struct C_CommitOpEvent : public Context {
Request *request;
int ret_val;
C_CommitOpEvent(Request *request, int ret_val)
: request(request), ret_val(ret_val) {
}
void finish(int r) override {
request->handle_commit_op_event(r, ret_val);
delete request;
}
};
uint64_t m_op_tid = 0;
bool m_appended_op_event = false;
bool m_committed_op_event = false;
void replay_op_ready(Context *on_safe);
void append_op_event(Context *on_safe);
void handle_op_event_safe(int r);
bool commit_op_event(int r);
void handle_commit_op_event(int r, int original_ret_val);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::Request<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_REQUEST_H
| 2,749 | 24.700935 | 72 |
h
|
null |
ceph-main/src/librbd/operation/ResizeRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/ResizeRequest.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageDispatchSpec.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/operation/TrimRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::operation::ResizeRequest: " << this \
<< " " << __func__ << ": "
namespace librbd {
namespace operation {
using util::create_async_context_callback;
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
ResizeRequest<I>::ResizeRequest(I &image_ctx, Context *on_finish,
uint64_t new_size, bool allow_shrink, ProgressContext &prog_ctx,
uint64_t journal_op_tid, bool disable_journal)
: Request<I>(image_ctx, on_finish, journal_op_tid),
m_original_size(0), m_new_size(new_size), m_allow_shrink(allow_shrink),
m_prog_ctx(prog_ctx), m_new_parent_overlap(0), m_disable_journal(disable_journal),
m_xlist_item(this)
{
}
template <typename I>
ResizeRequest<I>::~ResizeRequest() {
I &image_ctx = this->m_image_ctx;
ResizeRequest *next_req = NULL;
{
std::unique_lock 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();
}
}
if (next_req != NULL) {
std::shared_lock owner_locker{image_ctx.owner_lock};
next_req->send();
}
}
template <typename I>
void ResizeRequest<I>::send() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
{
std::unique_lock 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) {
return;
}
}
ceph_assert(image_ctx.resize_reqs.front() == this);
m_original_size = image_ctx.size;
compute_parent_overlap();
}
Request<I>::send();
}
template <typename I>
void ResizeRequest<I>::send_op() {
[[maybe_unused]] I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
if (this->is_canceled()) {
this->async_complete(-ERESTART);
} else {
send_pre_block_writes();
}
}
template <typename I>
void ResizeRequest<I>::send_pre_block_writes() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_pre_block_writes>(this));
}
template <typename I>
Context *ResizeRequest<I>::handle_pre_block_writes(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(*result);
}
return send_append_op_event();
}
template <typename I>
Context *ResizeRequest<I>::send_append_op_event() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_new_size < m_original_size && !m_allow_shrink) {
ldout(cct, 1) << "shrinking the image is not permitted" << dendl;
image_ctx.io_image_dispatcher->unblock_writes();
this->async_complete(-EINVAL);
return nullptr;
}
if (m_disable_journal || !this->template append_op_event<
ResizeRequest<I>, &ResizeRequest<I>::handle_append_op_event>(this)) {
return send_grow_object_map();
}
ldout(cct, 5) << dendl;
return nullptr;
}
template <typename I>
Context *ResizeRequest<I>::handle_append_op_event(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to commit journal entry: " << cpp_strerror(*result)
<< dendl;
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(*result);
}
return send_grow_object_map();
}
template <typename I>
void ResizeRequest<I>::send_trim_image() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
TrimRequest<I> *req = TrimRequest<I>::create(
image_ctx, create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_trim_image>(this),
m_original_size, m_new_size, m_prog_ctx);
req->send();
}
template <typename I>
Context *ResizeRequest<I>::handle_trim_image(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result == -ERESTART) {
ldout(cct, 5) << "resize operation interrupted" << dendl;
return this->create_context_finisher(*result);
} else if (*result < 0) {
lderr(cct) << "failed to trim image: " << cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_post_block_writes();
return nullptr;
}
template <typename I>
void ResizeRequest<I>::send_flush_cache() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
auto ctx = create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_flush_cache>(this);
auto aio_comp = io::AioCompletion::create_and_start(
ctx, util::get_image_ctx(&image_ctx), io::AIO_TYPE_FLUSH);
auto req = io::ImageDispatchSpec::create_flush(
image_ctx, io::IMAGE_DISPATCH_LAYER_INTERNAL_START, aio_comp,
io::FLUSH_SOURCE_INTERNAL, {});
req->send();
}
template <typename I>
Context *ResizeRequest<I>::handle_flush_cache(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to flush cache: " << cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_invalidate_cache();
return nullptr;
}
template <typename I>
void ResizeRequest<I>::send_invalidate_cache() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
// need to invalidate since we're deleting objects, and
// ObjectCacher doesn't track non-existent objects
image_ctx.io_image_dispatcher->invalidate_cache(create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_invalidate_cache>(this));
}
template <typename I>
Context *ResizeRequest<I>::handle_invalidate_cache(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
// ignore busy error -- writeback was successfully flushed so we might be
// wasting some cache space for trimmed objects, but they will get purged
// eventually. Most likely cause of the issue was a in-flight cache read
if (*result < 0 && *result != -EBUSY) {
lderr(cct) << "failed to invalidate cache: " << cpp_strerror(*result)
<< dendl;
return this->create_context_finisher(*result);
}
send_trim_image();
return nullptr;
}
template <typename I>
Context *ResizeRequest<I>::send_grow_object_map() {
I &image_ctx = this->m_image_ctx;
{
std::unique_lock image_locker{image_ctx.image_lock};
m_shrink_size_visible = true;
}
if (m_original_size == m_new_size) {
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(0);
} else if (m_new_size < m_original_size) {
image_ctx.io_image_dispatcher->unblock_writes();
send_flush_cache();
return nullptr;
}
image_ctx.owner_lock.lock_shared();
image_ctx.image_lock.lock_shared();
if (image_ctx.object_map == nullptr) {
image_ctx.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
// IO is still blocked
send_update_header();
return nullptr;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
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.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
return nullptr;
}
template <typename I>
Context *ResizeRequest<I>::handle_grow_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to resize object map: "
<< cpp_strerror(*result) << dendl;
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(*result);
}
// IO is still blocked
send_update_header();
return nullptr;
}
template <typename I>
Context *ResizeRequest<I>::send_shrink_object_map() {
I &image_ctx = this->m_image_ctx;
image_ctx.owner_lock.lock_shared();
image_ctx.image_lock.lock_shared();
if (image_ctx.object_map == nullptr || m_new_size > m_original_size) {
image_ctx.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
update_size_and_overlap();
return this->create_context_finisher(0);
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "original_size=" << m_original_size << ", "
<< "new_size=" << m_new_size << dendl;
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
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.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
return nullptr;
}
template <typename I>
Context *ResizeRequest<I>::handle_shrink_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to resize object map: "
<< cpp_strerror(*result) << dendl;
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(*result);
}
update_size_and_overlap();
return this->create_context_finisher(0);
}
template <typename I>
void ResizeRequest<I>::send_post_block_writes() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_post_block_writes>(this));
}
template <typename I>
Context *ResizeRequest<I>::handle_post_block_writes(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
image_ctx.io_image_dispatcher->unblock_writes();
lderr(cct) << "failed to block writes prior to header update: "
<< cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_update_header();
return nullptr;
}
template <typename I>
void ResizeRequest<I>::send_update_header() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "original_size=" << m_original_size << ", "
<< "new_size=" << m_new_size << dendl;;
// should have been canceled prior to releasing lock
std::shared_lock owner_locker{image_ctx.owner_lock};
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
librados::ObjectWriteOperation op;
if (image_ctx.old_format) {
// rewrite only the size field of the header
ceph_le64 new_size(m_new_size);
bufferlist bl;
bl.append(reinterpret_cast<const char*>(&new_size), sizeof(new_size));
op.write(offsetof(rbd_obj_header_ondisk, image_size), bl);
} else {
cls_client::set_size(&op, m_new_size);
}
librados::AioCompletion *rados_completion = create_rados_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_update_header>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid,
rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *ResizeRequest<I>::handle_update_header(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to update image header: " << cpp_strerror(*result)
<< dendl;
image_ctx.io_image_dispatcher->unblock_writes();
return this->create_context_finisher(*result);
}
return send_shrink_object_map();
}
template <typename I>
void ResizeRequest<I>::compute_parent_overlap() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
if (image_ctx.parent == NULL) {
m_new_parent_overlap = 0;
} else {
m_new_parent_overlap = std::min(m_new_size, image_ctx.parent_md.overlap);
}
}
template <typename I>
void ResizeRequest<I>::update_size_and_overlap() {
I &image_ctx = this->m_image_ctx;
{
std::unique_lock image_locker{image_ctx.image_lock};
image_ctx.size = m_new_size;
if (image_ctx.parent != NULL && m_new_size < m_original_size) {
image_ctx.parent_md.overlap = m_new_parent_overlap;
}
}
// blocked by PRE_BLOCK_WRITES (grow) or POST_BLOCK_WRITES (shrink) state
image_ctx.io_image_dispatcher->unblock_writes();
}
} // namespace operation
} // namespace librbd
template class librbd::operation::ResizeRequest<librbd::ImageCtx>;
| 14,389 | 29.813704 | 96 |
cc
|
null |
ceph-main/src/librbd/operation/ResizeRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_RESIZE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_RESIZE_REQUEST_H
#include "librbd/operation/Request.h"
#include "include/xlist.h"
namespace librbd
{
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class ResizeRequest : public Request<ImageCtxT> {
public:
static ResizeRequest *create(ImageCtxT &image_ctx, Context *on_finish,
uint64_t new_size, bool allow_shrink,
ProgressContext &prog_ctx, uint64_t journal_op_tid,
bool disable_journal) {
return new ResizeRequest(image_ctx, on_finish, new_size, allow_shrink, prog_ctx,
journal_op_tid, disable_journal);
}
ResizeRequest(ImageCtxT &image_ctx, Context *on_finish, uint64_t new_size,
bool allow_shrink, ProgressContext &prog_ctx, uint64_t journal_op_tid,
bool disable_journal);
~ResizeRequest() override;
inline bool shrinking() const {
return (m_shrink_size_visible && m_new_size < m_original_size);
}
inline uint64_t get_image_size() const {
return m_new_size;
}
void send() override;
protected:
void send_op() override;
bool should_complete(int r) override {
return true;
}
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::ResizeEvent(op_tid, m_new_size);
}
private:
/**
* Resize goes through the following state machine to resize the image
* and update the object map:
*
* @verbatim
*
* <start>
* |
* v
* STATE_PRE_BLOCK_WRITES
* |
* v
* STATE_APPEND_OP_EVENT (skip if journaling
* | disabled)
* |
* | (grow)
* |\--------> STATE_GROW_OBJECT_MAP (skip if object map
* | | disabled)
* | v
* | STATE_UPDATE_HEADER ----------------------------\
* | (unblock writes) |
* | |
* | (unblock writes) |
* | |
* | (shrink) |
* |\--------> STATE_FLUSH_CACHE |
* | | |
* | v |
* | STATE_INVALIDATE_CACHE |
* | | |
* | v |
* | STATE_TRIM_IMAGE |
* | | |
* | v |
* | STATE_POST_BLOCK_WRITES |
* | | |
* | v |
* | STATE_UPDATE_HEADER |
* | | |
* | v |
* | STATE_SHRINK_OBJECT_MAP (skip if object map |
* | | disabled) |
* | | (unblock writes) |
* | (no change) v |
* \------------> <finish> <-----------------------------------/
*
* @endverbatim
*
* The _OBJECT_MAP states are skipped if the object map isn't enabled.
* The state machine will immediately transition to _FINISHED if there
* are no objects to trim.
*/
uint64_t m_original_size;
uint64_t m_new_size;
bool m_allow_shrink = true;
ProgressContext &m_prog_ctx;
uint64_t m_new_parent_overlap;
bool m_shrink_size_visible = false;
bool m_disable_journal = false;
typename xlist<ResizeRequest<ImageCtxT>*>::item m_xlist_item;
void send_pre_block_writes();
Context *handle_pre_block_writes(int *result);
Context *send_append_op_event();
Context *handle_append_op_event(int *result);
void send_flush_cache();
Context *handle_flush_cache(int *result);
void send_invalidate_cache();
Context *handle_invalidate_cache(int *result);
void send_trim_image();
Context *handle_trim_image(int *result);
Context *send_grow_object_map();
Context *handle_grow_object_map(int *result);
Context *send_shrink_object_map();
Context *handle_shrink_object_map(int *result);
void send_post_block_writes();
Context *handle_post_block_writes(int *result);
void send_update_header();
Context *handle_update_header(int *result);
void compute_parent_overlap();
void update_size_and_overlap();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::ResizeRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_RESIZE_REQUEST_H
| 5,353 | 33.101911 | 86 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotCreateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/operation/SnapshotCreateRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageWatcher.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/mirror/snapshot/SetImageStateRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotCreateRequest: "
namespace librbd {
namespace operation {
using util::create_async_context_callback;
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
SnapshotCreateRequest<I>::SnapshotCreateRequest(I &image_ctx,
Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name,
uint64_t journal_op_tid,
uint64_t flags,
ProgressContext &prog_ctx)
: Request<I>(image_ctx, on_finish, journal_op_tid),
m_snap_namespace(snap_namespace), m_snap_name(snap_name),
m_skip_object_map(flags & SNAP_CREATE_FLAG_SKIP_OBJECT_MAP),
m_skip_notify_quiesce(flags & SNAP_CREATE_FLAG_SKIP_NOTIFY_QUIESCE),
m_ignore_notify_quiesce_error(flags & SNAP_CREATE_FLAG_IGNORE_NOTIFY_QUIESCE_ERROR),
m_prog_ctx(prog_ctx) {
}
template <typename I>
void SnapshotCreateRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (!image_ctx.data_ctx.is_valid()) {
lderr(cct) << "missing data pool" << dendl;
this->async_complete(-ENODEV);
return;
}
send_notify_quiesce();
}
template <typename I>
void SnapshotCreateRequest<I>::send_notify_quiesce() {
if (m_skip_notify_quiesce) {
send_suspend_requests();
return;
}
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
image_ctx.image_watcher->notify_quiesce(
&m_request_id, m_prog_ctx, create_async_context_callback(
image_ctx, create_context_callback<SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_notify_quiesce>(this)));
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_notify_quiesce(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0 && !m_ignore_notify_quiesce_error) {
lderr(cct) << "failed to notify quiesce: " << cpp_strerror(*result)
<< dendl;
save_result(result);
send_notify_unquiesce();
return nullptr;
}
std::shared_lock owner_locker{image_ctx.owner_lock};
send_suspend_requests();
return nullptr;
}
template <typename I>
void SnapshotCreateRequest<I>::send_suspend_requests() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
// TODO suspend (shrink) resize to ensure consistent RBD mirror
send_suspend_aio();
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_suspend_requests(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
// TODO
send_suspend_aio();
return nullptr;
}
template <typename I>
void SnapshotCreateRequest<I>::send_suspend_aio() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_suspend_aio>(this));
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_suspend_aio(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
save_result(result);
return send_notify_unquiesce();
}
m_writes_blocked = true;
send_append_op_event();
return nullptr;
}
template <typename I>
void SnapshotCreateRequest<I>::send_append_op_event() {
I &image_ctx = this->m_image_ctx;
if (!this->template append_op_event<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_append_op_event>(this)) {
send_allocate_snap_id();
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_append_op_event(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to commit journal entry: " << cpp_strerror(*result)
<< dendl;
save_result(result);
return send_notify_unquiesce();
}
send_allocate_snap_id();
return nullptr;
}
template <typename I>
void SnapshotCreateRequest<I>::send_allocate_snap_id() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
librados::AioCompletion *rados_completion = create_rados_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_allocate_snap_id>(this);
image_ctx.data_ctx.aio_selfmanaged_snap_create(&m_snap_id, rados_completion);
rados_completion->release();
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_allocate_snap_id(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << ", "
<< "snap_id=" << m_snap_id << dendl;
if (*result < 0) {
lderr(cct) << "failed to allocate snapshot id: " << cpp_strerror(*result)
<< dendl;
save_result(result);
return send_notify_unquiesce();
}
send_create_snap();
return nullptr;
}
template <typename I>
void SnapshotCreateRequest<I>::send_create_snap() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock image_locker{image_ctx.image_lock};
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
// save current size / parent info for creating snapshot record in ImageCtx
m_size = image_ctx.size;
m_parent_info = image_ctx.parent_md;
librados::ObjectWriteOperation op;
if (image_ctx.old_format) {
cls_client::old_snapshot_add(&op, m_snap_id, m_snap_name);
} else {
cls_client::snapshot_add(&op, m_snap_id, m_snap_name, m_snap_namespace);
}
librados::AioCompletion *rados_completion = create_rados_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_create_snap>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid,
rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_create_snap(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == -ESTALE) {
send_allocate_snap_id();
return nullptr;
} else if (*result < 0) {
save_result(result);
send_release_snap_id();
return nullptr;
}
return send_create_object_map();
}
template <typename I>
Context *SnapshotCreateRequest<I>::send_create_object_map() {
I &image_ctx = this->m_image_ctx;
image_ctx.image_lock.lock_shared();
if (image_ctx.object_map == nullptr || m_skip_object_map) {
image_ctx.image_lock.unlock_shared();
return send_create_image_state();
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
image_ctx.object_map->snapshot_add(
m_snap_id, create_context_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_create_object_map>(this));
image_ctx.image_lock.unlock_shared();
return nullptr;
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_create_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << this << " " << __func__ << ": failed to snapshot object map: "
<< cpp_strerror(*result) << dendl;
save_result(result);
update_snap_context();
return send_notify_unquiesce();
}
return send_create_image_state();
}
template <typename I>
Context *SnapshotCreateRequest<I>::send_create_image_state() {
I &image_ctx = this->m_image_ctx;
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&m_snap_namespace);
if (mirror_ns == nullptr || !mirror_ns->is_primary()) {
update_snap_context();
return send_notify_unquiesce();
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
auto req = mirror::snapshot::SetImageStateRequest<I>::create(
&image_ctx, m_snap_id, create_context_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_create_image_state>(this));
req->send();
return nullptr;
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_create_image_state(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
update_snap_context();
if (*result < 0) {
lderr(cct) << this << " " << __func__ << ": failed to create image state: "
<< cpp_strerror(*result) << dendl;
save_result(result);
}
return send_notify_unquiesce();
}
template <typename I>
void SnapshotCreateRequest<I>::send_release_snap_id() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
ceph_assert(m_snap_id != CEPH_NOSNAP);
librados::AioCompletion *rados_completion = create_rados_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_release_snap_id>(this);
image_ctx.data_ctx.aio_selfmanaged_snap_remove(m_snap_id, rados_completion);
rados_completion->release();
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_release_snap_id(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
return send_notify_unquiesce();
}
template <typename I>
Context *SnapshotCreateRequest<I>::send_notify_unquiesce() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (m_writes_blocked) {
image_ctx.io_image_dispatcher->unblock_writes();
}
if (m_skip_notify_quiesce) {
return this->create_context_finisher(m_ret_val);
}
ldout(cct, 5) << this << " " << __func__ << dendl;
image_ctx.image_watcher->notify_unquiesce(
m_request_id, create_context_callback<
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_notify_unquiesce>(this));
return nullptr;
}
template <typename I>
Context *SnapshotCreateRequest<I>::handle_notify_unquiesce(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to notify unquiesce: " << cpp_strerror(*result)
<< dendl;
// ignore error
}
*result = m_ret_val;
return this->create_context_finisher(m_ret_val);
}
template <typename I>
void SnapshotCreateRequest<I>::update_snap_context() {
I &image_ctx = this->m_image_ctx;
std::shared_lock owner_locker{image_ctx.owner_lock};
std::unique_lock image_locker{image_ctx.image_lock};
if (image_ctx.get_snap_info(m_snap_id) != NULL) {
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
// immediately add a reference to the new snapshot
utime_t snap_time = ceph_clock_now();
image_ctx.add_snap(m_snap_namespace, m_snap_name, m_snap_id, m_size,
m_parent_info, RBD_PROTECTION_STATUS_UNPROTECTED,
0, snap_time);
// immediately start using the new snap context if we
// own the exclusive lock
std::vector<snapid_t> snaps;
snaps.push_back(m_snap_id);
snaps.insert(snaps.end(), image_ctx.snapc.snaps.begin(),
image_ctx.snapc.snaps.end());
image_ctx.snapc.seq = m_snap_id;
image_ctx.snapc.snaps.swap(snaps);
image_ctx.data_ctx.selfmanaged_snap_set_write_ctx(
image_ctx.snapc.seq, image_ctx.snaps);
image_ctx.rebuild_data_io_context();
if (!image_ctx.migration_info.empty()) {
auto it = image_ctx.migration_info.snap_map.find(CEPH_NOSNAP);
ceph_assert(it != image_ctx.migration_info.snap_map.end());
ceph_assert(!it->second.empty());
if (it->second[0] == CEPH_NOSNAP) {
ldout(cct, 5) << this << " " << __func__
<< ": updating migration snap_map" << dendl;
it->second[0] = m_snap_id;
}
}
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotCreateRequest<librbd::ImageCtx>;
| 14,041 | 30.204444 | 88 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotCreateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_CREATE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_CREATE_REQUEST_H
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/Types.h"
#include "librbd/operation/Request.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotCreateRequest : public Request<ImageCtxT> {
public:
/**
* Snap Create goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_NOTIFY_QUIESCE * * * * * * * * * * * * *
* | *
* v *
* STATE_SUSPEND_REQUESTS *
* | *
* v *
* STATE_SUSPEND_AIO * * * * * * * * * * * * * * *
* | *
* v *
* STATE_APPEND_OP_EVENT (skip if journal *
* | disabled) *
* (retry) v *
* . . . > STATE_ALLOCATE_SNAP_ID *
* . | *
* . v *
* . . . . STATE_CREATE_SNAP * * * * * * * * * * * *
* | * *
* v * *
* STATE_CREATE_OBJECT_MAP (skip if * *
* | disabled) * *
* v * *
* STATE_CREATE_IMAGE_STATE (skip if * *
* | not mirror * *
* | snapshot) * *
* | v *
* | STATE_RELEASE_SNAP_ID *
* | | *
* | v *
* \------------> STATE_NOTIFY_UNQUIESCE < * *
* |
* v
* <finish>
* @endverbatim
*
* The _CREATE_STATE state may repeat back to the _ALLOCATE_SNAP_ID state
* if a stale snapshot context is allocated. If the create operation needs
* to abort, the error path is followed to record the result in the journal
* (if enabled) and bubble the originating error code back to the client.
*/
SnapshotCreateRequest(ImageCtxT &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name, uint64_t journal_op_tid,
uint64_t flags, ProgressContext &prog_ctx);
protected:
void send_op() override;
bool should_complete(int r) override {
return true;
}
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapCreateEvent(op_tid, m_snap_namespace, m_snap_name);
}
private:
cls::rbd::SnapshotNamespace m_snap_namespace;
std::string m_snap_name;
bool m_skip_object_map;
bool m_skip_notify_quiesce;
bool m_ignore_notify_quiesce_error;
ProgressContext &m_prog_ctx;
uint64_t m_request_id = 0;
int m_ret_val = 0;
bool m_writes_blocked = false;
uint64_t m_snap_id = CEPH_NOSNAP;
uint64_t m_size;
ParentImageInfo m_parent_info;
void send_notify_quiesce();
Context *handle_notify_quiesce(int *result);
void send_suspend_requests();
Context *handle_suspend_requests(int *result);
void send_suspend_aio();
Context *handle_suspend_aio(int *result);
void send_append_op_event();
Context *handle_append_op_event(int *result);
void send_allocate_snap_id();
Context *handle_allocate_snap_id(int *result);
void send_create_snap();
Context *handle_create_snap(int *result);
Context *send_create_object_map();
Context *handle_create_object_map(int *result);
Context *send_create_image_state();
Context *handle_create_image_state(int *result);
void send_release_snap_id();
Context *handle_release_snap_id(int *result);
Context *send_notify_unquiesce();
Context *handle_notify_unquiesce(int *result);
void update_snap_context();
void save_result(int *result) {
if (m_ret_val == 0 && *result < 0) {
m_ret_val = *result;
}
}
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotCreateRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_CREATE_REQUEST_H
| 5,112 | 33.315436 | 81 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotLimitRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotLimitRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotLimitRequest: "
namespace librbd {
namespace operation {
template <typename I>
SnapshotLimitRequest<I>::SnapshotLimitRequest(I &image_ctx,
Context *on_finish,
uint64_t limit)
: Request<I>(image_ctx, on_finish), m_snap_limit(limit) {
}
template <typename I>
void SnapshotLimitRequest<I>::send_op() {
send_limit_snaps();
}
template <typename I>
bool SnapshotLimitRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << " r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void SnapshotLimitRequest<I>::send_limit_snaps() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
{
std::shared_lock image_locker{image_ctx.image_lock};
librados::ObjectWriteOperation op;
cls_client::snapshot_set_limit(&op, m_snap_limit);
librados::AioCompletion *rados_completion =
this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, rados_completion,
&op);
ceph_assert(r == 0);
rados_completion->release();
}
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotLimitRequest<librbd::ImageCtx>;
| 1,793 | 25.776119 | 80 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotLimitRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_LIMIT_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_LIMIT_REQUEST_H
#include "librbd/operation/Request.h"
#include <iosfwd>
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotLimitRequest : public Request<ImageCtxT> {
public:
SnapshotLimitRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t limit);
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapLimitEvent(op_tid, m_snap_limit);
}
private:
uint64_t m_snap_limit;
void send_limit_snaps();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotLimitRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_LIMIT_REQUEST_H
| 1,018 | 21.644444 | 80 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotProtectRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotProtectRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotProtectRequest: "
namespace librbd {
namespace operation {
namespace {
template <typename I>
std::ostream& operator<<(std::ostream& os,
const typename SnapshotProtectRequest<I>::State& state) {
switch(state) {
case SnapshotProtectRequest<I>::STATE_PROTECT_SNAP:
os << "PROTECT_SNAP";
break;
}
return os;
}
} // anonymous namespace
template <typename I>
SnapshotProtectRequest<I>::SnapshotProtectRequest(I &image_ctx,
Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name)
: Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
m_snap_name(snap_name), m_state(STATE_PROTECT_SNAP) {
}
template <typename I>
void SnapshotProtectRequest<I>::send_op() {
send_protect_snap();
}
template <typename I>
bool SnapshotProtectRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
if (r < 0) {
if (r == -EBUSY) {
ldout(cct, 1) << "snapshot is already protected" << dendl;
} else {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
}
return true;
}
template <typename I>
void SnapshotProtectRequest<I>::send_protect_snap() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
int r = verify_and_send_protect_snap();
if (r < 0) {
this->async_complete(r);
return;
}
}
template <typename I>
int SnapshotProtectRequest<I>::verify_and_send_protect_snap() {
I &image_ctx = this->m_image_ctx;
std::shared_lock image_locker{image_ctx.image_lock};
CephContext *cct = image_ctx.cct;
if ((image_ctx.features & RBD_FEATURE_LAYERING) == 0) {
lderr(cct) << "image must support layering" << dendl;
return -ENOSYS;
}
uint64_t snap_id = image_ctx.get_snap_id(m_snap_namespace, m_snap_name);
if (snap_id == CEPH_NOSNAP) {
return -ENOENT;
}
bool is_protected;
int r = image_ctx.is_snap_protected(snap_id, &is_protected);
if (r < 0) {
return r;
}
if (is_protected) {
return -EBUSY;
}
librados::ObjectWriteOperation op;
cls_client::set_protection_status(&op, snap_id,
RBD_PROTECTION_STATUS_PROTECTED);
librados::AioCompletion *rados_completion =
this->create_callback_completion();
r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, rados_completion,
&op);
ceph_assert(r == 0);
rados_completion->release();
return 0;
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotProtectRequest<librbd::ImageCtx>;
| 3,244 | 26.268908 | 82 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotProtectRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_PROTECT_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_PROTECT_REQUEST_H
#include "librbd/operation/Request.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotProtectRequest : public Request<ImageCtxT> {
public:
/**
* Snap Protect goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_PROTECT_SNAP
* |
* v
* <finish>
*
* @endverbatim
*
*/
enum State {
STATE_PROTECT_SNAP
};
SnapshotProtectRequest(ImageCtxT &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name);
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapProtectEvent(op_tid, m_snap_namespace, m_snap_name);
}
private:
cls::rbd::SnapshotNamespace m_snap_namespace;
std::string m_snap_name;
State m_state;
void send_protect_snap();
int verify_and_send_protect_snap();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotProtectRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_PROTECT_REQUEST_H
| 1,469 | 20.304348 | 82 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotRemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotRemoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "include/ceph_assert.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "librbd/image/DetachChildRequest.h"
#include "librbd/mirror/snapshot/RemoveImageStateRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotRemoveRequest: " << this << " " \
<< __func__ << ": "
namespace librbd {
namespace operation {
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
SnapshotRemoveRequest<I>::SnapshotRemoveRequest(
I &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name, uint64_t snap_id)
: Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
m_snap_name(snap_name), m_snap_id(snap_id) {
}
template <typename I>
void SnapshotRemoveRequest<I>::send_op() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
{
std::shared_lock image_locker{image_ctx.image_lock};
if (image_ctx.snap_info.find(m_snap_id) == image_ctx.snap_info.end()) {
lderr(cct) << "snapshot doesn't exist" << dendl;
this->async_complete(-ENOENT);
return;
}
}
trash_snap();
}
template <typename I>
bool SnapshotRemoveRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -EBUSY) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void SnapshotRemoveRequest<I>::trash_snap() {
I &image_ctx = this->m_image_ctx;
if (image_ctx.old_format) {
release_snap_id();
return;
} else if (cls::rbd::get_snap_namespace_type(m_snap_namespace) ==
cls::rbd::SNAPSHOT_NAMESPACE_TYPE_TRASH) {
get_snap();
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
librados::ObjectWriteOperation op;
cls_client::snapshot_trash_add(&op, m_snap_id);
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_trash_snap>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_trash_snap(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == -EOPNOTSUPP) {
// trash / clone v2 not supported
detach_child();
return;
} else if (r < 0 && r != -EEXIST) {
lderr(cct) << "failed to move snapshot to trash: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
m_trashed_snapshot = true;
get_snap();
}
template <typename I>
void SnapshotRemoveRequest<I>::get_snap() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
librados::ObjectReadOperation op;
cls_client::snapshot_get_start(&op, m_snap_id);
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_get_snap>(this);
m_out_bl.clear();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, aio_comp, &op,
&m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_get_snap(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == 0) {
cls::rbd::SnapshotInfo snap_info;
auto it = m_out_bl.cbegin();
r = cls_client::snapshot_get_finish(&it, &snap_info);
m_child_attached = (snap_info.child_count > 0);
if (r == 0 && m_child_attached) {
list_children();
return;
}
}
if (r < 0) {
lderr(cct) << "failed to retrieve snapshot: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
detach_child();
}
template <typename I>
void SnapshotRemoveRequest<I>::list_children() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
librados::ObjectReadOperation op;
cls_client::children_list_start(&op, m_snap_id);
m_out_bl.clear();
m_child_images.clear();
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_list_children>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, aio_comp, &op,
&m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_list_children(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == 0) {
auto it = m_out_bl.cbegin();
r = cls_client::children_list_finish(&it, &m_child_images);
}
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to retrieve child: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
detach_stale_child();
}
template <typename I>
void SnapshotRemoveRequest<I>::detach_stale_child() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
for (auto& child_image : m_child_images) {
m_child_attached = true;
IoCtx ioctx;
int r = util::create_ioctx(image_ctx.md_ctx, "child image",
child_image.pool_id,
child_image.pool_namespace, &ioctx);
if (r == -ENOENT) {
librados::ObjectWriteOperation op;
cls_client::child_detach(&op, m_snap_id,
{child_image.pool_id,
child_image.pool_namespace,
child_image.image_id});
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_detach_stale_child>(this);
r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
return;
} else if (r < 0) {
this->async_complete(r);
return;
}
}
detach_child();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_detach_stale_child(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to detach stale child: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
m_child_attached = false;
list_children();
}
template <typename I>
void SnapshotRemoveRequest<I>::detach_child() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
bool detach_child = false;
{
std::shared_lock image_locker{image_ctx.image_lock};
cls::rbd::ParentImageSpec our_pspec;
int r = image_ctx.get_parent_spec(m_snap_id, &our_pspec);
if (r < 0) {
if (r == -ENOENT) {
ldout(cct, 1) << "No such snapshot" << dendl;
} else {
lderr(cct) << "failed to retrieve parent spec" << dendl;
}
this->async_complete(r);
return;
}
if (image_ctx.parent_md.spec != our_pspec &&
(scan_for_parents(our_pspec) == -ENOENT)) {
// no other references to the parent image
detach_child = true;
}
}
if (!detach_child) {
// HEAD image or other snapshots still associated with parent
remove_object_map();
return;
}
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_detach_child>(this);
auto req = image::DetachChildRequest<I>::create(image_ctx, ctx);
req->send();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_detach_child(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to detach child from parent: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
remove_object_map();
}
template <typename I>
void SnapshotRemoveRequest<I>::remove_object_map() {
I &image_ctx = this->m_image_ctx;
if (m_child_attached) {
// if a clone v2 child is attached to this snapshot, we cannot
// proceed. It's only an error if the snap was already in the trash
this->complete(m_trashed_snapshot ? 0 : -EBUSY);
return;
}
CephContext *cct = image_ctx.cct;
{
std::shared_lock owner_lock{image_ctx.owner_lock};
std::unique_lock image_locker{image_ctx.image_lock};
if (image_ctx.object_map != nullptr) {
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_remove_object_map>(this);
image_ctx.object_map->snapshot_remove(m_snap_id, ctx);
return;
}
}
// object map disabled
remove_image_state();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_remove_object_map(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to remove snapshot object map: " << cpp_strerror(r)
<< dendl;
this->complete(r);
return;
}
remove_image_state();
}
template <typename I>
void SnapshotRemoveRequest<I>::remove_image_state() {
I &image_ctx = this->m_image_ctx;
auto type = cls::rbd::get_snap_namespace_type(m_snap_namespace);
if (type != cls::rbd::SNAPSHOT_NAMESPACE_TYPE_MIRROR) {
release_snap_id();
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_remove_image_state>(this);
auto req = mirror::snapshot::RemoveImageStateRequest<I>::create(
&image_ctx, m_snap_id, ctx);
req->send();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_remove_image_state(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to remove image state: " << cpp_strerror(r)
<< dendl;
if (r != -ENOENT) {
this->complete(r);
return;
}
}
release_snap_id();
}
template <typename I>
void SnapshotRemoveRequest<I>::release_snap_id() {
I &image_ctx = this->m_image_ctx;
if (!image_ctx.data_ctx.is_valid()) {
remove_snap();
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_snap_id << dendl;
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_release_snap_id>(this);
image_ctx.data_ctx.aio_selfmanaged_snap_remove(m_snap_id, aio_comp);
aio_comp->release();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_release_snap_id(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(cct) << "failed to release snap id: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
remove_snap();
}
template <typename I>
void SnapshotRemoveRequest<I>::remove_snap() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
librados::ObjectWriteOperation op;
if (image_ctx.old_format) {
cls_client::old_snapshot_remove(&op, m_snap_name);
} else {
cls_client::snapshot_remove(&op, m_snap_id);
}
auto aio_comp = create_rados_callback<
SnapshotRemoveRequest<I>,
&SnapshotRemoveRequest<I>::handle_remove_snap>(this);
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void SnapshotRemoveRequest<I>::handle_remove_snap(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to remove snapshot: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
remove_snap_context();
this->complete(0);
}
template <typename I>
void SnapshotRemoveRequest<I>::remove_snap_context() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
std::unique_lock image_locker{image_ctx.image_lock};
image_ctx.rm_snap(m_snap_namespace, m_snap_name, m_snap_id);
}
template <typename I>
int SnapshotRemoveRequest<I>::scan_for_parents(
cls::rbd::ParentImageSpec &pspec) {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
if (pspec.pool_id != -1) {
std::map<uint64_t, SnapInfo>::iterator it;
for (it = image_ctx.snap_info.begin();
it != image_ctx.snap_info.end(); ++it) {
// skip our snap id (if checking base image, CEPH_NOSNAP won't match)
if (it->first == m_snap_id) {
continue;
}
if (it->second.parent.spec == pspec) {
break;
}
}
if (it == image_ctx.snap_info.end()) {
return -ENOENT;
}
}
return 0;
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotRemoveRequest<librbd::ImageCtx>;
| 13,768 | 26.211462 | 80 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotRemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_REMOVE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_REMOVE_REQUEST_H
#include "librbd/operation/Request.h"
#include "include/buffer.h"
#include "librbd/Types.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotRemoveRequest : public Request<ImageCtxT> {
public:
/**
* @verbatim
*
* <start>
* |
* v
* TRASH_SNAP
* |
* v (skip if unsupported)
* GET_SNAP
* |
* v (skip if unnecessary)
* LIST_CHILDREN <-------------\
* | |
* v (skip if unnecessary) | (repeat as needed)
* DETACH_STALE_CHILD ---------/
* |
* v (skip if unnecessary)
* DETACH_CHILD
* |
* v (skip if disabled/in-use)
* REMOVE_OBJECT_MAP
* |
* v (skip if not mirror snapshot)
* REMOVE_IMAGE_STATE
* |
* v (skip if in-use)
* RELEASE_SNAP_ID
* |
* v (skip if in-use)
* REMOVE_SNAP
* |
* v
* <finish>
*
* @endverbatim
*/
static SnapshotRemoveRequest *create(
ImageCtxT &image_ctx, const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name, uint64_t snap_id, Context *on_finish) {
return new SnapshotRemoveRequest(image_ctx, on_finish, snap_namespace,
snap_name, snap_id);
}
SnapshotRemoveRequest(ImageCtxT &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name,
uint64_t snap_id);
protected:
void send_op() override;
bool should_complete(int r) override;
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapRemoveEvent(op_tid, m_snap_namespace, m_snap_name);
}
private:
cls::rbd::SnapshotNamespace m_snap_namespace;
cls::rbd::ChildImageSpecs m_child_images;
std::string m_snap_name;
uint64_t m_snap_id;
bool m_trashed_snapshot = false;
bool m_child_attached = false;
ceph::bufferlist m_out_bl;
void trash_snap();
void handle_trash_snap(int r);
void get_snap();
void handle_get_snap(int r);
void list_children();
void handle_list_children(int r);
void detach_stale_child();
void handle_detach_stale_child(int r);
void detach_child();
void handle_detach_child(int r);
void remove_object_map();
void handle_remove_object_map(int r);
void remove_image_state();
void handle_remove_image_state(int r);
void release_snap_id();
void handle_release_snap_id(int r);
void remove_snap();
void handle_remove_snap(int r);
void remove_snap_context();
int scan_for_parents(cls::rbd::ParentImageSpec &pspec);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotRemoveRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_REMOVE_REQUEST_H
| 3,047 | 22.627907 | 81 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotRenameRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotRenameRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotRenameRequest: "
namespace librbd {
namespace operation {
namespace {
template <typename I>
std::ostream& operator<<(std::ostream& os,
const typename SnapshotRenameRequest<I>::State& state) {
switch(state) {
case SnapshotRenameRequest<I>::STATE_RENAME_SNAP:
os << "RENAME_SNAP";
break;
}
return os;
}
} // anonymous namespace
template <typename I>
SnapshotRenameRequest<I>::SnapshotRenameRequest(I &image_ctx,
Context *on_finish,
uint64_t snap_id,
const std::string &snap_name)
: Request<I>(image_ctx, on_finish), m_snap_id(snap_id),
m_snap_name(snap_name), m_state(STATE_RENAME_SNAP) {
}
template <typename I>
journal::Event SnapshotRenameRequest<I>::create_event(uint64_t op_tid) const {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.image_lock));
std::string src_snap_name;
auto snap_info_it = image_ctx.snap_info.find(m_snap_id);
if (snap_info_it != image_ctx.snap_info.end()) {
src_snap_name = snap_info_it->second.name;
}
return journal::SnapRenameEvent(op_tid, m_snap_id, src_snap_name,
m_snap_name);
}
template <typename I>
void SnapshotRenameRequest<I>::send_op() {
send_rename_snap();
}
template <typename I>
bool SnapshotRenameRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
if (r < 0) {
if (r == -EEXIST) {
ldout(cct, 1) << "snapshot already exists" << dendl;
} else {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
}
return true;
}
template <typename I>
void SnapshotRenameRequest<I>::send_rename_snap() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
std::shared_lock image_locker{image_ctx.image_lock};
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
librados::ObjectWriteOperation op;
if (image_ctx.old_format) {
cls_client::old_snapshot_rename(&op, m_snap_id, m_snap_name);
} else {
cls_client::snapshot_rename(&op, m_snap_id, m_snap_name);
}
librados::AioCompletion *rados_completion = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid,
rados_completion, &op);
ceph_assert(r == 0);
rados_completion->release();
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotRenameRequest<librbd::ImageCtx>;
| 2,978 | 27.92233 | 81 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotRenameRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_RENAME_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_RENAME_REQUEST_H
#include "librbd/operation/Request.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotRenameRequest : public Request<ImageCtxT> {
public:
/**
* Snap Rename goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_RENAME_SNAP
* |
* v
* <finish>
*
* @endverbatim
*
*/
enum State {
STATE_RENAME_SNAP
};
SnapshotRenameRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t snap_id, const std::string &snap_name);
journal::Event create_event(uint64_t op_tid) const override;
protected:
void send_op() override;
bool should_complete(int r) override;
private:
uint64_t m_snap_id;
std::string m_snap_name;
State m_state;
void send_rename_snap();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotRenameRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_RENAME_REQUEST_H
| 1,288 | 19.140625 | 81 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotRollbackRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotRollbackRequest.h"
#include "include/rados/librados.hpp"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/operation/ResizeRequest.h"
#include "osdc/Striper.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotRollbackRequest: "
namespace librbd {
namespace operation {
using util::create_context_callback;
using util::create_rados_callback;
namespace {
template <typename I>
class C_RollbackObject : public C_AsyncObjectThrottle<I> {
public:
C_RollbackObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
uint64_t snap_id, uint64_t object_num,
uint64_t head_num_objects,
decltype(I::object_map) snap_object_map)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_snap_id(snap_id),
m_object_num(object_num), m_head_num_objects(head_num_objects),
m_snap_object_map(snap_object_map) {
}
int send() override {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 20) << "C_RollbackObject: " << __func__ << ": object_num="
<< m_object_num << dendl;
{
std::shared_lock 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) &&
!m_snap_object_map->object_may_exist(m_object_num)) {
return 1;
}
}
std::string oid = image_ctx.get_object_name(m_object_num);
librados::ObjectWriteOperation op;
op.selfmanaged_snap_rollback(m_snap_id);
librados::AioCompletion *rados_completion =
util::create_rados_callback(this);
image_ctx.data_ctx.aio_operate(oid, rados_completion, &op);
rados_completion->release();
return 0;
}
private:
uint64_t m_snap_id;
uint64_t m_object_num;
uint64_t m_head_num_objects;
decltype(I::object_map) m_snap_object_map;
};
} // anonymous namespace
template <typename I>
SnapshotRollbackRequest<I>::SnapshotRollbackRequest(I &image_ctx,
Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name,
uint64_t snap_id,
uint64_t snap_size,
ProgressContext &prog_ctx)
: Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
m_snap_name(snap_name), m_snap_id(snap_id),
m_snap_size(snap_size), m_prog_ctx(prog_ctx),
m_object_map(nullptr), m_snap_object_map(nullptr) {
}
template <typename I>
SnapshotRollbackRequest<I>::~SnapshotRollbackRequest() {
I &image_ctx = this->m_image_ctx;
if (m_blocking_writes) {
image_ctx.io_image_dispatcher->unblock_writes();
}
if (m_object_map) {
m_object_map->put();
m_object_map = nullptr;
}
if (m_snap_object_map) {
m_snap_object_map->put();
m_snap_object_map = nullptr;
}
}
template <typename I>
void SnapshotRollbackRequest<I>::send_op() {
send_block_writes();
}
template <typename I>
void SnapshotRollbackRequest<I>::send_block_writes() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_blocking_writes = true;
image_ctx.io_image_dispatcher->block_writes(create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_block_writes>(this));
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_block_writes(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to block writes: " << cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_resize_image();
return nullptr;
}
template <typename I>
void SnapshotRollbackRequest<I>::send_resize_image() {
I &image_ctx = this->m_image_ctx;
uint64_t current_size;
{
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock image_locker{image_ctx.image_lock};
current_size = image_ctx.get_image_size(CEPH_NOSNAP);
}
m_head_num_objects = Striper::get_num_objects(image_ctx.layout, current_size);
if (current_size == m_snap_size) {
send_get_snap_object_map();
return;
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_resize_image>(this);
ResizeRequest<I> *req = ResizeRequest<I>::create(image_ctx, ctx, m_snap_size,
true, m_no_op_prog_ctx, 0, true);
req->send();
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_resize_image(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to resize image for rollback: "
<< cpp_strerror(*result) << dendl;
return this->create_context_finisher(*result);
}
send_get_snap_object_map();
return nullptr;
}
template <typename I>
void SnapshotRollbackRequest<I>::send_get_snap_object_map() {
I &image_ctx = this->m_image_ctx;
uint64_t flags = 0;
bool object_map_enabled;
CephContext *cct = image_ctx.cct;
{
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock 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) {
object_map_enabled = false;
}
}
if (object_map_enabled &&
(flags & RBD_FLAG_OBJECT_MAP_INVALID) != 0) {
lderr(cct) << "warning: object-map is invalid for snapshot" << dendl;
object_map_enabled = false;
}
if (!object_map_enabled) {
send_rollback_object_map();
return;
}
ldout(cct, 5) << this << " " << __func__ << dendl;
m_snap_object_map = image_ctx.create_object_map(m_snap_id);
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_get_snap_object_map>(this);
m_snap_object_map->open(ctx);
return;
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_get_snap_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << this << " " << __func__ << ": failed to open object map: "
<< cpp_strerror(*result) << dendl;
m_snap_object_map->put();
m_snap_object_map = nullptr;
}
send_rollback_object_map();
return nullptr;
}
template <typename I>
void SnapshotRollbackRequest<I>::send_rollback_object_map() {
I &image_ctx = this->m_image_ctx;
{
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock image_locker{image_ctx.image_lock};
if (image_ctx.object_map != nullptr) {
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_rollback_object_map>(this);
image_ctx.object_map->rollback(m_snap_id, ctx);
return;
}
}
send_rollback_objects();
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_rollback_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << this << " " << __func__ << ": failed to roll back object "
<< "map: " << cpp_strerror(*result) << dendl;
ceph_assert(m_object_map == nullptr);
apply();
return this->create_context_finisher(*result);
}
send_rollback_objects();
return nullptr;
}
template <typename I>
void SnapshotRollbackRequest<I>::send_rollback_objects() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
std::shared_lock owner_locker{image_ctx.owner_lock};
uint64_t num_objects;
{
std::shared_lock image_locker{image_ctx.image_lock};
num_objects = Striper::get_num_objects(image_ctx.layout,
image_ctx.get_current_size());
}
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_rollback_objects>(this);
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_RollbackObject<I> >(),
boost::lambda::_1, &image_ctx, m_snap_id, boost::lambda::_2,
m_head_num_objects, m_snap_object_map));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, num_objects);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_rollback_objects(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == -ERESTART) {
ldout(cct, 5) << "snapshot rollback operation interrupted" << dendl;
return this->create_context_finisher(*result);
} else if (*result < 0) {
lderr(cct) << "failed to rollback objects: " << cpp_strerror(*result)
<< dendl;
return this->create_context_finisher(*result);
}
return send_refresh_object_map();
}
template <typename I>
Context *SnapshotRollbackRequest<I>::send_refresh_object_map() {
I &image_ctx = this->m_image_ctx;
bool object_map_enabled;
{
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock image_locker{image_ctx.image_lock};
object_map_enabled = (image_ctx.object_map != nullptr);
}
if (!object_map_enabled) {
return send_invalidate_cache();
}
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_object_map = image_ctx.create_object_map(CEPH_NOSNAP);
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_refresh_object_map>(this);
m_object_map->open(ctx);
return nullptr;
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_refresh_object_map(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << this << " " << __func__ << ": failed to open object map: "
<< cpp_strerror(*result) << dendl;
m_object_map->put();
m_object_map = nullptr;
apply();
return this->create_context_finisher(*result);
}
return send_invalidate_cache();
}
template <typename I>
Context *SnapshotRollbackRequest<I>::send_invalidate_cache() {
I &image_ctx = this->m_image_ctx;
apply();
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
if(m_object_map != nullptr) {
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_invalidate_cache>(this, m_object_map);
image_ctx.io_image_dispatcher->invalidate_cache(ctx);
}
else {
Context *ctx = create_context_callback<
SnapshotRollbackRequest<I>,
&SnapshotRollbackRequest<I>::handle_invalidate_cache>(this);
image_ctx.io_image_dispatcher->invalidate_cache(ctx);
}
return nullptr;
}
template <typename I>
Context *SnapshotRollbackRequest<I>::handle_invalidate_cache(int *result) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result < 0) {
lderr(cct) << "failed to invalidate cache: " << cpp_strerror(*result)
<< dendl;
}
return this->create_context_finisher(*result);
}
template <typename I>
void SnapshotRollbackRequest<I>::apply() {
I &image_ctx = this->m_image_ctx;
std::shared_lock owner_locker{image_ctx.owner_lock};
std::unique_lock image_locker{image_ctx.image_lock};
if (image_ctx.object_map != nullptr) {
std::swap(m_object_map, image_ctx.object_map);
}
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotRollbackRequest<librbd::ImageCtx>;
| 13,321 | 30.345882 | 84 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotRollbackRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_ROLLBACK_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_ROLLBACK_REQUEST_H
#include "librbd/operation/Request.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/journal/Types.h"
#include <string>
class Context;
namespace librbd {
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotRollbackRequest : public Request<ImageCtxT> {
public:
/**
* Snap Rollback goes through the following state machine:
*
* @verbatim
*
* <start> ---------\
* |
* v
* STATE_BLOCK_WRITES
* |
* v
* STATE_RESIZE_IMAGE (skip if resize not
* | required)
* v
* STATE_GET_SNAP_OBJECT_MAP (skip if object)
* | map disabled)
* v
* STATE_ROLLBACK_OBJECT_MAP (skip if object
* | map disabled)
* v
* STATE_ROLLBACK_OBJECTS
* |
* v
* STATE_REFRESH_OBJECT_MAP (skip if object
* | map disabled)
* v
* STATE_INVALIDATE_CACHE (skip if cache
* | disabled)
* v
* <finish>
*
* @endverbatim
*
* The _RESIZE_IMAGE state is skipped if the image doesn't need to be resized.
* The _ROLLBACK_OBJECT_MAP state is skipped if the object map isn't enabled.
* The _INVALIDATE_CACHE state is skipped if the cache isn't enabled.
*/
SnapshotRollbackRequest(ImageCtxT &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name,
uint64_t snap_id,
uint64_t snap_size, ProgressContext &prog_ctx);
~SnapshotRollbackRequest() override;
protected:
void send_op() override;
bool should_complete(int r) override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapRollbackEvent(op_tid, m_snap_namespace, m_snap_name);
}
private:
cls::rbd::SnapshotNamespace m_snap_namespace;
std::string m_snap_name;
uint64_t m_snap_id;
uint64_t m_snap_size;
uint64_t m_head_num_objects;
ProgressContext &m_prog_ctx;
NoOpProgressContext m_no_op_prog_ctx;
bool m_blocking_writes = false;
decltype(ImageCtxT::object_map) m_object_map;
decltype(ImageCtxT::object_map) m_snap_object_map;
void send_block_writes();
Context *handle_block_writes(int *result);
void send_resize_image();
Context *handle_resize_image(int *result);
void send_get_snap_object_map();
Context *handle_get_snap_object_map(int *result);
void send_rollback_object_map();
Context *handle_rollback_object_map(int *result);
void send_rollback_objects();
Context *handle_rollback_objects(int *result);
Context *send_refresh_object_map();
Context *handle_refresh_object_map(int *result);
Context *send_invalidate_cache();
Context *handle_invalidate_cache(int *result);
void apply();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotRollbackRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_ROLLBACK_REQUEST_H
| 3,587 | 28.170732 | 83 |
h
|
null |
ceph-main/src/librbd/operation/SnapshotUnprotectRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SnapshotUnprotectRequest.h"
#include "include/rados/librados.hpp"
#include "include/stringify.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/Types.h"
#include "librbd/Utils.h"
#include <list>
#include <set>
#include <vector>
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::SnapshotUnprotectRequest: "
namespace librbd {
namespace operation {
namespace {
typedef std::pair<int64_t, std::string> Pool;
typedef std::vector<Pool> Pools;
template <typename I>
std::ostream& operator<<(std::ostream& os,
const typename SnapshotUnprotectRequest<I>::State& state) {
switch(state) {
case SnapshotUnprotectRequest<I>::STATE_UNPROTECT_SNAP_START:
os << "UNPROTECT_SNAP_START";
break;
case SnapshotUnprotectRequest<I>::STATE_SCAN_POOL_CHILDREN:
os << "SCAN_POOL_CHILDREN";
break;
case SnapshotUnprotectRequest<I>::STATE_UNPROTECT_SNAP_FINISH:
os << "UNPROTECT_SNAP_FINISH";
break;
case SnapshotUnprotectRequest<I>::STATE_UNPROTECT_SNAP_ROLLBACK:
os << "UNPROTECT_SNAP_ROLLBACK";
break;
default:
os << "UNKNOWN (" << static_cast<uint32_t>(state) << ")";
break;
}
return os;
}
template <typename I>
class C_ScanPoolChildren : public C_AsyncObjectThrottle<I> {
public:
C_ScanPoolChildren(AsyncObjectThrottle<I> &throttle, I *image_ctx,
const cls::rbd::ParentImageSpec &pspec, const Pools &pools,
size_t pool_idx)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_pspec(pspec),
m_pool(pools[pool_idx]) {
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " scanning pool '" << m_pool.second << "'"
<< dendl;
librados::Rados rados(image_ctx.md_ctx);
int64_t base_tier;
int r = rados.pool_get_base_tier(m_pool.first, &base_tier);
if (r == -ENOENT) {
ldout(cct, 1) << "pool '" << m_pool.second << "' no longer exists"
<< dendl;
return 1;
} else if (r < 0) {
lderr(cct) << "error retrieving base tier for pool '"
<< m_pool.second << "'" << dendl;
return r;
}
if (m_pool.first != base_tier) {
// pool is a cache; skip it
return 1;
}
r = util::create_ioctx(image_ctx.md_ctx, "child image", m_pool.first, {},
&m_pool_ioctx);
if (r == -ENOENT) {
return 1;
} else if (r < 0) {
return r;
}
librados::ObjectReadOperation op;
cls_client::get_children_start(&op, m_pspec);
librados::AioCompletion *rados_completion =
util::create_rados_callback(this);
r = m_pool_ioctx.aio_operate(RBD_CHILDREN, rados_completion, &op,
&m_children_bl);
ceph_assert(r == 0);
rados_completion->release();
return 0;
}
protected:
void finish(int r) override {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (r == 0) {
auto it = m_children_bl.cbegin();
r= cls_client::get_children_finish(&it, &m_children);
}
ldout(cct, 10) << this << " retrieved children: r=" << r << dendl;
if (r == -ENOENT) {
// no children -- proceed with unprotect
r = 0;
} else if (r < 0) {
lderr(cct) << "cannot get children for pool '" << m_pool.second << "'"
<< dendl;
} else {
lderr(cct) << "cannot unprotect: at least " << m_children.size() << " "
<< "child(ren) [" << joinify(m_children.begin(),
m_children.end(),
std::string(",")) << "] "
<< "in pool '" << m_pool.second << "'" << dendl;
r = -EBUSY;
}
C_AsyncObjectThrottle<I>::finish(r);
}
private:
cls::rbd::ParentImageSpec m_pspec;
Pool m_pool;
IoCtx m_pool_ioctx;
std::set<std::string> m_children;
bufferlist m_children_bl;
};
} // anonymous namespace
template <typename I>
SnapshotUnprotectRequest<I>::SnapshotUnprotectRequest(I &image_ctx,
Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name)
: Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
m_snap_name(snap_name), m_state(STATE_UNPROTECT_SNAP_START),
m_ret_val(0), m_snap_id(CEPH_NOSNAP) {
}
template <typename I>
void SnapshotUnprotectRequest<I>::send_op() {
send_unprotect_snap_start();
}
template <typename I>
bool SnapshotUnprotectRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": state=" << m_state << ", "
<< "r=" << r << dendl;
if (r < 0) {
if (r == -EINVAL) {
ldout(cct, 1) << "snapshot is already unprotected" << dendl;
} else {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
if (m_ret_val == 0) {
m_ret_val = r;
}
}
// use a different state machine once an error is encountered
if (m_ret_val < 0) {
return should_complete_error();
}
std::shared_lock owner_lock{image_ctx.owner_lock};
bool finished = false;
switch (m_state) {
case STATE_UNPROTECT_SNAP_START:
send_scan_pool_children();
break;
case STATE_SCAN_POOL_CHILDREN:
send_unprotect_snap_finish();
break;
case STATE_UNPROTECT_SNAP_FINISH:
finished = true;
break;
default:
ceph_abort();
break;
}
return finished;
}
template <typename I>
bool SnapshotUnprotectRequest<I>::should_complete_error() {
I &image_ctx = this->m_image_ctx;
std::shared_lock owner_locker{image_ctx.owner_lock};
CephContext *cct = image_ctx.cct;
lderr(cct) << this << " " << __func__ << ": "
<< "ret_val=" << m_ret_val << dendl;
bool finished = true;
if (m_state == STATE_SCAN_POOL_CHILDREN ||
m_state == STATE_UNPROTECT_SNAP_FINISH) {
send_unprotect_snap_rollback();
finished = false;
}
return finished;
}
template <typename I>
void SnapshotUnprotectRequest<I>::send_unprotect_snap_start() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
int r = verify_and_send_unprotect_snap_start();
if (r < 0) {
this->async_complete(r);
return;
}
}
template <typename I>
void SnapshotUnprotectRequest<I>::send_scan_pool_children() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_SCAN_POOL_CHILDREN;
// search all pools for children depending on this snapshot
// TODO add async version of wait_for_latest_osdmap
librados::Rados rados(image_ctx.md_ctx);
rados.wait_for_latest_osdmap();
// protect against pools being renamed/deleted
std::list<Pool> pool_list;
rados.pool_list2(pool_list);
cls::rbd::ParentImageSpec pspec(image_ctx.md_ctx.get_id(),
image_ctx.md_ctx.get_namespace(),
image_ctx.id, m_snap_id);
Pools pools(pool_list.begin(), pool_list.end());
Context *ctx = this->create_callback_context();
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_ScanPoolChildren<I> >(),
boost::lambda::_1, &image_ctx, pspec, pools, boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
nullptr, image_ctx, context_factory, ctx, NULL, 0, pools.size());
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
void SnapshotUnprotectRequest<I>::send_unprotect_snap_finish() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_UNPROTECT_SNAP_FINISH;
librados::ObjectWriteOperation op;
cls_client::set_protection_status(&op, m_snap_id,
RBD_PROTECTION_STATUS_UNPROTECTED);
librados::AioCompletion *comp = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
void SnapshotUnprotectRequest<I>::send_unprotect_snap_rollback() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
m_state = STATE_UNPROTECT_SNAP_ROLLBACK;
librados::ObjectWriteOperation op;
cls_client::set_protection_status(&op, m_snap_id,
RBD_PROTECTION_STATUS_PROTECTED);
librados::AioCompletion *comp = this->create_callback_completion();
int r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
template <typename I>
int SnapshotUnprotectRequest<I>::verify_and_send_unprotect_snap_start() {
I &image_ctx = this->m_image_ctx;
std::shared_lock image_locker{image_ctx.image_lock};
CephContext *cct = image_ctx.cct;
if ((image_ctx.features & RBD_FEATURE_LAYERING) == 0) {
lderr(cct) << "image must support layering" << dendl;
return -ENOSYS;
}
m_snap_id = image_ctx.get_snap_id(m_snap_namespace, m_snap_name);
if (m_snap_id == CEPH_NOSNAP) {
return -ENOENT;
}
bool is_unprotected;
int r = image_ctx.is_snap_unprotected(m_snap_id, &is_unprotected);
if (r < 0) {
return r;
}
if (is_unprotected) {
lderr(cct) << "snapshot is already unprotected" << dendl;
return -EINVAL;
}
librados::ObjectWriteOperation op;
cls_client::set_protection_status(&op, m_snap_id,
RBD_PROTECTION_STATUS_UNPROTECTING);
librados::AioCompletion *comp = this->create_callback_completion();
r = image_ctx.md_ctx.aio_operate(image_ctx.header_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
// TODO legacy code threw a notification post UNPROTECTING update -- required?
return 0;
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SnapshotUnprotectRequest<librbd::ImageCtx>;
| 10,926 | 29.867232 | 104 |
cc
|
null |
ceph-main/src/librbd/operation/SnapshotUnprotectRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SNAPSHOT_UNPROTECT_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SNAPSHOT_UNPROTECT_REQUEST_H
#include "librbd/operation/Request.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SnapshotUnprotectRequest : public Request<ImageCtxT> {
public:
/**
* Snap Unprotect goes through the following state machine:
*
* @verbatim
*
* <start>
* |
* v
* STATE_UNPROTECT_SNAP_START
* |
* v
* STATE_SCAN_POOL_CHILDREN * * * * > STATE_UNPROTECT_SNAP_ROLLBACK
* | |
* v |
* STATE_UNPROTECT_SNAP_FINISH |
* | |
* v |
* <finish> <----------------------------/
*
* @endverbatim
*
* If the unprotect operation needs to abort, the error path is followed
* to rollback the unprotect in-progress status on the image.
*/
enum State {
STATE_UNPROTECT_SNAP_START,
STATE_SCAN_POOL_CHILDREN,
STATE_UNPROTECT_SNAP_FINISH,
STATE_UNPROTECT_SNAP_ROLLBACK
};
SnapshotUnprotectRequest(ImageCtxT &image_ctx, Context *on_finish,
const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name);
protected:
void send_op() override;
bool should_complete(int r) override;
int filter_return_code(int r) const override {
if (m_ret_val < 0) {
return m_ret_val;
}
return 0;
}
journal::Event create_event(uint64_t op_tid) const override {
return journal::SnapUnprotectEvent(op_tid, m_snap_namespace, m_snap_name);
}
private:
cls::rbd::SnapshotNamespace m_snap_namespace;
std::string m_snap_name;
State m_state;
int m_ret_val;
uint64_t m_snap_id;
bool should_complete_error();
void send_unprotect_snap_start();
void send_scan_pool_children();
void send_unprotect_snap_finish();
void send_unprotect_snap_rollback();
int verify_and_send_unprotect_snap_start();
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SnapshotUnprotectRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SNAPSHOT_UNPROTECT_REQUEST_H
| 2,390 | 24.168421 | 84 |
h
|
null |
ceph-main/src/librbd/operation/SparsifyRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/SparsifyRequest.h"
#include "cls/rbd/cls_rbd_client.h"
#include "common/dout.h"
#include "common/errno.h"
#include "include/err.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/Types.h"
#include "librbd/io/ObjectRequest.h"
#include "librbd/io/Utils.h"
#include "osdc/Striper.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#define dout_subsys ceph_subsys_rbd
namespace librbd {
namespace operation {
namespace {
bool may_be_trimmed(const std::map<uint64_t,uint64_t> &extent_map,
const bufferlist &bl, size_t sparse_size,
uint64_t *new_end_ptr) {
if (extent_map.empty()) {
*new_end_ptr = 0;
return true;
}
uint64_t end = extent_map.rbegin()->first + extent_map.rbegin()->second;
uint64_t new_end = end;
uint64_t bl_off = bl.length();
for (auto it = extent_map.rbegin(); it != extent_map.rend(); it++) {
auto off = it->first;
auto len = it->second;
new_end = p2roundup<uint64_t>(off + len, sparse_size);
uint64_t extent_left = len;
uint64_t sub_len = len % sparse_size;
if (sub_len == 0) {
sub_len = sparse_size;
}
while (extent_left > 0) {
ceph_assert(bl_off >= sub_len);
bl_off -= sub_len;
bufferlist sub_bl;
sub_bl.substr_of(bl, bl_off, sub_len);
if (!sub_bl.is_zero()) {
break;
}
new_end -= sparse_size;
extent_left -= sub_len;
sub_len = sparse_size;
}
if (extent_left > 0) {
break;
}
}
if (new_end < end) {
*new_end_ptr = new_end;
return true;
}
return false;
}
} // anonymous namespace
using util::create_context_callback;
using util::create_rados_callback;
#undef dout_prefix
#define dout_prefix *_dout << "librbd::operation::SparsifyObject: " << this \
<< " " << m_oid << " " << __func__ << ": "
template <typename I>
class C_SparsifyObject : public C_AsyncObjectThrottle<I> {
public:
/**
* @verbatim
*
* <start>
* |
* v (not supported)
* SPARSIFY * * * * * * * * * * * * > READ < * * * * * * * * * * (concurrent
* | | * update is
* | (object map disabled) | (can trim) * detected)
* |------------------------\ V *
* | | PRE UPDATE OBJECT MAP *
* | (object map enabled) | | (if needed) *
* v | V *
* PRE UPDATE OBJECT MAP | TRIM * * * * * * * * * * *
* | | |
* v | V
* CHECK EXISTS | POST UPDATE OBJECT MAP
* | | | (if needed)
* v | |
* POST UPDATE OBJECT MAP | |
* | | |
* v | |
* <finish> <------------------/<-------/
*
* @endverbatim
*
*/
C_SparsifyObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
uint64_t object_no, size_t sparse_size)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_cct(image_ctx->cct),
m_object_no(object_no), m_sparse_size(sparse_size),
m_oid(image_ctx->get_object_name(object_no)) {
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ldout(m_cct, 20) << dendl;
if (!image_ctx.data_ctx.is_valid()) {
lderr(m_cct) << "missing data pool" << dendl;
return -ENODEV;
}
if (image_ctx.exclusive_lock != nullptr &&
!image_ctx.exclusive_lock->is_lock_owner()) {
ldout(m_cct, 1) << "lost exclusive lock during sparsify" << dendl;
return -ERESTART;
}
{
std::shared_lock 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
return 1;
}
uint64_t raw_overlap = 0;
uint64_t object_overlap = 0;
int r = image_ctx.get_parent_overlap(CEPH_NOSNAP, &raw_overlap);
ceph_assert(r == 0);
if (raw_overlap > 0) {
auto [parent_extents, area] = io::util::object_to_area_extents(
&image_ctx, m_object_no, {{0, image_ctx.layout.object_size}});
object_overlap = image_ctx.prune_parent_extents(parent_extents, area,
raw_overlap, false);
}
m_remove_empty = object_overlap == 0;
}
send_sparsify();
return 0;
}
void send_sparsify() {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << dendl;
librados::ObjectWriteOperation op;
cls_client::sparsify(&op, m_sparse_size, m_remove_empty);
auto comp = create_rados_callback<
C_SparsifyObject, &C_SparsifyObject::handle_sparsify>(this);
int r = image_ctx.data_ctx.aio_operate(m_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
void handle_sparsify(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (r == -EOPNOTSUPP) {
m_trying_trim = true;
send_read();
return;
}
if (r == -ENOENT) {
finish_op(0);
return;
}
if (r < 0) {
lderr(m_cct) << "failed to sparsify: " << cpp_strerror(r) << dendl;
finish_op(r);
return;
}
send_pre_update_object_map();
}
void send_pre_update_object_map() {
I &image_ctx = this->m_image_ctx;
if (m_trying_trim) {
if (!m_remove_empty || m_new_end != 0 ||
!image_ctx.test_features(RBD_FEATURE_OBJECT_MAP)) {
send_trim();
return;
}
} else if (!m_remove_empty ||
!image_ctx.test_features(RBD_FEATURE_OBJECT_MAP)) {
finish_op(0);
return;
}
ldout(m_cct, 20) << dendl;
image_ctx.owner_lock.lock_shared();
image_ctx.image_lock.lock_shared();
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.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
finish_op(-EINVAL);
return;
}
int r;
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.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
finish_op(r);
return;
}
auto ctx = create_context_callback<
C_SparsifyObject<I>,
&C_SparsifyObject<I>::handle_pre_update_object_map>(this);
bool sent = image_ctx.object_map->template aio_update<
Context, &Context::complete>(CEPH_NOSNAP, m_object_no, OBJECT_PENDING,
OBJECT_EXISTS, {}, false, ctx);
// NOTE: state machine might complete before we reach here
image_ctx.image_lock.unlock_shared();
image_ctx.owner_lock.unlock_shared();
if (!sent) {
finish_op(0);
}
}
void handle_pre_update_object_map(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (r < 0) {
lderr(m_cct) << "failed to update object map: " << cpp_strerror(r)
<< dendl;
finish_op(r);
return;
}
if (m_trying_trim) {
send_trim();
} else {
send_check_exists();
}
}
void send_check_exists() {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << dendl;
librados::ObjectReadOperation op;
op.stat(NULL, NULL, NULL);
m_bl.clear();
auto comp = create_rados_callback<
C_SparsifyObject, &C_SparsifyObject::handle_check_exists>(this);
int r = image_ctx.data_ctx.aio_operate(m_oid, comp, &op, &m_bl);
ceph_assert(r == 0);
comp->release();
}
void handle_check_exists(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(m_cct) << "stat failed: " << cpp_strerror(r) << dendl;
finish_op(r);
return;
}
send_post_update_object_map(r == 0);
}
void send_post_update_object_map(bool exists) {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << dendl;
auto ctx = create_context_callback<
C_SparsifyObject<I>,
&C_SparsifyObject<I>::handle_post_update_object_map>(this);
bool sent;
{
std::shared_lock owner_locker{image_ctx.owner_lock};
std::shared_lock image_locker{image_ctx.image_lock};
assert(image_ctx.exclusive_lock->is_lock_owner());
assert(image_ctx.object_map != nullptr);
sent = image_ctx.object_map->template aio_update<
Context, &Context::complete>(CEPH_NOSNAP, m_object_no,
exists ? OBJECT_EXISTS : OBJECT_NONEXISTENT,
OBJECT_PENDING, {}, false, ctx);
}
if (!sent) {
ctx->complete(0);
}
}
void handle_post_update_object_map(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (r < 0) {
lderr(m_cct) << "failed to update object map: " << cpp_strerror(r)
<< dendl;
finish_op(r);
return;
}
finish_op(0);
}
void send_read() {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << dendl;
librados::ObjectReadOperation op;
m_bl.clear();
op.sparse_read(0, image_ctx.layout.object_size, &m_extent_map, &m_bl,
nullptr);
auto comp = create_rados_callback<
C_SparsifyObject, &C_SparsifyObject::handle_read>(this);
int r = image_ctx.data_ctx.aio_operate(m_oid, comp, &op, &m_bl);
ceph_assert(r == 0);
comp->release();
}
void handle_read(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (r < 0) {
if (r == -ENOENT) {
r = 0;
} else {
lderr(m_cct) << "failed to read object: " << cpp_strerror(r) << dendl;
}
finish_op(r);
return;
}
if (!may_be_trimmed(m_extent_map, m_bl, m_sparse_size, &m_new_end)) {
finish_op(0);
return;
}
send_pre_update_object_map();
}
void send_trim() {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << dendl;
ceph_assert(m_new_end < image_ctx.layout.object_size);
librados::ObjectWriteOperation op;
m_bl.clear();
m_bl.append_zero(image_ctx.layout.object_size - m_new_end);
op.cmpext(m_new_end, m_bl, nullptr);
if (m_new_end == 0 && m_remove_empty) {
op.remove();
} else {
op.truncate(m_new_end);
}
auto comp = create_rados_callback<
C_SparsifyObject, &C_SparsifyObject::handle_trim>(this);
int r = image_ctx.data_ctx.aio_operate(m_oid, comp, &op);
ceph_assert(r == 0);
comp->release();
}
void handle_trim(int r) {
I &image_ctx = this->m_image_ctx;
ldout(m_cct, 20) << "r=" << r << dendl;
if (r <= -MAX_ERRNO) {
m_finish_op_ctx->complete(0);
m_finish_op_ctx = nullptr;
send_read();
return;
}
if (r < 0 && r != -ENOENT) {
lderr(m_cct) << "failed to trim: " << cpp_strerror(r) << dendl;
finish_op(r);
return;
}
if (!m_remove_empty || m_new_end != 0 ||
!image_ctx.test_features(RBD_FEATURE_OBJECT_MAP)) {
finish_op(0);
return;
}
send_post_update_object_map(false);
}
void finish_op(int r) {
ldout(m_cct, 20) << "r=" << r << dendl;
if (m_finish_op_ctx != nullptr) {
m_finish_op_ctx->complete(0);
}
this->complete(r);
}
private:
CephContext *m_cct;
uint64_t m_object_no;
size_t m_sparse_size;
std::string m_oid;
bool m_remove_empty = false;
bool m_trying_trim = false;
bufferlist m_bl;
std::map<uint64_t,uint64_t> m_extent_map;
uint64_t m_new_end = 0;
Context *m_finish_op_ctx = nullptr;
};
#undef dout_prefix
#define dout_prefix *_dout << "librbd::operation::SparsifyRequest: " << this \
<< " " << __func__ << ": "
template <typename I>
bool SparsifyRequest<I>::should_complete(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "encountered error: " << cpp_strerror(r) << dendl;
}
return true;
}
template <typename I>
void SparsifyRequest<I>::send_op() {
sparsify_objects();
}
template <typename I>
void SparsifyRequest<I>::sparsify_objects() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
assert(ceph_mutex_is_locked(image_ctx.owner_lock));
uint64_t objects = 0;
{
std::shared_lock image_locker{image_ctx.image_lock};
objects = image_ctx.get_object_count(CEPH_NOSNAP);
}
auto ctx = create_context_callback<
SparsifyRequest<I>,
&SparsifyRequest<I>::handle_sparsify_objects>(this);
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_SparsifyObject<I> >(),
boost::lambda::_1, &image_ctx, boost::lambda::_2, m_sparse_size));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, 0, objects);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
void SparsifyRequest<I>::handle_sparsify_objects(int r) {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << "r=" << r << dendl;
if (r == -ERESTART) {
ldout(cct, 5) << "sparsify operation interrupted" << dendl;
this->complete(r);
return;
} else if (r < 0) {
lderr(cct) << "sparsify encountered an error: " << cpp_strerror(r) << dendl;
this->complete(r);
return;
}
this->complete(0);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::SparsifyRequest<librbd::ImageCtx>;
| 14,249 | 26.403846 | 82 |
cc
|
null |
ceph-main/src/librbd/operation/SparsifyRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_SPARSIFY_REQUEST_H
#define CEPH_LIBRBD_OPERATION_SPARSIFY_REQUEST_H
#include "librbd/operation/Request.h"
#include "common/snap_types.h"
namespace librbd {
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class SparsifyRequest : public Request<ImageCtxT>
{
public:
SparsifyRequest(ImageCtxT &image_ctx, size_t sparse_size, Context *on_finish,
ProgressContext &prog_ctx)
: Request<ImageCtxT>(image_ctx, on_finish), m_sparse_size(sparse_size),
m_prog_ctx(prog_ctx) {
}
protected:
void send_op() override;
bool should_complete(int r) override;
bool can_affect_io() const override {
return true;
}
journal::Event create_event(uint64_t op_tid) const override {
ceph_abort();
return journal::UnknownEvent();
}
private:
/**
* @verbatim
*
* <start>
* |
* v
* SPARSIFY OBJECTS
* |
* v
* <finish>
*
* @endverbatim
*/
size_t m_sparse_size;
ProgressContext &m_prog_ctx;
void sparsify_objects();
void handle_sparsify_objects(int r);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::SparsifyRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_SPARSIFY_REQUEST_H
| 1,404 | 20.615385 | 79 |
h
|
null |
ceph-main/src/librbd/operation/TrimRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/operation/TrimRequest.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "common/ContextCompletion.h"
#include "common/dout.h"
#include "common/errno.h"
#include "osdc/Striper.h"
#include <boost/lambda/bind.hpp>
#include <boost/lambda/construct.hpp>
#include <boost/scope_exit.hpp>
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::TrimRequest: "
namespace librbd {
namespace operation {
template <typename I>
class C_CopyupObject : public C_AsyncObjectThrottle<I> {
public:
C_CopyupObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
IOContext io_context, uint64_t object_no)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_io_context(io_context),
m_object_no(object_no)
{
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
std::string oid = image_ctx.get_object_name(m_object_no);
ldout(image_ctx.cct, 10) << "removing (with copyup) " << oid << dendl;
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
&image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, m_object_no, 0,
image_ctx.layout.object_size, m_io_context,
io::OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE, 0, {}, this);
object_dispatch_spec->send();
return 0;
}
private:
IOContext m_io_context;
uint64_t m_object_no;
};
template <typename I>
class C_RemoveObject : public C_AsyncObjectThrottle<I> {
public:
C_RemoveObject(AsyncObjectThrottle<I> &throttle, I *image_ctx,
uint64_t object_no)
: C_AsyncObjectThrottle<I>(throttle, *image_ctx), m_object_no(object_no)
{
}
int send() override {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
{
std::shared_lock image_locker{image_ctx.image_lock};
if (image_ctx.object_map != nullptr &&
!image_ctx.object_map->object_may_exist(m_object_no)) {
return 1;
}
}
std::string oid = image_ctx.get_object_name(m_object_no);
ldout(image_ctx.cct, 10) << "removing " << oid << dendl;
librados::AioCompletion *rados_completion =
util::create_rados_callback(this);
int r = image_ctx.data_ctx.aio_remove(oid, rados_completion);
ceph_assert(r == 0);
rados_completion->release();
return 0;
}
private:
uint64_t m_object_no;
};
template <typename I>
TrimRequest<I>::TrimRequest(I &image_ctx, Context *on_finish,
uint64_t original_size, uint64_t new_size,
ProgressContext &prog_ctx)
: AsyncRequest<I>(image_ctx, on_finish), m_new_size(new_size),
m_prog_ctx(prog_ctx)
{
uint64_t period = image_ctx.get_stripe_period();
uint64_t new_num_periods = ((m_new_size + period - 1) / period);
m_delete_off = std::min(new_num_periods * period, original_size);
// first object we can delete free and clear
m_delete_start = new_num_periods * image_ctx.get_stripe_count();
m_delete_start_min = m_delete_start;
m_num_objects = Striper::get_num_objects(image_ctx.layout, original_size);
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " trim image " << original_size << " -> "
<< m_new_size << " periods " << new_num_periods
<< " discard to offset " << m_delete_off
<< " delete objects " << m_delete_start
<< " to " << m_num_objects << dendl;
}
template <typename I>
bool TrimRequest<I>::should_complete(int r)
{
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " should_complete: r=" << r << dendl;
if (r == -ERESTART) {
ldout(cct, 5) << "trim operation interrupted" << dendl;
return true;
} else if (r < 0) {
lderr(cct) << "trim encountered an error: " << cpp_strerror(r) << dendl;
return true;
}
std::shared_lock owner_lock{image_ctx.owner_lock};
switch (m_state) {
case STATE_PRE_TRIM:
ldout(cct, 5) << " PRE_TRIM" << dendl;
send_copyup_objects();
break;
case STATE_COPYUP_OBJECTS:
ldout(cct, 5) << " COPYUP_OBJECTS" << dendl;
send_remove_objects();
break;
case STATE_REMOVE_OBJECTS:
ldout(cct, 5) << " REMOVE_OBJECTS" << dendl;
send_post_trim();
break;
case STATE_POST_TRIM:
ldout(cct, 5) << " POST_TRIM" << dendl;
send_clean_boundary();
break;
case STATE_CLEAN_BOUNDARY:
ldout(cct, 5) << "CLEAN_BOUNDARY" << dendl;
send_finish(0);
break;
case STATE_FINISHED:
ldout(cct, 5) << "FINISHED" << dendl;
return true;
default:
lderr(cct) << "invalid state: " << m_state << dendl;
ceph_abort();
break;
}
return false;
}
template <typename I>
void TrimRequest<I>::send() {
I &image_ctx = this->m_image_ctx;
CephContext *cct = image_ctx.cct;
if (!image_ctx.data_ctx.is_valid()) {
lderr(cct) << "missing data pool" << dendl;
send_finish(-ENODEV);
return;
}
send_pre_trim();
}
template<typename I>
void TrimRequest<I>::send_pre_trim() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
if (m_delete_start >= m_num_objects) {
send_clean_boundary();
return;
}
{
std::shared_lock 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
<< " num_objects=" << m_num_objects << dendl;
m_state = STATE_PRE_TRIM;
ceph_assert(image_ctx.exclusive_lock->is_lock_owner());
if (image_ctx.object_map->template aio_update<AsyncRequest<I> >(
CEPH_NOSNAP, m_delete_start_min, m_num_objects, OBJECT_PENDING,
OBJECT_EXISTS, {}, false, this)) {
return;
}
}
}
send_copyup_objects();
}
template<typename I>
void TrimRequest<I>::send_copyup_objects() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
IOContext io_context;
bool has_snapshots;
uint64_t copyup_end;
{
std::shared_lock image_locker{image_ctx.image_lock};
io_context = image_ctx.get_data_io_context();
has_snapshots = !image_ctx.snaps.empty();
uint64_t crypto_header_objects = Striper::get_num_objects(
image_ctx.layout,
image_ctx.get_area_size(io::ImageArea::CRYPTO_HEADER));
uint64_t raw_overlap;
int r = image_ctx.get_parent_overlap(CEPH_NOSNAP, &raw_overlap);
ceph_assert(r == 0);
auto overlap = image_ctx.reduce_parent_overlap(raw_overlap, false);
uint64_t data_overlap_objects = Striper::get_num_objects(
image_ctx.layout,
(overlap.second == io::ImageArea::DATA ? overlap.first : 0));
// copyup is only required for portion of image that overlaps parent
ceph_assert(m_delete_start >= crypto_header_objects);
copyup_end = crypto_header_objects + data_overlap_objects;
}
// TODO: protect against concurrent shrink and snap create?
// skip to remove if no copyup is required.
if (copyup_end <= m_delete_start || !has_snapshots) {
send_remove_objects();
return;
}
uint64_t copyup_start = m_delete_start;
m_delete_start = copyup_end;
ldout(image_ctx.cct, 5) << this << " send_copyup_objects: "
<< " start object=" << copyup_start << ", "
<< " end object=" << copyup_end << dendl;
m_state = STATE_COPYUP_OBJECTS;
Context *ctx = this->create_callback_context();
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_CopyupObject<I> >(),
boost::lambda::_1, &image_ctx, io_context, boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, copyup_start,
copyup_end);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template <typename I>
void TrimRequest<I>::send_remove_objects() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
ldout(image_ctx.cct, 5) << this << " send_remove_objects: "
<< " delete_start=" << m_delete_start
<< " num_objects=" << m_num_objects << dendl;
m_state = STATE_REMOVE_OBJECTS;
Context *ctx = this->create_callback_context();
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
boost::lambda::bind(boost::lambda::new_ptr<C_RemoveObject<I> >(),
boost::lambda::_1, &image_ctx, boost::lambda::_2));
AsyncObjectThrottle<I> *throttle = new AsyncObjectThrottle<I>(
this, image_ctx, context_factory, ctx, &m_prog_ctx, m_delete_start,
m_num_objects);
throttle->start_ops(
image_ctx.config.template get_val<uint64_t>("rbd_concurrent_management_ops"));
}
template<typename I>
void TrimRequest<I>::send_post_trim() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
{
std::shared_lock 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
<< " num_objects=" << m_num_objects << dendl;
m_state = STATE_POST_TRIM;
ceph_assert(image_ctx.exclusive_lock->is_lock_owner());
if (image_ctx.object_map->template aio_update<AsyncRequest<I> >(
CEPH_NOSNAP, m_delete_start_min, m_num_objects, OBJECT_NONEXISTENT,
OBJECT_PENDING, {}, false, this)) {
return;
}
}
}
send_clean_boundary();
}
template <typename I>
void TrimRequest<I>::send_clean_boundary() {
I &image_ctx = this->m_image_ctx;
ceph_assert(ceph_mutex_is_locked(image_ctx.owner_lock));
CephContext *cct = image_ctx.cct;
if (m_delete_off <= m_new_size) {
send_finish(0);
return;
}
// should have been canceled prior to releasing lock
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
uint64_t delete_len = m_delete_off - m_new_size;
ldout(image_ctx.cct, 5) << this << " send_clean_boundary: "
<< " delete_off=" << m_delete_off
<< " length=" << delete_len << dendl;
m_state = STATE_CLEAN_BOUNDARY;
IOContext io_context;
{
std::shared_lock image_locker{image_ctx.image_lock};
io_context = image_ctx.get_data_io_context();
}
// discard the weird boundary
std::vector<ObjectExtent> extents;
Striper::file_to_extents(cct, image_ctx.format_string,
&image_ctx.layout, m_new_size, delete_len, 0,
extents);
ContextCompletion *completion =
new ContextCompletion(this->create_async_callback_context(), true);
for (auto& extent : extents) {
ldout(cct, 20) << " ex " << extent << dendl;
Context *req_comp = new C_ContextCompletion(*completion);
if (extent.offset == 0) {
// treat as a full object delete on the boundary
extent.length = image_ctx.layout.object_size;
}
auto object_dispatch_spec = io::ObjectDispatchSpec::create_discard(
&image_ctx, io::OBJECT_DISPATCH_LAYER_NONE, extent.objectno, extent.offset,
extent.length, io_context, 0, 0, {}, req_comp);
object_dispatch_spec->send();
}
completion->finish_adding_requests();
}
template <typename I>
void TrimRequest<I>::send_finish(int r) {
m_state = STATE_FINISHED;
this->async_complete(r);
}
} // namespace operation
} // namespace librbd
template class librbd::operation::TrimRequest<librbd::ImageCtx>;
| 12,254 | 30.997389 | 82 |
cc
|
null |
ceph-main/src/librbd/operation/TrimRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_OPERATION_TRIM_REQUEST_H
#define CEPH_LIBRBD_OPERATION_TRIM_REQUEST_H
#include "librbd/AsyncRequest.h"
namespace librbd
{
class ImageCtx;
class ProgressContext;
namespace operation {
template <typename ImageCtxT = ImageCtx>
class TrimRequest : public AsyncRequest<ImageCtxT>
{
public:
static TrimRequest *create(ImageCtxT &image_ctx, Context *on_finish,
uint64_t original_size, uint64_t new_size,
ProgressContext &prog_ctx) {
return new TrimRequest(image_ctx, on_finish, original_size, new_size,
prog_ctx);
}
TrimRequest(ImageCtxT &image_ctx, Context *on_finish,
uint64_t original_size, uint64_t new_size,
ProgressContext &prog_ctx);
void send() override;
protected:
/**
* Trim goes through the following state machine to remove whole objects,
* clean partially trimmed objects, and update the object map:
*
* @verbatim
*
* <start> . . . . . . . . . . . . . . . . .
* | .
* v (skip if not needed) .
* STATE_PRE_TRIM .
* | .
* v (skip if not needed) .
* STATE_COPYUP_OBJECTS .
* | .
* v (skip if not needed) .
* STATE_REMOVE_OBJECTS .
* | .
* v (skip if not needed) .
* STATE_POST_TRIM .
* | .
* v (skip if not needed) .
* STATE_CLEAN_BOUNDARY .
* | .
* v .
* STATE_FINISHED < . . . . . . . . . . . . . . .
* |
* v
* <finish>
*
* The _COPYUP_OBJECTS state is skipped if there is no parent overlap
* within the new image size and the image does not have any snapshots.
* The _PRE_TRIM/_POST_TRIM states are skipped if the object map
* isn't enabled. The _REMOVE_OBJECTS state is skipped if no whole objects
* are removed. The _CLEAN_BOUNDARY state is skipped if no boundary
* objects are cleaned. The state machine will immediately transition
* to _FINISHED state if there are no bytes to trim.
*/
enum State {
STATE_PRE_TRIM,
STATE_COPYUP_OBJECTS,
STATE_REMOVE_OBJECTS,
STATE_POST_TRIM,
STATE_CLEAN_BOUNDARY,
STATE_FINISHED
};
bool should_complete(int r) override;
State m_state = STATE_PRE_TRIM;
private:
uint64_t m_delete_start;
uint64_t m_delete_start_min = 0;
uint64_t m_num_objects;
uint64_t m_delete_off;
uint64_t m_new_size;
ProgressContext &m_prog_ctx;
void send_pre_trim();
void send_copyup_objects();
void send_remove_objects();
void send_post_trim();
void send_clean_boundary();
void send_finish(int r);
};
} // namespace operation
} // namespace librbd
extern template class librbd::operation::TrimRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_OPERATION_TRIM_REQUEST_H
| 3,361 | 30.12963 | 76 |
h
|
null |
ceph-main/src/librbd/plugin/Api.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/Timer.h"
#include "librbd/plugin/Api.h"
#include "librbd/ImageCtx.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/Utils.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
namespace librbd {
namespace plugin {
template <typename I>
void Api<I>::read_parent(
I *image_ctx, uint64_t object_no, io::ReadExtents* extents,
librados::snap_t snap_id, const ZTracer::Trace &trace,
Context* on_finish) {
io::util::read_parent<I>(image_ctx, object_no, extents, snap_id, trace,
on_finish);
}
template <typename I>
void Api<I>::execute_image_metadata_set(
I *image_ctx, const std::string &key,
const std::string &value, Context *on_finish) {
ImageCtx* ictx = util::get_image_ctx(image_ctx);
ictx->operations->execute_metadata_set(key, value, on_finish);
}
template <typename I>
void Api<I>::execute_image_metadata_remove(
I *image_ctx, const std::string &key, Context *on_finish) {
ImageCtx* ictx = util::get_image_ctx(image_ctx);
ictx->operations->execute_metadata_remove(key, on_finish);
}
template <typename I>
void Api<I>::get_image_timer_instance(
CephContext *cct, SafeTimer **timer, ceph::mutex **timer_lock) {
ImageCtx::get_timer_instance(cct, timer, timer_lock);
}
template <typename I>
bool Api<I>::test_image_features(I *image_ctx, uint64_t features) {
return image_ctx->test_features(features);
}
template <typename I>
void Api<I>::update_aio_comp(io::AioCompletion* aio_comp,
uint32_t request_count,
io::ReadResult &read_result,
io::Extents &image_extents) {
aio_comp->set_request_count(request_count);
aio_comp->read_result = std::move(read_result);
aio_comp->read_result.set_image_extents(image_extents);
start_in_flight_io(aio_comp);
}
template <typename I>
void Api<I>::update_aio_comp(
io::AioCompletion* aio_comp, uint32_t request_count) {
aio_comp->set_request_count(request_count);
start_in_flight_io(aio_comp);
}
template <typename I>
io::ReadResult::C_ImageReadRequest* Api<I>::create_image_read_request(
io::AioCompletion* aio_comp, uint64_t buffer_offset,
const Extents& image_extents) {
return new io::ReadResult::C_ImageReadRequest(
aio_comp, buffer_offset, image_extents);
}
template <typename I>
io::C_AioRequest* Api<I>::create_aio_request(io::AioCompletion* aio_comp) {
io::C_AioRequest *req_comp = new io::C_AioRequest(aio_comp);
return req_comp;
}
template <typename I>
void Api<I>::start_in_flight_io(io::AioCompletion* aio_comp) {
if (!aio_comp->async_op.started()) {
aio_comp->start_op();
}
}
} // namespace plugin
} // namespace librbd
template class librbd::plugin::Api<librbd::ImageCtx>;
| 2,862 | 29.784946 | 75 |
cc
|
null |
ceph-main/src/librbd/plugin/Api.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_PLUGIN_API_H
#define CEPH_LIBRBD_PLUGIN_API_H
#include "common/Timer.h"
#include "common/ceph_mutex.h"
#include "include/common_fwd.h"
#include "include/int_types.h"
#include "include/rados/librados.hpp"
#include "librbd/io/Types.h"
#include "librbd/io/ReadResult.h"
namespace ZTracer { struct Trace; }
namespace librbd {
namespace io {
class AioCompletion;
class C_AioRequest;
}
struct ImageCtx;
namespace plugin {
template <typename ImageCtxT>
struct Api {
using Extents = librbd::io::Extents;
Api() {}
virtual ~Api() {}
virtual void read_parent(
ImageCtxT *image_ctx, uint64_t object_no, io::ReadExtents* extents,
librados::snap_t snap_id, const ZTracer::Trace &trace,
Context* on_finish);
virtual void execute_image_metadata_set(
ImageCtxT *image_ctx,
const std::string &key,
const std::string &value,
Context *on_finish);
virtual void execute_image_metadata_remove(
ImageCtxT *image_ctx,
const std::string &key,
Context *on_finish);
virtual void get_image_timer_instance(
CephContext *cct, SafeTimer **timer,
ceph::mutex **timer_lock);
virtual bool test_image_features(
ImageCtxT *image_ctx,
uint64_t features);
virtual void update_aio_comp(
io::AioCompletion* aio_comp,
uint32_t request_count,
io::ReadResult& read_result,
io::Extents &image_extents);
virtual void update_aio_comp(
io::AioCompletion* aio_comp,
uint32_t request_count);
virtual io::ReadResult::C_ImageReadRequest* create_image_read_request(
io::AioCompletion* aio_comp, uint64_t buffer_offset,
const Extents& image_extents);
virtual io::C_AioRequest* create_aio_request(io::AioCompletion* aio_comp);
private:
void start_in_flight_io(io::AioCompletion* aio_comp);
};
} // namespace plugin
} // namespace librbd
extern template class librbd::plugin::Api<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_PLUGIN_API_H
| 2,076 | 23.435294 | 76 |
h
|
null |
ceph-main/src/librbd/plugin/ParentCache.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/plugin/ParentCache.h"
#include "ceph_ver.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/PluginRegistry.h"
#include "librbd/ImageCtx.h"
#include "librbd/cache/ParentCacheObjectDispatch.h"
extern "C" {
const char *__ceph_plugin_version() {
return CEPH_GIT_NICE_VER;
}
int __ceph_plugin_init(CephContext *cct, const std::string& type,
const std::string& name) {
auto plugin_registry = cct->get_plugin_registry();
return plugin_registry->add(
type, name, new librbd::plugin::ParentCache<librbd::ImageCtx>(cct));
}
} // extern "C"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::plugin::ParentCache: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace plugin {
template <typename I>
void ParentCache<I>::init(I* image_ctx, Api<I>& api,
cache::ImageWritebackInterface& image_writeback,
PluginHookPoints& hook_points_list,
Context* on_finish) {
bool parent_cache_enabled = image_ctx->config.template get_val<bool>(
"rbd_parent_cache_enabled");
if (image_ctx->child == nullptr || !parent_cache_enabled ||
!image_ctx->data_ctx.is_valid()) {
on_finish->complete(0);
return;
}
auto cct = image_ctx->cct;
ldout(cct, 5) << dendl;
auto parent_cache = cache::ParentCacheObjectDispatch<I>::create(
image_ctx, api);
on_finish = new LambdaContext([this, on_finish, parent_cache](int r) {
if (r < 0) {
// the object dispatcher will handle cleanup if successfully initialized
delete parent_cache;
}
handle_init_parent_cache(r, on_finish);
});
parent_cache->init(on_finish);
}
template <typename I>
void ParentCache<I>::handle_init_parent_cache(int r, Context* on_finish) {
ldout(cct, 5) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "Failed to initialize parent cache object dispatch layer: "
<< cpp_strerror(r) << dendl;
on_finish->complete(r);
return;
}
on_finish->complete(0);
}
} // namespace plugin
} // namespace librbd
template class librbd::plugin::ParentCache<librbd::ImageCtx>;
| 2,338 | 27.52439 | 80 |
cc
|
null |
ceph-main/src/librbd/plugin/ParentCache.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_PLUGIN_PARENT_CACHE_H
#define CEPH_LIBRBD_PLUGIN_PARENT_CACHE_H
#include "librbd/plugin/Types.h"
#include "include/Context.h"
namespace librbd {
struct ImageCtx;
namespace plugin {
template <typename ImageCtxT>
class ParentCache : public Interface<ImageCtxT> {
public:
ParentCache(CephContext* cct) : Interface<ImageCtxT>(cct) {
}
void init(ImageCtxT* image_ctx, Api<ImageCtxT>& api,
cache::ImageWritebackInterface& image_writeback,
PluginHookPoints& hook_points_list,
Context* on_finish) override;
private:
void handle_init_parent_cache(int r, Context* on_finish);
using ceph::Plugin::cct;
};
} // namespace plugin
} // namespace librbd
extern template class librbd::plugin::ParentCache<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_PLUGIN_PARENT_CACHE_H
| 927 | 22.794872 | 70 |
h
|
null |
ceph-main/src/librbd/plugin/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_PLUGIN_TYPES_H
#define CEPH_LIBRBD_PLUGIN_TYPES_H
#include "include/common_fwd.h"
#include "include/Context.h"
#include "common/PluginRegistry.h"
#include "librbd/cache/ImageWriteback.h"
namespace librbd {
namespace plugin {
template <typename> struct Api;
struct HookPoints {
virtual ~HookPoints() {
}
virtual void acquired_exclusive_lock(Context* on_finish) = 0;
virtual void prerelease_exclusive_lock(Context* on_finish) = 0;
virtual void discard(Context* on_finish) {
on_finish->complete(0);
}
};
typedef std::list<std::unique_ptr<HookPoints>> PluginHookPoints;
template <typename ImageCtxT>
struct Interface : public ceph::Plugin {
Interface(CephContext* cct) : Plugin(cct) {
}
virtual ~Interface() {
}
virtual void init(ImageCtxT* image_ctx, Api<ImageCtxT>& api,
librbd::cache::ImageWritebackInterface& image_writeback,
PluginHookPoints& hook_points_list, Context* on_finish) = 0;
};
} // namespace plugin
} // namespace librbd
#endif // CEPH_LIBRBD_PLUGIN_TYPES_H
| 1,152 | 24.065217 | 80 |
h
|
null |
ceph-main/src/librbd/plugin/WriteLogImageCache.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "ceph_ver.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/PluginRegistry.h"
#include "librbd/ImageCtx.h"
#include "librbd/cache/WriteLogImageDispatch.h"
#include "librbd/cache/ImageWriteback.h"
#include "librbd/cache/Utils.h"
#include "librbd/cache/pwl/DiscardRequest.h"
#include "librbd/cache/pwl/InitRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/plugin/WriteLogImageCache.h"
extern "C" {
const char *__ceph_plugin_version() {
return CEPH_GIT_NICE_VER;
}
int __ceph_plugin_init(CephContext *cct, const std::string& type,
const std::string& name) {
auto plugin_registry = cct->get_plugin_registry();
return plugin_registry->add(
type, name, new librbd::plugin::WriteLogImageCache<librbd::ImageCtx>(cct));
}
} // extern "C"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::plugin::WriteLogImageCache: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace plugin {
template <typename I>
void WriteLogImageCache<I>::init(I* image_ctx, Api<I>& api,
cache::ImageWritebackInterface& image_writeback,
PluginHookPoints& hook_points_list,
Context* on_finish) {
bool pwl_enabled = librbd::cache::util::is_pwl_enabled(*image_ctx);
if (!pwl_enabled || !image_ctx->data_ctx.is_valid()) {
on_finish->complete(0);
return;
}
auto cct = image_ctx->cct;
ldout(cct, 5) << dendl;
auto hook_points = std::make_unique<WriteLogImageCache::HookPoints>(
image_ctx, image_writeback, api);
hook_points_list.emplace_back(std::move(hook_points));
on_finish->complete(0);
}
template <typename I>
WriteLogImageCache<I>::~WriteLogImageCache() {
}
template <typename I>
WriteLogImageCache<I>::HookPoints::HookPoints(
I* image_ctx, cache::ImageWritebackInterface& image_writeback,
plugin::Api<I>& plugin_api)
: m_image_ctx(image_ctx), m_image_writeback(image_writeback),
m_plugin_api(plugin_api)
{
}
template <typename I>
WriteLogImageCache<I>::HookPoints::~HookPoints() {
}
template <typename I>
void WriteLogImageCache<I>::HookPoints::acquired_exclusive_lock(
Context* on_finish) {
cache::pwl::InitRequest<I> *req = cache::pwl::InitRequest<I>::create(
*m_image_ctx, m_image_writeback, m_plugin_api, on_finish);
req->send();
}
template <typename I>
void WriteLogImageCache<I>::HookPoints::prerelease_exclusive_lock(
Context* on_finish) {
m_image_ctx->io_image_dispatcher->shut_down_dispatch(
io::IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE, on_finish);
}
template <typename I>
void WriteLogImageCache<I>::HookPoints::discard(
Context* on_finish) {
cache::pwl::DiscardRequest<I> *req = cache::pwl::DiscardRequest<I>::create(
*m_image_ctx, m_plugin_api, on_finish);
req->send();
}
} // namespace plugin
} // namespace librbd
template class librbd::plugin::WriteLogImageCache<librbd::ImageCtx>;
| 3,129 | 28.809524 | 81 |
cc
|
null |
ceph-main/src/librbd/plugin/WriteLogImageCache.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H
#define CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H
#include "librbd/plugin/Types.h"
#include "include/Context.h"
namespace librbd {
struct ImageCtx;
namespace plugin {
template <typename ImageCtxT>
class WriteLogImageCache : public Interface<ImageCtxT> {
public:
WriteLogImageCache(CephContext* cct) : Interface<ImageCtxT>(cct) {
}
~WriteLogImageCache() override;
void init(ImageCtxT* image_ctx, Api<ImageCtxT>& api,
cache::ImageWritebackInterface& image_writeback,
PluginHookPoints& hook_points_list,
Context* on_finish) override;
class HookPoints : public plugin::HookPoints {
public:
HookPoints(ImageCtxT* image_ctx,
cache::ImageWritebackInterface& image_writeback,
plugin::Api<ImageCtxT>& plugin_api);
~HookPoints() override;
void acquired_exclusive_lock(Context* on_finish) override;
void prerelease_exclusive_lock(Context* on_finish) override;
void discard(Context* on_finish) override;
private:
ImageCtxT* m_image_ctx;
cache::ImageWritebackInterface& m_image_writeback;
plugin::Api<ImageCtxT>& m_plugin_api;
};
};
} // namespace plugin
} // namespace librbd
extern template class librbd::plugin::WriteLogImageCache<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_PLUGIN_WRITELOG_IMAGE_CACHE_H
| 1,455 | 25.962963 | 75 |
h
|
null |
ceph-main/src/librbd/trash/MoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/trash/MoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::trash::MoveRequest: " << this \
<< " " << __func__ << ": "
namespace librbd {
namespace trash {
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
void MoveRequest<I>::send() {
trash_add();
}
template <typename I>
void MoveRequest<I>::trash_add() {
ldout(m_cct, 10) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::trash_add(&op, m_image_id, m_trash_image_spec);
auto aio_comp = create_rados_callback<
MoveRequest<I>, &MoveRequest<I>::handle_trash_add>(this);
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void MoveRequest<I>::handle_trash_add(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r == -EEXIST) {
ldout(m_cct, 10) << "previous unfinished deferred remove for image: "
<< m_image_id << dendl;
} else if (r < 0) {
lderr(m_cct) << "failed to add image to trash: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
remove_id();
}
template <typename I>
void MoveRequest<I>::remove_id() {
ldout(m_cct, 10) << dendl;
auto aio_comp = create_rados_callback<
MoveRequest<I>, &MoveRequest<I>::handle_remove_id>(this);
int r = m_io_ctx.aio_remove(util::id_obj_name(m_trash_image_spec.name),
aio_comp);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void MoveRequest<I>::handle_remove_id(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(m_cct) << "failed to remove image id object: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
directory_remove();
}
template <typename I>
void MoveRequest<I>::directory_remove() {
ldout(m_cct, 10) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::dir_remove_image(&op, m_trash_image_spec.name,
m_image_id);
auto aio_comp = create_rados_callback<
MoveRequest<I>, &MoveRequest<I>::handle_directory_remove>(this);
int r = m_io_ctx.aio_operate(RBD_DIRECTORY, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void MoveRequest<I>::handle_directory_remove(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r == -ENOENT) {
r = 0;
}
if (r < 0) {
lderr(m_cct) << "failed to remove image from directory: " << cpp_strerror(r)
<< dendl;
}
finish(r);
}
template <typename I>
void MoveRequest<I>::finish(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace trash
} // namespace librbd
template class librbd::trash::MoveRequest<librbd::ImageCtx>;
| 3,186 | 24.094488 | 80 |
cc
|
null |
ceph-main/src/librbd/trash/MoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_TRASH_MOVE_REQUEST_H
#define CEPH_LIBRBD_TRASH_MOVE_REQUEST_H
#include "include/common_fwd.h"
#include "include/utime.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace trash {
template <typename ImageCtxT = librbd::ImageCtx>
class MoveRequest {
public:
static MoveRequest* create(librados::IoCtx& io_ctx,
const std::string& image_id,
const cls::rbd::TrashImageSpec& trash_image_spec,
Context* on_finish) {
return new MoveRequest(io_ctx, image_id, trash_image_spec, on_finish);
}
MoveRequest(librados::IoCtx& io_ctx, const std::string& image_id,
const cls::rbd::TrashImageSpec& trash_image_spec,
Context* on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id),
m_trash_image_spec(trash_image_spec), m_on_finish(on_finish),
m_cct(reinterpret_cast<CephContext *>(io_ctx.cct())) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* TRASH_ADD
* |
* v
* REMOVE_ID
* |
* v
* DIRECTORY_REMOVE
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_image_id;
cls::rbd::TrashImageSpec m_trash_image_spec;
Context *m_on_finish;
CephContext *m_cct;
void trash_add();
void handle_trash_add(int r);
void remove_id();
void handle_remove_id(int r);
void directory_remove();
void handle_directory_remove(int r);
void finish(int r);
};
} // namespace trash
} // namespace librbd
extern template class librbd::trash::MoveRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_TRASH_MOVE_REQUEST_H
| 1,897 | 20.568182 | 78 |
h
|
null |
ceph-main/src/librbd/trash/RemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/trash/RemoveRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/image/RemoveRequest.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::trash::RemoveRequest: " << this \
<< " " << __func__ << ": "
namespace librbd {
namespace trash {
using util::create_context_callback;
using util::create_rados_callback;
template <typename I>
void RemoveRequest<I>::send() {
set_state();
}
template <typename I>
void RemoveRequest<I>::set_state() {
ldout(m_cct, 10) << dendl;
librados::ObjectWriteOperation op;
cls_client::trash_state_set(&op, m_image_id, m_trash_set_state,
m_trash_expect_state);
auto aio_comp = create_rados_callback<
RemoveRequest<I>, &RemoveRequest<I>::handle_set_state>(this);
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void RemoveRequest<I>::handle_set_state(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r < 0 && r != -EOPNOTSUPP) {
lderr(m_cct) << "error setting trash image state: " << cpp_strerror(r)
<< dendl;
if (m_ret_val == 0) {
m_ret_val = r;
}
if (m_trash_set_state == cls::rbd::TRASH_IMAGE_STATE_REMOVING) {
close_image();
} else {
finish(m_ret_val);
}
return;
}
if (m_trash_set_state == cls::rbd::TRASH_IMAGE_STATE_REMOVING) {
remove_image();
} else {
ceph_assert(m_trash_set_state == cls::rbd::TRASH_IMAGE_STATE_NORMAL);
finish(m_ret_val < 0 ? m_ret_val : r);
};
}
template <typename I>
void RemoveRequest<I>::close_image() {
if (m_image_ctx == nullptr) {
finish(m_ret_val);
return;
}
ldout(m_cct, 10) << dendl;
auto ctx = create_context_callback<
RemoveRequest<I>, &RemoveRequest<I>::handle_close_image>(this);
m_image_ctx->state->close(ctx);
}
template <typename I>
void RemoveRequest<I>::handle_close_image(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r < 0) {
ldout(m_cct, 5) << "failed to close image:" << cpp_strerror(r) << dendl;
}
m_image_ctx = nullptr;
finish(m_ret_val);
}
template <typename I>
void RemoveRequest<I>::remove_image() {
ldout(m_cct, 10) << dendl;
auto ctx = create_context_callback<
RemoveRequest<I>, &RemoveRequest<I>::handle_remove_image>(this);
if (m_image_ctx != nullptr) {
auto req = librbd::image::RemoveRequest<I>::create(
m_io_ctx, m_image_ctx, m_force, true, m_prog_ctx, m_op_work_queue, ctx);
req->send();
} else {
auto req = librbd::image::RemoveRequest<I>::create(
m_io_ctx, "", m_image_id, m_force, true, m_prog_ctx, m_op_work_queue,
ctx);
req->send();
}
}
template <typename I>
void RemoveRequest<I>::handle_remove_image(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r < 0) {
ldout(m_cct, 5) << "failed to remove image:" << cpp_strerror(r) << dendl;
m_ret_val = r;
m_trash_set_state = cls::rbd::TRASH_IMAGE_STATE_NORMAL;
m_trash_expect_state = cls::rbd::TRASH_IMAGE_STATE_REMOVING;
set_state();
return;
}
m_image_ctx = nullptr;
remove_trash_entry();
}
template <typename I>
void RemoveRequest<I>::remove_trash_entry() {
ldout(m_cct, 10) << dendl;
librados::ObjectWriteOperation op;
cls_client::trash_remove(&op, m_image_id);
auto aio_comp = create_rados_callback<
RemoveRequest<I>, &RemoveRequest<I>::handle_remove_trash_entry>(this);
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void RemoveRequest<I>::handle_remove_trash_entry(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
lderr(m_cct) << "error removing trash entry: " << cpp_strerror(r) << dendl;
}
finish(0);
}
template <typename I>
void RemoveRequest<I>::finish(int r) {
ldout(m_cct, 10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace trash
} // namespace librbd
template class librbd::trash::RemoveRequest<librbd::ImageCtx>;
| 4,427 | 24.894737 | 80 |
cc
|
null |
ceph-main/src/librbd/trash/RemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_TRASH_REMOVE_REQUEST_H
#define CEPH_LIBRBD_TRASH_REMOVE_REQUEST_H
#include "include/common_fwd.h"
#include "include/utime.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include <string>
class Context;
namespace librbd {
struct ImageCtx;
class ProgressContext;
namespace asio { struct ContextWQ; }
namespace trash {
template <typename ImageCtxT = librbd::ImageCtx>
class RemoveRequest {
public:
static RemoveRequest* create(librados::IoCtx &io_ctx,
const std::string &image_id,
asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish) {
return new RemoveRequest(io_ctx, image_id, op_work_queue, force, prog_ctx,
on_finish);
}
static RemoveRequest* create(librados::IoCtx &io_ctx, ImageCtxT *image_ctx,
asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish) {
return new RemoveRequest(io_ctx, image_ctx, op_work_queue, force, prog_ctx,
on_finish);
}
RemoveRequest(librados::IoCtx &io_ctx, const std::string &image_id,
asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id), m_op_work_queue(op_work_queue),
m_force(force), m_prog_ctx(prog_ctx), m_on_finish(on_finish),
m_cct(reinterpret_cast<CephContext *>(io_ctx.cct())) {
}
RemoveRequest(librados::IoCtx &io_ctx, ImageCtxT *image_ctx,
asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish)
: m_io_ctx(io_ctx), m_image_ctx(image_ctx), m_image_id(m_image_ctx->id),
m_op_work_queue(op_work_queue), m_force(force), m_prog_ctx(prog_ctx),
m_on_finish(on_finish),
m_cct(reinterpret_cast<CephContext *>(io_ctx.cct())) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* SET_STATE (removing) * * * * * * *> CLOSE_IMAGE
* | |
* v |
* REMOVE_IMAGE * * *> SET_STATE (normal) |
* | | |
* v | |
* REMOVE_TRASH_ENTRY | |
* | | |
* v | |
* <finish> <-------------/<---------------/
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
ImageCtxT *m_image_ctx = nullptr;
std::string m_image_id;
asio::ContextWQ *m_op_work_queue;
bool m_force;
ProgressContext &m_prog_ctx;
Context *m_on_finish;
CephContext *m_cct;
cls::rbd::TrashImageState m_trash_set_state =
cls::rbd::TRASH_IMAGE_STATE_REMOVING;
cls::rbd::TrashImageState m_trash_expect_state =
cls::rbd::TRASH_IMAGE_STATE_NORMAL;
int m_ret_val = 0;
void set_state();
void handle_set_state(int r);
void close_image();
void handle_close_image(int r);
void remove_image();
void handle_remove_image(int r);
void remove_trash_entry();
void handle_remove_trash_entry(int r);
void finish(int r);
};
} // namespace trash
} // namespace librbd
extern template class librbd::trash::RemoveRequest<librbd::ImageCtx>;
#endif // CEPH_LIBRBD_TRASH_REMOVE_REQUEST_H
| 3,589 | 29.168067 | 79 |
h
|
null |
ceph-main/src/librbd/trash_watcher/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/Formatter.h"
#include "include/ceph_assert.h"
#include "include/stringify.h"
#include "librbd/trash_watcher/Types.h"
#include "librbd/watcher/Utils.h"
namespace librbd {
namespace trash_watcher {
namespace {
class DumpPayloadVisitor : public boost::static_visitor<void> {
public:
explicit DumpPayloadVisitor(Formatter *formatter) : m_formatter(formatter) {}
template <typename Payload>
inline void operator()(const Payload &payload) const {
NotifyOp notify_op = Payload::NOTIFY_OP;
m_formatter->dump_string("notify_op", stringify(notify_op));
payload.dump(m_formatter);
}
private:
ceph::Formatter *m_formatter;
};
} // anonymous namespace
void ImageAddedPayload::encode(bufferlist &bl) const {
using ceph::encode;
encode(image_id, bl);
encode(trash_image_spec, bl);
}
void ImageAddedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(image_id, iter);
decode(trash_image_spec, iter);
}
void ImageAddedPayload::dump(Formatter *f) const {
f->dump_string("image_id", image_id);
f->open_object_section("trash_image_spec");
trash_image_spec.dump(f);
f->close_section();
}
void ImageRemovedPayload::encode(bufferlist &bl) const {
using ceph::encode;
encode(image_id, bl);
}
void ImageRemovedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(image_id, iter);
}
void ImageRemovedPayload::dump(Formatter *f) const {
f->dump_string("image_id", image_id);
}
void UnknownPayload::encode(bufferlist &bl) const {
ceph_abort();
}
void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
}
void NotifyMessage::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
boost::apply_visitor(watcher::util::EncodePayloadVisitor(bl), payload);
ENCODE_FINISH(bl);
}
void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
case NOTIFY_OP_IMAGE_ADDED:
payload = ImageAddedPayload();
break;
case NOTIFY_OP_IMAGE_REMOVED:
payload = ImageRemovedPayload();
break;
default:
payload = UnknownPayload();
break;
}
apply_visitor(watcher::util::DecodePayloadVisitor(struct_v, iter), payload);
DECODE_FINISH(iter);
}
void NotifyMessage::dump(Formatter *f) const {
apply_visitor(DumpPayloadVisitor(f), payload);
}
void NotifyMessage::generate_test_instances(std::list<NotifyMessage *> &o) {
o.push_back(new NotifyMessage{ImageAddedPayload{
"id", {cls::rbd::TRASH_IMAGE_SOURCE_USER, "name", {}, {}}}});
o.push_back(new NotifyMessage{ImageRemovedPayload{"id"}});
}
std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
switch (op) {
case NOTIFY_OP_IMAGE_ADDED:
out << "ImageAdded";
break;
case NOTIFY_OP_IMAGE_REMOVED:
out << "ImageRemoved";
break;
default:
out << "Unknown (" << static_cast<uint32_t>(op) << ")";
break;
}
return out;
}
} // namespace trash_watcher
} // namespace librbd
| 3,267 | 23.946565 | 82 |
cc
|
null |
ceph-main/src/librbd/trash_watcher/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_TRASH_WATCHER_TYPES_H
#define CEPH_LIBRBD_TRASH_WATCHER_TYPES_H
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include "cls/rbd/cls_rbd_types.h"
#include <iosfwd>
#include <list>
#include <string>
#include <boost/variant.hpp>
namespace librbd {
namespace trash_watcher {
enum NotifyOp {
NOTIFY_OP_IMAGE_ADDED = 0,
NOTIFY_OP_IMAGE_REMOVED = 1
};
struct ImageAddedPayload {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_ADDED;
std::string image_id;
cls::rbd::TrashImageSpec trash_image_spec;
ImageAddedPayload() {
}
ImageAddedPayload(const std::string& image_id,
const cls::rbd::TrashImageSpec& trash_image_spec)
: image_id(image_id), trash_image_spec(trash_image_spec) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct ImageRemovedPayload {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_REMOVED;
std::string image_id;
ImageRemovedPayload() {
}
ImageRemovedPayload(const std::string& image_id)
: image_id(image_id) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct UnknownPayload {
static const NotifyOp NOTIFY_OP = static_cast<NotifyOp>(-1);
UnknownPayload() {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
typedef boost::variant<ImageAddedPayload,
ImageRemovedPayload,
UnknownPayload> Payload;
struct NotifyMessage {
NotifyMessage(const Payload &payload = UnknownPayload()) : payload(payload) {
}
Payload payload;
void encode(bufferlist& bl) const;
void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
};
WRITE_CLASS_ENCODER(NotifyMessage);
std::ostream &operator<<(std::ostream &out, const NotifyOp &op);
} // namespace trash_watcher
} // namespace librbd
using librbd::trash_watcher::encode;
using librbd::trash_watcher::decode;
#endif // CEPH_LIBRBD_TRASH_WATCHER_TYPES_H
| 2,375 | 23.244898 | 79 |
h
|
null |
ceph-main/src/librbd/watcher/Notifier.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/watcher/Notifier.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/watcher/Types.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::watcher::Notifier: " \
<< this << " " << __func__ << ": "
namespace librbd {
namespace watcher {
const uint64_t Notifier::NOTIFY_TIMEOUT = 5000;
Notifier::C_AioNotify::C_AioNotify(Notifier *notifier, NotifyResponse *response,
Context *on_finish)
: notifier(notifier), response(response), on_finish(on_finish) {
}
void Notifier::C_AioNotify::finish(int r) {
if (response != nullptr) {
if (r == 0 || r == -ETIMEDOUT) {
try {
auto it = out_bl.cbegin();
decode(*response, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
}
}
}
notifier->handle_notify(r, on_finish);
}
Notifier::Notifier(asio::ContextWQ *work_queue, IoCtx &ioctx,
const std::string &oid)
: m_work_queue(work_queue), m_ioctx(ioctx), m_oid(oid),
m_aio_notify_lock(ceph::make_mutex(util::unique_lock_name(
"librbd::object_watcher::Notifier::m_aio_notify_lock", this))) {
m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
}
Notifier::~Notifier() {
std::lock_guard aio_notify_locker{m_aio_notify_lock};
ceph_assert(m_pending_aio_notifies == 0);
}
void Notifier::flush(Context *on_finish) {
std::lock_guard aio_notify_locker{m_aio_notify_lock};
if (m_pending_aio_notifies == 0) {
m_work_queue->queue(on_finish, 0);
return;
}
m_aio_notify_flush_ctxs.push_back(on_finish);
}
void Notifier::notify(bufferlist &bl, NotifyResponse *response,
Context *on_finish) {
{
std::lock_guard aio_notify_locker{m_aio_notify_lock};
++m_pending_aio_notifies;
ldout(m_cct, 20) << "pending=" << m_pending_aio_notifies << dendl;
}
C_AioNotify *ctx = new C_AioNotify(this, response, on_finish);
librados::AioCompletion *comp = util::create_rados_callback(ctx);
int r = m_ioctx.aio_notify(m_oid, comp, bl, NOTIFY_TIMEOUT, &ctx->out_bl);
ceph_assert(r == 0);
comp->release();
}
void Notifier::handle_notify(int r, Context *on_finish) {
ldout(m_cct, 20) << "r=" << r << dendl;
std::lock_guard aio_notify_locker{m_aio_notify_lock};
ceph_assert(m_pending_aio_notifies > 0);
--m_pending_aio_notifies;
ldout(m_cct, 20) << "pending=" << m_pending_aio_notifies << dendl;
if (m_pending_aio_notifies == 0) {
for (auto ctx : m_aio_notify_flush_ctxs) {
m_work_queue->queue(ctx, 0);
}
m_aio_notify_flush_ctxs.clear();
}
if (on_finish != nullptr) {
m_work_queue->queue(on_finish, r);
}
}
} // namespace watcher
} // namespace librbd
| 2,897 | 27.98 | 80 |
cc
|
null |
ceph-main/src/librbd/watcher/Notifier.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_WATCHER_NOTIFIER_H
#define CEPH_LIBRBD_WATCHER_NOTIFIER_H
#include "include/int_types.h"
#include "include/buffer_fwd.h"
#include "include/Context.h"
#include "include/rados/librados.hpp"
#include "common/ceph_mutex.h"
#include <list>
namespace librbd {
namespace asio { struct ContextWQ; }
namespace watcher {
struct NotifyResponse;
class Notifier {
public:
static const uint64_t NOTIFY_TIMEOUT;
Notifier(asio::ContextWQ *work_queue, librados::IoCtx &ioctx,
const std::string &oid);
~Notifier();
void flush(Context *on_finish);
void notify(bufferlist &bl, NotifyResponse *response, Context *on_finish);
private:
typedef std::list<Context*> Contexts;
struct C_AioNotify : public Context {
Notifier *notifier;
NotifyResponse *response;
Context *on_finish;
bufferlist out_bl;
C_AioNotify(Notifier *notifier, NotifyResponse *response,
Context *on_finish);
void finish(int r) override;
};
asio::ContextWQ *m_work_queue;
librados::IoCtx &m_ioctx;
CephContext *m_cct;
std::string m_oid;
ceph::mutex m_aio_notify_lock;
size_t m_pending_aio_notifies = 0;
Contexts m_aio_notify_flush_ctxs;
void handle_notify(int r, Context *on_finish);
};
} // namespace watcher
} // namespace librbd
#endif // CEPH_LIBRBD_WATCHER_NOTIFIER_H
| 1,437 | 21.123077 | 76 |
h
|
null |
ceph-main/src/librbd/watcher/RewatchRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/watcher/RewatchRequest.h"
#include "common/ceph_mutex.h"
#include "common/errno.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#define dout_prefix *_dout << "librbd::watcher::RewatchRequest: " \
<< this << " " << __func__ << " "
namespace librbd {
using util::create_context_callback;
using util::create_rados_callback;
namespace watcher {
using std::string;
RewatchRequest::RewatchRequest(librados::IoCtx& ioctx, const string& oid,
ceph::shared_mutex &watch_lock,
librados::WatchCtx2 *watch_ctx,
uint64_t *watch_handle, Context *on_finish)
: m_ioctx(ioctx), m_oid(oid), m_watch_lock(watch_lock),
m_watch_ctx(watch_ctx), m_watch_handle(watch_handle),
m_on_finish(on_finish) {
}
void RewatchRequest::send() {
unwatch();
}
void RewatchRequest::unwatch() {
ceph_assert(ceph_mutex_is_wlocked(m_watch_lock));
if (*m_watch_handle == 0) {
rewatch();
return;
}
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ldout(cct, 10) << dendl;
uint64_t watch_handle = 0;
std::swap(*m_watch_handle, watch_handle);
librados::AioCompletion *aio_comp = create_rados_callback<
RewatchRequest, &RewatchRequest::handle_unwatch>(this);
int r = m_ioctx.aio_unwatch(watch_handle, aio_comp);
ceph_assert(r == 0);
aio_comp->release();
}
void RewatchRequest::handle_unwatch(int r) {
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ldout(cct, 10) << "r=" << r << dendl;
if (r == -EBLOCKLISTED) {
lderr(cct) << "client blocklisted" << dendl;
finish(r);
return;
} else if (r < 0) {
lderr(cct) << "failed to unwatch: " << cpp_strerror(r) << dendl;
}
rewatch();
}
void RewatchRequest::rewatch() {
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ldout(cct, 10) << dendl;
librados::AioCompletion *aio_comp = create_rados_callback<
RewatchRequest, &RewatchRequest::handle_rewatch>(this);
int r = m_ioctx.aio_watch(m_oid, aio_comp, &m_rewatch_handle, m_watch_ctx);
ceph_assert(r == 0);
aio_comp->release();
}
void RewatchRequest::handle_rewatch(int r) {
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ldout(cct, 10) << "r=" << r << dendl;
if (r < 0) {
lderr(cct) << "failed to watch object: " << cpp_strerror(r)
<< dendl;
m_rewatch_handle = 0;
}
{
std::unique_lock watch_locker{m_watch_lock};
*m_watch_handle = m_rewatch_handle;
}
finish(r);
}
void RewatchRequest::finish(int r) {
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ldout(cct, 10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace watcher
} // namespace librbd
| 2,987 | 26.412844 | 79 |
cc
|
null |
ceph-main/src/librbd/watcher/RewatchRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_LIBRBD_WATCHER_REWATCH_REQUEST_H
#define CEPH_LIBRBD_WATCHER_REWATCH_REQUEST_H
#include "common/ceph_mutex.h"
#include "include/int_types.h"
#include "include/rados/librados.hpp"
struct Context;
namespace librbd {
namespace watcher {
class RewatchRequest {
public:
static RewatchRequest *create(librados::IoCtx& ioctx, const std::string& oid,
ceph::shared_mutex &watch_lock,
librados::WatchCtx2 *watch_ctx,
uint64_t *watch_handle, Context *on_finish) {
return new RewatchRequest(ioctx, oid, watch_lock, watch_ctx, watch_handle,
on_finish);
}
RewatchRequest(librados::IoCtx& ioctx, const std::string& oid,
ceph::shared_mutex &watch_lock, librados::WatchCtx2 *watch_ctx,
uint64_t *watch_handle, Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* UNWATCH
* |
* | . . . .
* | . . (recoverable error)
* v v .
* REWATCH . . .
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx& m_ioctx;
std::string m_oid;
ceph::shared_mutex &m_watch_lock;
librados::WatchCtx2 *m_watch_ctx;
uint64_t *m_watch_handle;
Context *m_on_finish;
uint64_t m_rewatch_handle = 0;
void unwatch();
void handle_unwatch(int r);
void rewatch();
void handle_rewatch(int r);
void finish(int r);
};
} // namespace watcher
} // namespace librbd
#endif // CEPH_LIBRBD_WATCHER_REWATCH_REQUEST_H
| 1,697 | 21.342105 | 80 |
h
|
null |
ceph-main/src/librbd/watcher/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "librbd/watcher/Types.h"
#include "common/Formatter.h"
namespace librbd {
namespace watcher {
void ClientId::encode(bufferlist &bl) const {
using ceph::encode;
encode(gid, bl);
encode(handle, bl);
}
void ClientId::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
decode(gid, iter);
decode(handle, iter);
}
void ClientId::dump(Formatter *f) const {
f->dump_unsigned("gid", gid);
f->dump_unsigned("handle", handle);
}
void NotifyResponse::encode(bufferlist& bl) const {
using ceph::encode;
encode(acks, bl);
encode(timeouts, bl);
}
void NotifyResponse::decode(bufferlist::const_iterator& iter) {
using ceph::decode;
decode(acks, iter);
decode(timeouts, iter);
}
std::ostream &operator<<(std::ostream &out,
const ClientId &client_id) {
out << "[" << client_id.gid << "," << client_id.handle << "]";
return out;
}
} // namespace watcher
} // namespace librbd
| 1,041 | 21.652174 | 70 |
cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.