repo
stringlengths 1
152
⌀ | file
stringlengths 15
205
| code
stringlengths 0
41.6M
| file_length
int64 0
41.6M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 90
values |
|---|---|---|---|---|---|---|
null |
ceph-main/src/tools/rbd_mirror/PoolMetaCache.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/debug.h"
#include "common/dout.h"
#include "tools/rbd_mirror/PoolMetaCache.h"
#include <shared_mutex>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::PoolMetaCache: " \
<< this << " " << __func__ << ": "
namespace rbd {
namespace mirror {
int PoolMetaCache::get_local_pool_meta(
int64_t pool_id,
LocalPoolMeta* local_pool_meta) const {
dout(15) << "pool_id=" << pool_id << dendl;
std::shared_lock locker{m_lock};
auto it = m_local_pool_metas.find(pool_id);
if (it == m_local_pool_metas.end()) {
return -ENOENT;
}
*local_pool_meta = it->second;
return 0;
}
void PoolMetaCache::set_local_pool_meta(
int64_t pool_id,
const LocalPoolMeta& local_pool_meta) {
dout(15) << "pool_id=" << pool_id << ", "
<< "local_pool_meta=" << local_pool_meta << dendl;
std::unique_lock locker(m_lock);
m_local_pool_metas[pool_id] = local_pool_meta;
}
void PoolMetaCache::remove_local_pool_meta(int64_t pool_id) {
dout(15) << "pool_id=" << pool_id << dendl;
std::unique_lock locker(m_lock);
m_local_pool_metas.erase(pool_id);
}
int PoolMetaCache::get_remote_pool_meta(
int64_t pool_id,
RemotePoolMeta* remote_pool_meta) const {
dout(15) << "pool_id=" << pool_id << dendl;
std::shared_lock locker{m_lock};
auto it = m_remote_pool_metas.find(pool_id);
if (it == m_remote_pool_metas.end()) {
return -ENOENT;
}
*remote_pool_meta = it->second;
return 0;
}
void PoolMetaCache::set_remote_pool_meta(
int64_t pool_id,
const RemotePoolMeta& remote_pool_meta) {
dout(15) << "pool_id=" << pool_id << ", "
<< "remote_pool_meta=" << remote_pool_meta << dendl;
std::unique_lock locker(m_lock);
m_remote_pool_metas[pool_id] = remote_pool_meta;
}
void PoolMetaCache::remove_remote_pool_meta(int64_t pool_id) {
dout(15) << "pool_id=" << pool_id << dendl;
std::unique_lock locker(m_lock);
m_remote_pool_metas.erase(pool_id);
}
} // namespace mirror
} // namespace rbd
| 2,195 | 25.142857 | 70 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/PoolMetaCache.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_POOL_META_CACHE_H
#define CEPH_RBD_MIRROR_POOL_META_CACHE_H
#include "include/int_types.h"
#include "common/ceph_mutex.h"
#include "tools/rbd_mirror/Types.h"
#include <map>
namespace rbd {
namespace mirror {
class PoolMetaCache {
public:
PoolMetaCache(CephContext* cct)
: m_cct(cct) {
}
PoolMetaCache(const PoolMetaCache&) = delete;
PoolMetaCache& operator=(const PoolMetaCache&) = delete;
int get_local_pool_meta(int64_t pool_id,
LocalPoolMeta* local_pool_meta) const;
void set_local_pool_meta(int64_t pool_id,
const LocalPoolMeta& local_pool_meta);
void remove_local_pool_meta(int64_t pool_id);
int get_remote_pool_meta(int64_t pool_id,
RemotePoolMeta* remote_pool_meta) const;
void set_remote_pool_meta(int64_t pool_id,
const RemotePoolMeta& remote_pool_meta);
void remove_remote_pool_meta(int64_t pool_id);
private:
CephContext* m_cct;
mutable ceph::shared_mutex m_lock =
ceph::make_shared_mutex("rbd::mirror::PoolMetaCache::m_lock");
std::map<int64_t, LocalPoolMeta> m_local_pool_metas;
std::map<int64_t, RemotePoolMeta> m_remote_pool_metas;
};
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_POOL_META_CACHE_H
| 1,411 | 28.416667 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/PoolReplayer.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "PoolReplayer.h"
#include "common/Cond.h"
#include "common/Formatter.h"
#include "common/admin_socket.h"
#include "common/ceph_argparse.h"
#include "common/code_environment.h"
#include "common/common_init.h"
#include "common/debug.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "global/global_context.h"
#include "librbd/api/Config.h"
#include "librbd/api/Namespace.h"
#include "PoolMetaCache.h"
#include "RemotePoolPoller.h"
#include "ServiceDaemon.h"
#include "Threads.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::PoolReplayer: " \
<< this << " " << __func__ << ": "
namespace rbd {
namespace mirror {
using ::operator<<;
namespace {
const std::string SERVICE_DAEMON_INSTANCE_ID_KEY("instance_id");
const std::string SERVICE_DAEMON_LEADER_KEY("leader");
const std::vector<std::string> UNIQUE_PEER_CONFIG_KEYS {
{"monmap", "mon_host", "mon_dns_srv_name", "key", "keyfile", "keyring"}};
template <typename I>
class PoolReplayerAdminSocketCommand {
public:
PoolReplayerAdminSocketCommand(PoolReplayer<I> *pool_replayer)
: pool_replayer(pool_replayer) {
}
virtual ~PoolReplayerAdminSocketCommand() {}
virtual int call(Formatter *f) = 0;
protected:
PoolReplayer<I> *pool_replayer;
};
template <typename I>
class StatusCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit StatusCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->print_status(f);
return 0;
}
};
template <typename I>
class StartCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit StartCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->start();
return 0;
}
};
template <typename I>
class StopCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit StopCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->stop(true);
return 0;
}
};
template <typename I>
class RestartCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit RestartCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->restart();
return 0;
}
};
template <typename I>
class FlushCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit FlushCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->flush();
return 0;
}
};
template <typename I>
class LeaderReleaseCommand : public PoolReplayerAdminSocketCommand<I> {
public:
explicit LeaderReleaseCommand(PoolReplayer<I> *pool_replayer)
: PoolReplayerAdminSocketCommand<I>(pool_replayer) {
}
int call(Formatter *f) override {
this->pool_replayer->release_leader();
return 0;
}
};
template <typename I>
class PoolReplayerAdminSocketHook : public AdminSocketHook {
public:
PoolReplayerAdminSocketHook(CephContext *cct, const std::string &name,
PoolReplayer<I> *pool_replayer)
: admin_socket(cct->get_admin_socket()) {
std::string command;
int r;
command = "rbd mirror status " + name;
r = admin_socket->register_command(command, this,
"get status for rbd mirror " + name);
if (r == 0) {
commands[command] = new StatusCommand<I>(pool_replayer);
}
command = "rbd mirror start " + name;
r = admin_socket->register_command(command, this,
"start rbd mirror " + name);
if (r == 0) {
commands[command] = new StartCommand<I>(pool_replayer);
}
command = "rbd mirror stop " + name;
r = admin_socket->register_command(command, this,
"stop rbd mirror " + name);
if (r == 0) {
commands[command] = new StopCommand<I>(pool_replayer);
}
command = "rbd mirror restart " + name;
r = admin_socket->register_command(command, this,
"restart rbd mirror " + name);
if (r == 0) {
commands[command] = new RestartCommand<I>(pool_replayer);
}
command = "rbd mirror flush " + name;
r = admin_socket->register_command(command, this,
"flush rbd mirror " + name);
if (r == 0) {
commands[command] = new FlushCommand<I>(pool_replayer);
}
command = "rbd mirror leader release " + name;
r = admin_socket->register_command(command, this,
"release rbd mirror leader " + name);
if (r == 0) {
commands[command] = new LeaderReleaseCommand<I>(pool_replayer);
}
}
~PoolReplayerAdminSocketHook() override {
(void)admin_socket->unregister_commands(this);
for (auto i = commands.begin(); i != commands.end(); ++i) {
delete i->second;
}
}
int call(std::string_view command, const cmdmap_t& cmdmap,
const bufferlist&,
Formatter *f,
std::ostream& ss,
bufferlist& out) override {
auto i = commands.find(command);
ceph_assert(i != commands.end());
return i->second->call(f);
}
private:
typedef std::map<std::string, PoolReplayerAdminSocketCommand<I>*,
std::less<>> Commands;
AdminSocket *admin_socket;
Commands commands;
};
} // anonymous namespace
template <typename I>
struct PoolReplayer<I>::RemotePoolPollerListener
: public remote_pool_poller::Listener {
PoolReplayer<I>* m_pool_replayer;
RemotePoolPollerListener(PoolReplayer<I>* pool_replayer)
: m_pool_replayer(pool_replayer) {
}
void handle_updated(const RemotePoolMeta& remote_pool_meta) override {
m_pool_replayer->handle_remote_pool_meta_updated(remote_pool_meta);
}
};
template <typename I>
PoolReplayer<I>::PoolReplayer(
Threads<I> *threads, ServiceDaemon<I> *service_daemon,
journal::CacheManagerHandler *cache_manager_handler,
PoolMetaCache* pool_meta_cache, int64_t local_pool_id,
const PeerSpec &peer, const std::vector<const char*> &args) :
m_threads(threads),
m_service_daemon(service_daemon),
m_cache_manager_handler(cache_manager_handler),
m_pool_meta_cache(pool_meta_cache),
m_local_pool_id(local_pool_id),
m_peer(peer),
m_args(args),
m_lock(ceph::make_mutex("rbd::mirror::PoolReplayer " + stringify(peer))),
m_pool_replayer_thread(this),
m_leader_listener(this) {
}
template <typename I>
PoolReplayer<I>::~PoolReplayer()
{
shut_down();
ceph_assert(m_asok_hook == nullptr);
}
template <typename I>
bool PoolReplayer<I>::is_blocklisted() const {
std::lock_guard locker{m_lock};
return m_blocklisted;
}
template <typename I>
bool PoolReplayer<I>::is_leader() const {
std::lock_guard locker{m_lock};
return m_leader_watcher && m_leader_watcher->is_leader();
}
template <typename I>
bool PoolReplayer<I>::is_running() const {
return m_pool_replayer_thread.is_started() && !m_stopping;
}
template <typename I>
void PoolReplayer<I>::init(const std::string& site_name) {
std::lock_guard locker{m_lock};
ceph_assert(!m_pool_replayer_thread.is_started());
// reset state
m_stopping = false;
m_blocklisted = false;
m_site_name = site_name;
dout(10) << "replaying for " << m_peer << dendl;
int r = init_rados(g_ceph_context->_conf->cluster,
g_ceph_context->_conf->name.to_str(),
"", "", "local cluster", &m_local_rados, false);
if (r < 0) {
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to connect to local cluster");
return;
}
r = init_rados(m_peer.cluster_name, m_peer.client_name,
m_peer.mon_host, m_peer.key,
std::string("remote peer ") + stringify(m_peer),
&m_remote_rados, true);
if (r < 0) {
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to connect to remote cluster");
return;
}
r = m_local_rados->ioctx_create2(m_local_pool_id, m_local_io_ctx);
if (r < 0) {
derr << "error accessing local pool " << m_local_pool_id << ": "
<< cpp_strerror(r) << dendl;
return;
}
auto cct = reinterpret_cast<CephContext *>(m_local_io_ctx.cct());
librbd::api::Config<I>::apply_pool_overrides(m_local_io_ctx, &cct->_conf);
r = librbd::cls_client::mirror_uuid_get(&m_local_io_ctx,
&m_local_mirror_uuid);
if (r < 0) {
derr << "failed to retrieve local mirror uuid from pool "
<< m_local_io_ctx.get_pool_name() << ": " << cpp_strerror(r) << dendl;
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to query local mirror uuid");
return;
}
r = m_remote_rados->ioctx_create(m_local_io_ctx.get_pool_name().c_str(),
m_remote_io_ctx);
if (r < 0) {
derr << "error accessing remote pool " << m_local_io_ctx.get_pool_name()
<< ": " << cpp_strerror(r) << dendl;
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_WARNING,
"unable to access remote pool");
return;
}
dout(10) << "connected to " << m_peer << dendl;
m_image_sync_throttler.reset(
Throttler<I>::create(cct, "rbd_mirror_concurrent_image_syncs"));
m_image_deletion_throttler.reset(
Throttler<I>::create(cct, "rbd_mirror_concurrent_image_deletions"));
m_remote_pool_poller_listener.reset(new RemotePoolPollerListener(this));
m_remote_pool_poller.reset(RemotePoolPoller<I>::create(
m_threads, m_remote_io_ctx, m_site_name, m_local_mirror_uuid,
*m_remote_pool_poller_listener));
C_SaferCond on_pool_poller_init;
m_remote_pool_poller->init(&on_pool_poller_init);
r = on_pool_poller_init.wait();
if (r < 0) {
derr << "failed to initialize remote pool poller: " << cpp_strerror(r)
<< dendl;
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to initialize remote pool poller");
m_remote_pool_poller.reset();
return;
}
ceph_assert(!m_remote_pool_meta.mirror_uuid.empty());
m_pool_meta_cache->set_remote_pool_meta(
m_remote_io_ctx.get_id(), m_remote_pool_meta);
m_pool_meta_cache->set_local_pool_meta(
m_local_io_ctx.get_id(), {m_local_mirror_uuid});
m_default_namespace_replayer.reset(NamespaceReplayer<I>::create(
"", m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_peer.uuid,
m_remote_pool_meta, m_threads, m_image_sync_throttler.get(),
m_image_deletion_throttler.get(), m_service_daemon,
m_cache_manager_handler, m_pool_meta_cache));
C_SaferCond on_init;
m_default_namespace_replayer->init(&on_init);
r = on_init.wait();
if (r < 0) {
derr << "error initializing default namespace replayer: " << cpp_strerror(r)
<< dendl;
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to initialize default namespace replayer");
m_default_namespace_replayer.reset();
return;
}
m_leader_watcher.reset(LeaderWatcher<I>::create(m_threads, m_local_io_ctx,
&m_leader_listener));
r = m_leader_watcher->init();
if (r < 0) {
derr << "error initializing leader watcher: " << cpp_strerror(r) << dendl;
m_callout_id = m_service_daemon->add_or_update_callout(
m_local_pool_id, m_callout_id, service_daemon::CALLOUT_LEVEL_ERROR,
"unable to initialize leader messenger object");
m_leader_watcher.reset();
return;
}
if (m_callout_id != service_daemon::CALLOUT_ID_NONE) {
m_service_daemon->remove_callout(m_local_pool_id, m_callout_id);
m_callout_id = service_daemon::CALLOUT_ID_NONE;
}
m_service_daemon->add_or_update_attribute(
m_local_io_ctx.get_id(), SERVICE_DAEMON_INSTANCE_ID_KEY,
stringify(m_local_io_ctx.get_instance_id()));
m_pool_replayer_thread.create("pool replayer");
}
template <typename I>
void PoolReplayer<I>::shut_down() {
dout(20) << dendl;
{
std::lock_guard l{m_lock};
m_stopping = true;
m_cond.notify_all();
}
if (m_pool_replayer_thread.is_started()) {
m_pool_replayer_thread.join();
}
if (m_leader_watcher) {
m_leader_watcher->shut_down();
}
m_leader_watcher.reset();
if (m_default_namespace_replayer) {
C_SaferCond on_shut_down;
m_default_namespace_replayer->shut_down(&on_shut_down);
on_shut_down.wait();
}
m_default_namespace_replayer.reset();
if (m_remote_pool_poller) {
C_SaferCond ctx;
m_remote_pool_poller->shut_down(&ctx);
ctx.wait();
m_pool_meta_cache->remove_remote_pool_meta(m_remote_io_ctx.get_id());
m_pool_meta_cache->remove_local_pool_meta(m_local_io_ctx.get_id());
}
m_remote_pool_poller.reset();
m_remote_pool_poller_listener.reset();
m_image_sync_throttler.reset();
m_image_deletion_throttler.reset();
m_local_rados.reset();
m_remote_rados.reset();
}
template <typename I>
int PoolReplayer<I>::init_rados(const std::string &cluster_name,
const std::string &client_name,
const std::string &mon_host,
const std::string &key,
const std::string &description,
RadosRef *rados_ref,
bool strip_cluster_overrides) {
dout(10) << "cluster_name=" << cluster_name << ", client_name=" << client_name
<< ", mon_host=" << mon_host << ", strip_cluster_overrides="
<< strip_cluster_overrides << dendl;
// NOTE: manually bootstrap a CephContext here instead of via
// the librados API to avoid mixing global singletons between
// the librados shared library and the daemon
// TODO: eliminate intermingling of global singletons within Ceph APIs
CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT);
if (client_name.empty() || !iparams.name.from_str(client_name)) {
derr << "error initializing cluster handle for " << description << dendl;
return -EINVAL;
}
CephContext *cct = common_preinit(iparams, CODE_ENVIRONMENT_LIBRARY,
CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
cct->_conf->cluster = cluster_name;
// librados::Rados::conf_read_file
int r = cct->_conf.parse_config_files(nullptr, nullptr, 0);
if (r < 0 && r != -ENOENT) {
// do not treat this as fatal, it might still be able to connect
derr << "could not read ceph conf for " << description << ": "
<< cpp_strerror(r) << dendl;
}
// preserve cluster-specific config settings before applying environment/cli
// overrides
std::map<std::string, std::string> config_values;
if (strip_cluster_overrides) {
// remote peer connections shouldn't apply cluster-specific
// configuration settings
for (auto& key : UNIQUE_PEER_CONFIG_KEYS) {
config_values[key] = cct->_conf.get_val<std::string>(key);
}
}
cct->_conf.parse_env(cct->get_module_type());
// librados::Rados::conf_parse_env
std::vector<const char*> args;
r = cct->_conf.parse_argv(args);
if (r < 0) {
derr << "could not parse environment for " << description << ":"
<< cpp_strerror(r) << dendl;
cct->put();
return r;
}
cct->_conf.parse_env(cct->get_module_type());
if (!m_args.empty()) {
// librados::Rados::conf_parse_argv
args = m_args;
r = cct->_conf.parse_argv(args);
if (r < 0) {
derr << "could not parse command line args for " << description << ": "
<< cpp_strerror(r) << dendl;
cct->put();
return r;
}
}
if (strip_cluster_overrides) {
// remote peer connections shouldn't apply cluster-specific
// configuration settings
for (auto& pair : config_values) {
auto value = cct->_conf.get_val<std::string>(pair.first);
if (pair.second != value) {
dout(0) << "reverting global config option override: "
<< pair.first << ": " << value << " -> " << pair.second
<< dendl;
cct->_conf.set_val_or_die(pair.first, pair.second);
}
}
}
if (!g_ceph_context->_conf->admin_socket.empty()) {
cct->_conf.set_val_or_die("admin_socket",
"$run_dir/$name.$pid.$cluster.$cctid.asok");
}
if (!mon_host.empty()) {
r = cct->_conf.set_val("mon_host", mon_host);
if (r < 0) {
derr << "failed to set mon_host config for " << description << ": "
<< cpp_strerror(r) << dendl;
cct->put();
return r;
}
}
if (!key.empty()) {
r = cct->_conf.set_val("key", key);
if (r < 0) {
derr << "failed to set key config for " << description << ": "
<< cpp_strerror(r) << dendl;
cct->put();
return r;
}
}
// disable unnecessary librbd cache
cct->_conf.set_val_or_die("rbd_cache", "false");
cct->_conf.apply_changes(nullptr);
cct->_conf.complain_about_parse_error(cct);
rados_ref->reset(new librados::Rados());
r = (*rados_ref)->init_with_context(cct);
ceph_assert(r == 0);
cct->put();
r = (*rados_ref)->connect();
if (r < 0) {
derr << "error connecting to " << description << ": "
<< cpp_strerror(r) << dendl;
return r;
}
return 0;
}
template <typename I>
void PoolReplayer<I>::run() {
dout(20) << dendl;
while (true) {
std::string asok_hook_name = m_local_io_ctx.get_pool_name() + " " +
m_peer.cluster_name;
if (m_asok_hook_name != asok_hook_name || m_asok_hook == nullptr) {
m_asok_hook_name = asok_hook_name;
delete m_asok_hook;
m_asok_hook = new PoolReplayerAdminSocketHook<I>(g_ceph_context,
m_asok_hook_name, this);
}
with_namespace_replayers([this]() { update_namespace_replayers(); });
std::unique_lock locker{m_lock};
if (m_leader_watcher->is_blocklisted() ||
m_default_namespace_replayer->is_blocklisted()) {
m_blocklisted = true;
m_stopping = true;
}
for (auto &it : m_namespace_replayers) {
if (it.second->is_blocklisted()) {
m_blocklisted = true;
m_stopping = true;
break;
}
}
if (m_stopping) {
break;
}
auto seconds = g_ceph_context->_conf.get_val<uint64_t>(
"rbd_mirror_pool_replayers_refresh_interval");
m_cond.wait_for(locker, ceph::make_timespan(seconds));
}
// shut down namespace replayers
with_namespace_replayers([this]() { update_namespace_replayers(); });
delete m_asok_hook;
m_asok_hook = nullptr;
}
template <typename I>
void PoolReplayer<I>::update_namespace_replayers() {
dout(20) << dendl;
ceph_assert(ceph_mutex_is_locked(m_lock));
std::set<std::string> mirroring_namespaces;
if (!m_stopping) {
int r = list_mirroring_namespaces(&mirroring_namespaces);
if (r < 0) {
return;
}
}
auto cct = reinterpret_cast<CephContext *>(m_local_io_ctx.cct());
C_SaferCond cond;
auto gather_ctx = new C_Gather(cct, &cond);
for (auto it = m_namespace_replayers.begin();
it != m_namespace_replayers.end(); ) {
auto iter = mirroring_namespaces.find(it->first);
if (iter == mirroring_namespaces.end()) {
auto namespace_replayer = it->second;
auto on_shut_down = new LambdaContext(
[namespace_replayer, ctx=gather_ctx->new_sub()](int r) {
delete namespace_replayer;
ctx->complete(r);
});
m_service_daemon->remove_namespace(m_local_pool_id, it->first);
namespace_replayer->shut_down(on_shut_down);
it = m_namespace_replayers.erase(it);
} else {
mirroring_namespaces.erase(iter);
it++;
}
}
for (auto &name : mirroring_namespaces) {
auto namespace_replayer = NamespaceReplayer<I>::create(
name, m_local_io_ctx, m_remote_io_ctx, m_local_mirror_uuid, m_peer.uuid,
m_remote_pool_meta, m_threads, m_image_sync_throttler.get(),
m_image_deletion_throttler.get(), m_service_daemon,
m_cache_manager_handler, m_pool_meta_cache);
auto on_init = new LambdaContext(
[this, namespace_replayer, name, &mirroring_namespaces,
ctx=gather_ctx->new_sub()](int r) {
std::lock_guard locker{m_lock};
if (r < 0) {
derr << "failed to initialize namespace replayer for namespace "
<< name << ": " << cpp_strerror(r) << dendl;
delete namespace_replayer;
mirroring_namespaces.erase(name);
} else {
m_namespace_replayers[name] = namespace_replayer;
m_service_daemon->add_namespace(m_local_pool_id, name);
}
ctx->complete(r);
});
namespace_replayer->init(on_init);
}
gather_ctx->activate();
m_lock.unlock();
cond.wait();
m_lock.lock();
if (m_leader) {
C_SaferCond acquire_cond;
auto acquire_gather_ctx = new C_Gather(cct, &acquire_cond);
for (auto &name : mirroring_namespaces) {
namespace_replayer_acquire_leader(name, acquire_gather_ctx->new_sub());
}
acquire_gather_ctx->activate();
m_lock.unlock();
acquire_cond.wait();
m_lock.lock();
std::vector<std::string> instance_ids;
m_leader_watcher->list_instances(&instance_ids);
for (auto &name : mirroring_namespaces) {
auto it = m_namespace_replayers.find(name);
if (it == m_namespace_replayers.end()) {
// acquire leader for this namespace replayer failed
continue;
}
it->second->handle_instances_added(instance_ids);
}
} else {
std::string leader_instance_id;
if (m_leader_watcher->get_leader_instance_id(&leader_instance_id)) {
for (auto &name : mirroring_namespaces) {
m_namespace_replayers[name]->handle_update_leader(leader_instance_id);
}
}
}
}
template <typename I>
int PoolReplayer<I>::list_mirroring_namespaces(
std::set<std::string> *namespaces) {
dout(20) << dendl;
ceph_assert(ceph_mutex_is_locked(m_lock));
std::vector<std::string> names;
int r = librbd::api::Namespace<I>::list(m_local_io_ctx, &names);
if (r < 0) {
derr << "failed to list namespaces: " << cpp_strerror(r) << dendl;
return r;
}
for (auto &name : names) {
cls::rbd::MirrorMode mirror_mode = cls::rbd::MIRROR_MODE_DISABLED;
int r = librbd::cls_client::mirror_mode_get(&m_local_io_ctx, &mirror_mode);
if (r < 0 && r != -ENOENT) {
derr << "failed to get namespace mirror mode: " << cpp_strerror(r)
<< dendl;
if (m_namespace_replayers.count(name) == 0) {
continue;
}
} else if (mirror_mode == cls::rbd::MIRROR_MODE_DISABLED) {
dout(10) << "mirroring is disabled for namespace " << name << dendl;
continue;
}
namespaces->insert(name);
}
return 0;
}
template <typename I>
void PoolReplayer<I>::reopen_logs()
{
dout(20) << dendl;
std::lock_guard locker{m_lock};
if (m_local_rados) {
reinterpret_cast<CephContext *>(m_local_rados->cct())->reopen_logs();
}
if (m_remote_rados) {
reinterpret_cast<CephContext *>(m_remote_rados->cct())->reopen_logs();
}
}
template <typename I>
void PoolReplayer<I>::namespace_replayer_acquire_leader(const std::string &name,
Context *on_finish) {
dout(20) << dendl;
ceph_assert(ceph_mutex_is_locked(m_lock));
auto it = m_namespace_replayers.find(name);
ceph_assert(it != m_namespace_replayers.end());
on_finish = new LambdaContext(
[this, name, on_finish](int r) {
if (r < 0) {
derr << "failed to handle acquire leader for namespace: "
<< name << ": " << cpp_strerror(r) << dendl;
// remove the namespace replayer -- update_namespace_replayers will
// retry to create it and acquire leader.
std::lock_guard locker{m_lock};
auto namespace_replayer = m_namespace_replayers[name];
m_namespace_replayers.erase(name);
auto on_shut_down = new LambdaContext(
[namespace_replayer, on_finish](int r) {
delete namespace_replayer;
on_finish->complete(r);
});
m_service_daemon->remove_namespace(m_local_pool_id, name);
namespace_replayer->shut_down(on_shut_down);
return;
}
on_finish->complete(0);
});
it->second->handle_acquire_leader(on_finish);
}
template <typename I>
void PoolReplayer<I>::print_status(Formatter *f) {
dout(20) << dendl;
assert(f);
std::lock_guard l{m_lock};
f->open_object_section("pool_replayer_status");
f->dump_stream("peer") << m_peer;
if (m_local_io_ctx.is_valid()) {
f->dump_string("pool", m_local_io_ctx.get_pool_name());
f->dump_stream("instance_id") << m_local_io_ctx.get_instance_id();
}
std::string state("running");
if (m_manual_stop) {
state = "stopped (manual)";
} else if (m_stopping) {
state = "stopped";
} else if (!is_running()) {
state = "error";
}
f->dump_string("state", state);
if (m_leader_watcher) {
std::string leader_instance_id;
m_leader_watcher->get_leader_instance_id(&leader_instance_id);
f->dump_string("leader_instance_id", leader_instance_id);
bool leader = m_leader_watcher->is_leader();
f->dump_bool("leader", leader);
if (leader) {
std::vector<std::string> instance_ids;
m_leader_watcher->list_instances(&instance_ids);
f->open_array_section("instances");
for (auto instance_id : instance_ids) {
f->dump_string("instance_id", instance_id);
}
f->close_section(); // instances
}
}
if (m_local_rados) {
auto cct = reinterpret_cast<CephContext *>(m_local_rados->cct());
f->dump_string("local_cluster_admin_socket",
cct->_conf.get_val<std::string>("admin_socket"));
}
if (m_remote_rados) {
auto cct = reinterpret_cast<CephContext *>(m_remote_rados->cct());
f->dump_string("remote_cluster_admin_socket",
cct->_conf.get_val<std::string>("admin_socket"));
}
if (m_image_sync_throttler) {
f->open_object_section("sync_throttler");
m_image_sync_throttler->print_status(f);
f->close_section(); // sync_throttler
}
if (m_image_deletion_throttler) {
f->open_object_section("deletion_throttler");
m_image_deletion_throttler->print_status(f);
f->close_section(); // deletion_throttler
}
if (m_default_namespace_replayer) {
m_default_namespace_replayer->print_status(f);
}
f->open_array_section("namespaces");
for (auto &it : m_namespace_replayers) {
f->open_object_section("namespace");
f->dump_string("name", it.first);
it.second->print_status(f);
f->close_section(); // namespace
}
f->close_section(); // namespaces
f->close_section(); // pool_replayer_status
}
template <typename I>
void PoolReplayer<I>::start() {
dout(20) << dendl;
std::lock_guard l{m_lock};
if (m_stopping) {
return;
}
m_manual_stop = false;
if (m_default_namespace_replayer) {
m_default_namespace_replayer->start();
}
for (auto &it : m_namespace_replayers) {
it.second->start();
}
}
template <typename I>
void PoolReplayer<I>::stop(bool manual) {
dout(20) << "enter: manual=" << manual << dendl;
std::lock_guard l{m_lock};
if (!manual) {
m_stopping = true;
m_cond.notify_all();
return;
} else if (m_stopping) {
return;
}
m_manual_stop = true;
if (m_default_namespace_replayer) {
m_default_namespace_replayer->stop();
}
for (auto &it : m_namespace_replayers) {
it.second->stop();
}
}
template <typename I>
void PoolReplayer<I>::restart() {
dout(20) << dendl;
std::lock_guard l{m_lock};
if (m_stopping) {
return;
}
if (m_default_namespace_replayer) {
m_default_namespace_replayer->restart();
}
for (auto &it : m_namespace_replayers) {
it.second->restart();
}
}
template <typename I>
void PoolReplayer<I>::flush() {
dout(20) << dendl;
std::lock_guard l{m_lock};
if (m_stopping || m_manual_stop) {
return;
}
if (m_default_namespace_replayer) {
m_default_namespace_replayer->flush();
}
for (auto &it : m_namespace_replayers) {
it.second->flush();
}
}
template <typename I>
void PoolReplayer<I>::release_leader() {
dout(20) << dendl;
std::lock_guard l{m_lock};
if (m_stopping || !m_leader_watcher) {
return;
}
m_leader_watcher->release_leader();
}
template <typename I>
void PoolReplayer<I>::handle_post_acquire_leader(Context *on_finish) {
dout(20) << dendl;
with_namespace_replayers(
[this](Context *on_finish) {
dout(10) << "handle_post_acquire_leader" << dendl;
ceph_assert(ceph_mutex_is_locked(m_lock));
m_service_daemon->add_or_update_attribute(m_local_pool_id,
SERVICE_DAEMON_LEADER_KEY,
true);
auto ctx = new LambdaContext(
[this, on_finish](int r) {
if (r == 0) {
std::lock_guard locker{m_lock};
m_leader = true;
}
on_finish->complete(r);
});
auto cct = reinterpret_cast<CephContext *>(m_local_io_ctx.cct());
auto gather_ctx = new C_Gather(cct, ctx);
m_default_namespace_replayer->handle_acquire_leader(
gather_ctx->new_sub());
for (auto &it : m_namespace_replayers) {
namespace_replayer_acquire_leader(it.first, gather_ctx->new_sub());
}
gather_ctx->activate();
}, on_finish);
}
template <typename I>
void PoolReplayer<I>::handle_pre_release_leader(Context *on_finish) {
dout(20) << dendl;
with_namespace_replayers(
[this](Context *on_finish) {
dout(10) << "handle_pre_release_leader" << dendl;
ceph_assert(ceph_mutex_is_locked(m_lock));
m_leader = false;
m_service_daemon->remove_attribute(m_local_pool_id,
SERVICE_DAEMON_LEADER_KEY);
auto cct = reinterpret_cast<CephContext *>(m_local_io_ctx.cct());
auto gather_ctx = new C_Gather(cct, on_finish);
m_default_namespace_replayer->handle_release_leader(
gather_ctx->new_sub());
for (auto &it : m_namespace_replayers) {
it.second->handle_release_leader(gather_ctx->new_sub());
}
gather_ctx->activate();
}, on_finish);
}
template <typename I>
void PoolReplayer<I>::handle_update_leader(
const std::string &leader_instance_id) {
dout(10) << "leader_instance_id=" << leader_instance_id << dendl;
std::lock_guard locker{m_lock};
m_default_namespace_replayer->handle_update_leader(leader_instance_id);
for (auto &it : m_namespace_replayers) {
it.second->handle_update_leader(leader_instance_id);
}
}
template <typename I>
void PoolReplayer<I>::handle_instances_added(
const std::vector<std::string> &instance_ids) {
dout(5) << "instance_ids=" << instance_ids << dendl;
std::lock_guard locker{m_lock};
if (!m_leader_watcher->is_leader()) {
return;
}
m_default_namespace_replayer->handle_instances_added(instance_ids);
for (auto &it : m_namespace_replayers) {
it.second->handle_instances_added(instance_ids);
}
}
template <typename I>
void PoolReplayer<I>::handle_instances_removed(
const std::vector<std::string> &instance_ids) {
dout(5) << "instance_ids=" << instance_ids << dendl;
std::lock_guard locker{m_lock};
if (!m_leader_watcher->is_leader()) {
return;
}
m_default_namespace_replayer->handle_instances_removed(instance_ids);
for (auto &it : m_namespace_replayers) {
it.second->handle_instances_removed(instance_ids);
}
}
template <typename I>
void PoolReplayer<I>::handle_remote_pool_meta_updated(
const RemotePoolMeta& remote_pool_meta) {
dout(5) << "remote_pool_meta=" << remote_pool_meta << dendl;
if (!m_default_namespace_replayer) {
m_remote_pool_meta = remote_pool_meta;
return;
}
derr << "remote pool metadata updated unexpectedly" << dendl;
std::unique_lock locker{m_lock};
m_stopping = true;
m_cond.notify_all();
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::PoolReplayer<librbd::ImageCtx>;
| 32,868 | 28.373548 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/PoolReplayer.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_POOL_REPLAYER_H
#define CEPH_RBD_MIRROR_POOL_REPLAYER_H
#include "common/Cond.h"
#include "common/ceph_mutex.h"
#include "include/rados/librados.hpp"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "tools/rbd_mirror/LeaderWatcher.h"
#include "tools/rbd_mirror/NamespaceReplayer.h"
#include "tools/rbd_mirror/Throttler.h"
#include "tools/rbd_mirror/Types.h"
#include "tools/rbd_mirror/leader_watcher/Types.h"
#include "tools/rbd_mirror/service_daemon/Types.h"
#include <map>
#include <memory>
#include <string>
#include <vector>
class AdminSocketHook;
namespace journal { struct CacheManagerHandler; }
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
template <typename> class RemotePoolPoller;
namespace remote_pool_poller { struct Listener; }
struct PoolMetaCache;
template <typename> class ServiceDaemon;
template <typename> struct Threads;
/**
* Controls mirroring for a single remote cluster.
*/
template <typename ImageCtxT = librbd::ImageCtx>
class PoolReplayer {
public:
PoolReplayer(Threads<ImageCtxT> *threads,
ServiceDaemon<ImageCtxT> *service_daemon,
journal::CacheManagerHandler *cache_manager_handler,
PoolMetaCache* pool_meta_cache,
int64_t local_pool_id, const PeerSpec &peer,
const std::vector<const char*> &args);
~PoolReplayer();
PoolReplayer(const PoolReplayer&) = delete;
PoolReplayer& operator=(const PoolReplayer&) = delete;
bool is_blocklisted() const;
bool is_leader() const;
bool is_running() const;
void init(const std::string& site_name);
void shut_down();
void run();
void print_status(Formatter *f);
void start();
void stop(bool manual);
void restart();
void flush();
void release_leader();
void reopen_logs();
private:
/**
* @verbatim
*
* <start>
* |
* v
* INIT
* |
* v
* <follower> <---------------------\
* . |
* . (leader acquired) |
* v |
* NOTIFY_NAMESPACE_WATCHERS NOTIFY_NAMESPACE_WATCHERS
* | ^
* v .
* <leader> .
* . .
* . (leader lost / shut down) .
* . . . . . . . . . . . . . . . .
*
* @endverbatim
*/
struct RemotePoolPollerListener;
int init_rados(const std::string &cluster_name,
const std::string &client_name,
const std::string &mon_host,
const std::string &key,
const std::string &description, RadosRef *rados_ref,
bool strip_cluster_overrides);
void update_namespace_replayers();
int list_mirroring_namespaces(std::set<std::string> *namespaces);
void namespace_replayer_acquire_leader(const std::string &name,
Context *on_finish);
void handle_post_acquire_leader(Context *on_finish);
void handle_pre_release_leader(Context *on_finish);
void handle_update_leader(const std::string &leader_instance_id);
void handle_instances_added(const std::vector<std::string> &instance_ids);
void handle_instances_removed(const std::vector<std::string> &instance_ids);
// sync version, executed in the caller thread
template <typename L>
void with_namespace_replayers(L &&callback) {
std::lock_guard locker{m_lock};
if (m_namespace_replayers_locked) {
ceph_assert(m_on_namespace_replayers_unlocked == nullptr);
C_SaferCond cond;
m_on_namespace_replayers_unlocked = &cond;
m_lock.unlock();
cond.wait();
m_lock.lock();
} else {
m_namespace_replayers_locked = true;
}
ceph_assert(m_namespace_replayers_locked);
callback(); // may temporary release the lock
ceph_assert(m_namespace_replayers_locked);
if (m_on_namespace_replayers_unlocked == nullptr) {
m_namespace_replayers_locked = false;
return;
}
m_threads->work_queue->queue(m_on_namespace_replayers_unlocked);
m_on_namespace_replayers_unlocked = nullptr;
}
// async version
template <typename L>
void with_namespace_replayers(L &&callback, Context *on_finish) {
std::lock_guard locker{m_lock};
on_finish = librbd::util::create_async_context_callback(
m_threads->work_queue, new LambdaContext(
[this, on_finish](int r) {
{
std::lock_guard locker{m_lock};
ceph_assert(m_namespace_replayers_locked);
m_namespace_replayers_locked = false;
if (m_on_namespace_replayers_unlocked != nullptr) {
m_namespace_replayers_locked = true;
m_threads->work_queue->queue(m_on_namespace_replayers_unlocked);
m_on_namespace_replayers_unlocked = nullptr;
}
}
on_finish->complete(r);
}));
auto on_lock = new LambdaContext(
[this, callback, on_finish](int) {
std::lock_guard locker{m_lock};
ceph_assert(m_namespace_replayers_locked);
callback(on_finish);
});
if (m_namespace_replayers_locked) {
ceph_assert(m_on_namespace_replayers_unlocked == nullptr);
m_on_namespace_replayers_unlocked = on_lock;
return;
}
m_namespace_replayers_locked = true;
m_threads->work_queue->queue(on_lock);
}
void handle_remote_pool_meta_updated(const RemotePoolMeta& remote_pool_meta);
Threads<ImageCtxT> *m_threads;
ServiceDaemon<ImageCtxT> *m_service_daemon;
journal::CacheManagerHandler *m_cache_manager_handler;
PoolMetaCache* m_pool_meta_cache;
int64_t m_local_pool_id = -1;
PeerSpec m_peer;
std::vector<const char*> m_args;
mutable ceph::mutex m_lock;
ceph::condition_variable m_cond;
std::string m_site_name;
bool m_stopping = false;
bool m_manual_stop = false;
bool m_blocklisted = false;
RadosRef m_local_rados;
RadosRef m_remote_rados;
librados::IoCtx m_local_io_ctx;
librados::IoCtx m_remote_io_ctx;
std::string m_local_mirror_uuid;
RemotePoolMeta m_remote_pool_meta;
std::unique_ptr<remote_pool_poller::Listener> m_remote_pool_poller_listener;
std::unique_ptr<RemotePoolPoller<ImageCtxT>> m_remote_pool_poller;
std::unique_ptr<NamespaceReplayer<ImageCtxT>> m_default_namespace_replayer;
std::map<std::string, NamespaceReplayer<ImageCtxT> *> m_namespace_replayers;
std::string m_asok_hook_name;
AdminSocketHook *m_asok_hook = nullptr;
service_daemon::CalloutId m_callout_id = service_daemon::CALLOUT_ID_NONE;
bool m_leader = false;
bool m_namespace_replayers_locked = false;
Context *m_on_namespace_replayers_unlocked = nullptr;
class PoolReplayerThread : public Thread {
PoolReplayer *m_pool_replayer;
public:
PoolReplayerThread(PoolReplayer *pool_replayer)
: m_pool_replayer(pool_replayer) {
}
void *entry() override {
m_pool_replayer->run();
return 0;
}
} m_pool_replayer_thread;
class LeaderListener : public leader_watcher::Listener {
public:
LeaderListener(PoolReplayer *pool_replayer)
: m_pool_replayer(pool_replayer) {
}
protected:
void post_acquire_handler(Context *on_finish) override {
m_pool_replayer->handle_post_acquire_leader(on_finish);
}
void pre_release_handler(Context *on_finish) override {
m_pool_replayer->handle_pre_release_leader(on_finish);
}
void update_leader_handler(
const std::string &leader_instance_id) override {
m_pool_replayer->handle_update_leader(leader_instance_id);
}
void handle_instances_added(const InstanceIds& instance_ids) override {
m_pool_replayer->handle_instances_added(instance_ids);
}
void handle_instances_removed(const InstanceIds& instance_ids) override {
m_pool_replayer->handle_instances_removed(instance_ids);
}
private:
PoolReplayer *m_pool_replayer;
} m_leader_listener;
std::unique_ptr<LeaderWatcher<ImageCtxT>> m_leader_watcher;
std::unique_ptr<Throttler<ImageCtxT>> m_image_sync_throttler;
std::unique_ptr<Throttler<ImageCtxT>> m_image_deletion_throttler;
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::PoolReplayer<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_POOL_REPLAYER_H
| 8,480 | 28.346021 | 80 |
h
|
null |
ceph-main/src/tools/rbd_mirror/PoolWatcher.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/PoolWatcher.h"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/Timer.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/MirroringWatcher.h"
#include "librbd/Utils.h"
#include "librbd/api/Image.h"
#include "librbd/api/Mirror.h"
#include "librbd/asio/ContextWQ.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/pool_watcher/RefreshImagesRequest.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::PoolWatcher: " << this << " " \
<< __func__ << ": "
using std::list;
using std::string;
using std::unique_ptr;
using std::vector;
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
namespace rbd {
namespace mirror {
template <typename I>
class PoolWatcher<I>::MirroringWatcher : public librbd::MirroringWatcher<I> {
public:
using ContextWQ = typename std::decay<
typename std::remove_pointer<
decltype(Threads<I>::work_queue)>::type>::type;
MirroringWatcher(librados::IoCtx &io_ctx, ContextWQ *work_queue,
PoolWatcher *pool_watcher)
: librbd::MirroringWatcher<I>(io_ctx, work_queue),
m_pool_watcher(pool_watcher) {
}
void handle_rewatch_complete(int r) override {
m_pool_watcher->handle_rewatch_complete(r);
}
void handle_mode_updated(cls::rbd::MirrorMode mirror_mode) override {
// invalidate all image state and refresh the pool contents
m_pool_watcher->schedule_refresh_images(5);
}
void handle_image_updated(cls::rbd::MirrorImageState state,
const std::string &image_id,
const std::string &global_image_id) override {
bool enabled = (state == cls::rbd::MIRROR_IMAGE_STATE_ENABLED);
m_pool_watcher->handle_image_updated(image_id, global_image_id,
enabled);
}
private:
PoolWatcher *m_pool_watcher;
};
template <typename I>
PoolWatcher<I>::PoolWatcher(Threads<I> *threads,
librados::IoCtx &io_ctx,
const std::string& mirror_uuid,
pool_watcher::Listener &listener)
: m_threads(threads),
m_io_ctx(io_ctx),
m_mirror_uuid(mirror_uuid),
m_listener(listener),
m_lock(ceph::make_mutex(librbd::util::unique_lock_name(
"rbd::mirror::PoolWatcher", this))) {
m_mirroring_watcher = new MirroringWatcher(m_io_ctx,
m_threads->work_queue, this);
}
template <typename I>
PoolWatcher<I>::~PoolWatcher() {
delete m_mirroring_watcher;
}
template <typename I>
bool PoolWatcher<I>::is_blocklisted() const {
std::lock_guard locker{m_lock};
return m_blocklisted;
}
template <typename I>
void PoolWatcher<I>::init(Context *on_finish) {
dout(5) << dendl;
{
std::lock_guard locker{m_lock};
m_on_init_finish = on_finish;
ceph_assert(!m_refresh_in_progress);
m_refresh_in_progress = true;
}
// start async updates for mirror image directory
register_watcher();
}
template <typename I>
void PoolWatcher<I>::shut_down(Context *on_finish) {
dout(5) << dendl;
{
std::scoped_lock locker{m_threads->timer_lock, m_lock};
ceph_assert(!m_shutting_down);
m_shutting_down = true;
if (m_timer_ctx != nullptr) {
m_threads->timer->cancel_event(m_timer_ctx);
m_timer_ctx = nullptr;
}
}
// in-progress unregister tracked as async op
unregister_watcher();
m_async_op_tracker.wait_for_ops(on_finish);
}
template <typename I>
void PoolWatcher<I>::register_watcher() {
{
std::lock_guard locker{m_lock};
ceph_assert(m_image_ids_invalid);
ceph_assert(m_refresh_in_progress);
}
// if the watch registration is in-flight, let the watcher
// handle the transition -- only (re-)register if it's not registered
if (!m_mirroring_watcher->is_unregistered()) {
refresh_images();
return;
}
// first time registering or the watch failed
dout(5) << dendl;
m_async_op_tracker.start_op();
Context *ctx = create_context_callback<
PoolWatcher, &PoolWatcher<I>::handle_register_watcher>(this);
m_mirroring_watcher->register_watch(ctx);
}
template <typename I>
void PoolWatcher<I>::handle_register_watcher(int r) {
dout(5) << "r=" << r << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_image_ids_invalid);
ceph_assert(m_refresh_in_progress);
if (r < 0) {
m_refresh_in_progress = false;
}
}
Context *on_init_finish = nullptr;
if (r >= 0) {
refresh_images();
} else if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted" << dendl;
std::lock_guard locker{m_lock};
m_blocklisted = true;
std::swap(on_init_finish, m_on_init_finish);
} else if (r == -ENOENT) {
dout(5) << "mirroring directory does not exist" << dendl;
{
std::lock_guard locker{m_lock};
std::swap(on_init_finish, m_on_init_finish);
}
schedule_refresh_images(30);
} else {
derr << "unexpected error registering mirroring directory watch: "
<< cpp_strerror(r) << dendl;
schedule_refresh_images(10);
}
m_async_op_tracker.finish_op();
if (on_init_finish != nullptr) {
on_init_finish->complete(r);
}
}
template <typename I>
void PoolWatcher<I>::unregister_watcher() {
dout(5) << dendl;
m_async_op_tracker.start_op();
Context *ctx = new LambdaContext([this](int r) {
dout(5) << "unregister_watcher: r=" << r << dendl;
if (r < 0) {
derr << "error unregistering watcher for "
<< m_mirroring_watcher->get_oid() << " object: " << cpp_strerror(r)
<< dendl;
}
m_async_op_tracker.finish_op();
});
m_mirroring_watcher->unregister_watch(ctx);
}
template <typename I>
void PoolWatcher<I>::refresh_images() {
dout(5) << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_image_ids_invalid);
ceph_assert(m_refresh_in_progress);
// clear all pending notification events since we need to perform
// a full image list refresh
m_pending_added_image_ids.clear();
m_pending_removed_image_ids.clear();
}
m_async_op_tracker.start_op();
m_refresh_image_ids.clear();
Context *ctx = create_context_callback<
PoolWatcher, &PoolWatcher<I>::handle_refresh_images>(this);
auto req = pool_watcher::RefreshImagesRequest<I>::create(m_io_ctx,
&m_refresh_image_ids,
ctx);
req->send();
}
template <typename I>
void PoolWatcher<I>::handle_refresh_images(int r) {
dout(5) << "r=" << r << dendl;
bool deferred_refresh = false;
bool retry_refresh = false;
Context *on_init_finish = nullptr;
{
std::lock_guard locker{m_lock};
ceph_assert(m_image_ids_invalid);
ceph_assert(m_refresh_in_progress);
m_refresh_in_progress = false;
if (r == -ENOENT) {
dout(5) << "mirroring directory not found" << dendl;
r = 0;
m_refresh_image_ids.clear();
}
if (m_deferred_refresh) {
// need to refresh -- skip the notification
deferred_refresh = true;
} else if (r >= 0) {
m_pending_image_ids = std::move(m_refresh_image_ids);
m_image_ids_invalid = false;
std::swap(on_init_finish, m_on_init_finish);
schedule_listener();
} else if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted during image refresh" << dendl;
m_blocklisted = true;
std::swap(on_init_finish, m_on_init_finish);
} else {
retry_refresh = true;
}
}
if (deferred_refresh) {
dout(5) << "scheduling deferred refresh" << dendl;
schedule_refresh_images(0);
} else if (retry_refresh) {
derr << "failed to retrieve mirroring directory: " << cpp_strerror(r)
<< dendl;
schedule_refresh_images(10);
}
m_async_op_tracker.finish_op();
if (on_init_finish != nullptr) {
on_init_finish->complete(r);
}
}
template <typename I>
void PoolWatcher<I>::schedule_refresh_images(double interval) {
std::scoped_lock locker{m_threads->timer_lock, m_lock};
if (m_shutting_down || m_refresh_in_progress || m_timer_ctx != nullptr) {
if (m_refresh_in_progress && !m_deferred_refresh) {
dout(5) << "deferring refresh until in-flight refresh completes" << dendl;
m_deferred_refresh = true;
}
return;
}
m_image_ids_invalid = true;
m_timer_ctx = m_threads->timer->add_event_after(
interval,
new LambdaContext([this](int r) {
process_refresh_images();
}));
}
template <typename I>
void PoolWatcher<I>::handle_rewatch_complete(int r) {
dout(5) << "r=" << r << dendl;
if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted" << dendl;
std::lock_guard locker{m_lock};
m_blocklisted = true;
return;
} else if (r == -ENOENT) {
dout(5) << "mirroring directory deleted" << dendl;
} else if (r < 0) {
derr << "unexpected error re-registering mirroring directory watch: "
<< cpp_strerror(r) << dendl;
}
schedule_refresh_images(5);
}
template <typename I>
void PoolWatcher<I>::handle_image_updated(const std::string &id,
const std::string &global_image_id,
bool enabled) {
dout(10) << "image_id=" << id << ", "
<< "global_image_id=" << global_image_id << ", "
<< "enabled=" << enabled << dendl;
std::lock_guard locker{m_lock};
ImageId image_id(global_image_id, id);
m_pending_added_image_ids.erase(image_id);
m_pending_removed_image_ids.erase(image_id);
if (enabled) {
m_pending_added_image_ids.insert(image_id);
schedule_listener();
} else {
m_pending_removed_image_ids.insert(image_id);
schedule_listener();
}
}
template <typename I>
void PoolWatcher<I>::process_refresh_images() {
ceph_assert(ceph_mutex_is_locked(m_threads->timer_lock));
ceph_assert(m_timer_ctx != nullptr);
m_timer_ctx = nullptr;
{
std::lock_guard locker{m_lock};
ceph_assert(!m_refresh_in_progress);
m_refresh_in_progress = true;
m_deferred_refresh = false;
}
// execute outside of the timer's lock
m_async_op_tracker.start_op();
Context *ctx = new LambdaContext([this](int r) {
register_watcher();
m_async_op_tracker.finish_op();
});
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
void PoolWatcher<I>::schedule_listener() {
ceph_assert(ceph_mutex_is_locked(m_lock));
m_pending_updates = true;
if (m_shutting_down || m_image_ids_invalid || m_notify_listener_in_progress) {
return;
}
dout(20) << dendl;
m_async_op_tracker.start_op();
Context *ctx = new LambdaContext([this](int r) {
notify_listener();
m_async_op_tracker.finish_op();
});
m_notify_listener_in_progress = true;
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
void PoolWatcher<I>::notify_listener() {
dout(10) << dendl;
std::string mirror_uuid;
ImageIds added_image_ids;
ImageIds removed_image_ids;
{
std::lock_guard locker{m_lock};
ceph_assert(m_notify_listener_in_progress);
}
if (!removed_image_ids.empty()) {
m_listener.handle_update(mirror_uuid, {}, std::move(removed_image_ids));
removed_image_ids.clear();
}
{
std::lock_guard locker{m_lock};
ceph_assert(m_notify_listener_in_progress);
// if the watch failed while we didn't own the lock, we are going
// to need to perform a full refresh
if (m_image_ids_invalid) {
m_notify_listener_in_progress = false;
return;
}
// merge add/remove notifications into pending set (a given image
// can only be in one set or another)
for (auto &image_id : m_pending_removed_image_ids) {
dout(20) << "image_id=" << image_id << dendl;
m_pending_image_ids.erase(image_id);
}
for (auto &image_id : m_pending_added_image_ids) {
dout(20) << "image_id=" << image_id << dendl;
m_pending_image_ids.erase(image_id);
m_pending_image_ids.insert(image_id);
}
m_pending_added_image_ids.clear();
// compute added/removed images
for (auto &image_id : m_image_ids) {
auto it = m_pending_image_ids.find(image_id);
if (it == m_pending_image_ids.end() || it->id != image_id.id) {
removed_image_ids.insert(image_id);
}
}
for (auto &image_id : m_pending_image_ids) {
auto it = m_image_ids.find(image_id);
if (it == m_image_ids.end() || it->id != image_id.id) {
added_image_ids.insert(image_id);
}
}
m_pending_updates = false;
m_image_ids = m_pending_image_ids;
}
m_listener.handle_update(m_mirror_uuid, std::move(added_image_ids),
std::move(removed_image_ids));
{
std::lock_guard locker{m_lock};
m_notify_listener_in_progress = false;
if (m_pending_updates) {
schedule_listener();
}
}
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::PoolWatcher<librbd::ImageCtx>;
| 13,360 | 27.187764 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/PoolWatcher.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_POOL_WATCHER_H
#define CEPH_RBD_MIRROR_POOL_WATCHER_H
#include <map>
#include <memory>
#include <set>
#include <string>
#include "common/AsyncOpTracker.h"
#include "common/ceph_context.h"
#include "common/ceph_mutex.h"
#include "include/rados/librados.hpp"
#include "tools/rbd_mirror/Types.h"
#include <boost/functional/hash.hpp>
#include <boost/optional.hpp>
#include "include/ceph_assert.h"
#include "tools/rbd_mirror/pool_watcher/Types.h"
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
template <typename> struct Threads;
/**
* Keeps track of images that have mirroring enabled within all
* pools.
*/
template <typename ImageCtxT = librbd::ImageCtx>
class PoolWatcher {
public:
static PoolWatcher* create(Threads<ImageCtxT> *threads,
librados::IoCtx &io_ctx,
const std::string& mirror_uuid,
pool_watcher::Listener &listener) {
return new PoolWatcher(threads, io_ctx, mirror_uuid, listener);
}
PoolWatcher(Threads<ImageCtxT> *threads,
librados::IoCtx &io_ctx,
const std::string& mirror_uuid,
pool_watcher::Listener &listener);
~PoolWatcher();
PoolWatcher(const PoolWatcher&) = delete;
PoolWatcher& operator=(const PoolWatcher&) = delete;
bool is_blocklisted() const;
void init(Context *on_finish = nullptr);
void shut_down(Context *on_finish);
inline uint64_t get_image_count() const {
std::lock_guard locker{m_lock};
return m_image_ids.size();
}
private:
/**
* @verbatim
*
* <start>
* |
* v
* INIT
* |
* v
* REGISTER_WATCHER
* |
* |/--------------------------------\
* | |
* v |
* REFRESH_IMAGES |
* | |
* |/----------------------------\ |
* | | |
* v | |
* NOTIFY_LISTENER | |
* | | |
* v | |
* IDLE ---\ | |
* | | | |
* | |\---> IMAGE_UPDATED | |
* | | | | |
* | | v | |
* | | GET_IMAGE_NAME --/ |
* | | |
* | \----> WATCH_ERROR ---------/
* v
* SHUT_DOWN
* |
* v
* UNREGISTER_WATCHER
* |
* v
* <finish>
*
* @endverbatim
*/
class MirroringWatcher;
Threads<ImageCtxT> *m_threads;
librados::IoCtx m_io_ctx;
std::string m_mirror_uuid;
pool_watcher::Listener &m_listener;
ImageIds m_refresh_image_ids;
bufferlist m_out_bl;
mutable ceph::mutex m_lock;
Context *m_on_init_finish = nullptr;
ImageIds m_image_ids;
bool m_pending_updates = false;
bool m_notify_listener_in_progress = false;
ImageIds m_pending_image_ids;
ImageIds m_pending_added_image_ids;
ImageIds m_pending_removed_image_ids;
MirroringWatcher *m_mirroring_watcher;
Context *m_timer_ctx = nullptr;
AsyncOpTracker m_async_op_tracker;
bool m_blocklisted = false;
bool m_shutting_down = false;
bool m_image_ids_invalid = true;
bool m_refresh_in_progress = false;
bool m_deferred_refresh = false;
void register_watcher();
void handle_register_watcher(int r);
void unregister_watcher();
void refresh_images();
void handle_refresh_images(int r);
void schedule_refresh_images(double interval);
void process_refresh_images();
void handle_rewatch_complete(int r);
void handle_image_updated(const std::string &image_id,
const std::string &global_image_id,
bool enabled);
void schedule_listener();
void notify_listener();
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::PoolWatcher<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_POOL_WATCHER_H
| 4,213 | 25.012346 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/ProgressContext.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_PROGRESS_CONTEXT_H
#define RBD_MIRROR_PROGRESS_CONTEXT_H
namespace rbd {
namespace mirror {
class ProgressContext
{
public:
virtual ~ProgressContext() {}
virtual void update_progress(const std::string &description,
bool flush = true) = 0;
};
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_PROGRESS_CONTEXT_H
| 459 | 19.909091 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/RemotePoolPoller.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "RemotePoolPoller.h"
#include "include/ceph_assert.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/Timer.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::RemotePoolPoller: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
static const double POLL_INTERVAL_SECONDS = 30;
using librbd::util::create_rados_callback;
template <typename I>
RemotePoolPoller<I>::~RemotePoolPoller() {
ceph_assert(m_timer_task == nullptr);
}
template <typename I>
void RemotePoolPoller<I>::init(Context* on_finish) {
dout(10) << dendl;
ceph_assert(m_state == STATE_INITIALIZING);
ceph_assert(m_on_finish == nullptr);
m_on_finish = on_finish;
get_mirror_uuid();
}
template <typename I>
void RemotePoolPoller<I>::shut_down(Context* on_finish) {
dout(10) << dendl;
std::unique_lock locker(m_threads->timer_lock);
ceph_assert(m_state == STATE_POLLING);
m_state = STATE_SHUTTING_DOWN;
if (m_timer_task == nullptr) {
// currently executing a poll
ceph_assert(m_on_finish == nullptr);
m_on_finish = on_finish;
return;
}
m_threads->timer->cancel_event(m_timer_task);
m_timer_task = nullptr;
m_threads->work_queue->queue(on_finish, 0);
}
template <typename I>
void RemotePoolPoller<I>::get_mirror_uuid() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_uuid_get_start(&op);
auto aio_comp = create_rados_callback<
RemotePoolPoller<I>, &RemotePoolPoller<I>::handle_get_mirror_uuid>(this);
m_out_bl.clear();
int r = m_remote_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void RemotePoolPoller<I>::handle_get_mirror_uuid(int r) {
dout(10) << "r=" << r << dendl;
std::string remote_mirror_uuid;
if (r >= 0) {
auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_uuid_get_finish(&it, &remote_mirror_uuid);
if (r >= 0 && remote_mirror_uuid.empty()) {
r = -ENOENT;
}
}
if (r < 0) {
if (r == -ENOENT) {
dout(5) << "remote mirror uuid missing" << dendl;
} else {
derr << "failed to retrieve remote mirror uuid: " << cpp_strerror(r)
<< dendl;
}
m_remote_pool_meta.mirror_uuid = "";
}
// if we have the mirror uuid, we will poll until shut down
if (m_state == STATE_INITIALIZING) {
if (r < 0) {
schedule_task(r);
return;
}
m_state = STATE_POLLING;
}
dout(10) << "remote_mirror_uuid=" << remote_mirror_uuid << dendl;
if (m_remote_pool_meta.mirror_uuid != remote_mirror_uuid) {
m_remote_pool_meta.mirror_uuid = remote_mirror_uuid;
m_updated = true;
}
mirror_peer_ping();
}
template <typename I>
void RemotePoolPoller<I>::mirror_peer_ping() {
dout(10) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_peer_ping(&op, m_site_name, m_local_mirror_uuid);
auto aio_comp = create_rados_callback<
RemotePoolPoller<I>, &RemotePoolPoller<I>::handle_mirror_peer_ping>(this);
int r = m_remote_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void RemotePoolPoller<I>::handle_mirror_peer_ping(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EOPNOTSUPP) {
// older OSD that doesn't support snapshot-based mirroring, so no need
// to query remote peers
dout(10) << "remote peer does not support snapshot-based mirroring"
<< dendl;
notify_listener();
return;
} else if (r < 0) {
// we can still see if we can perform a peer list and find ourselves
derr << "failed to ping remote mirror peer: " << cpp_strerror(r) << dendl;
}
mirror_peer_list();
}
template <typename I>
void RemotePoolPoller<I>::mirror_peer_list() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_peer_list_start(&op);
auto aio_comp = create_rados_callback<
RemotePoolPoller<I>, &RemotePoolPoller<I>::handle_mirror_peer_list>(this);
m_out_bl.clear();
int r = m_remote_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void RemotePoolPoller<I>::handle_mirror_peer_list(int r) {
dout(10) << "r=" << r << dendl;
std::vector<cls::rbd::MirrorPeer> peers;
if (r == 0) {
auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_peer_list_finish(&iter, &peers);
}
if (r < 0) {
derr << "failed to retrieve mirror peers: " << cpp_strerror(r) << dendl;
}
cls::rbd::MirrorPeer* matched_peer = nullptr;
for (auto& peer : peers) {
if (peer.mirror_peer_direction == cls::rbd::MIRROR_PEER_DIRECTION_RX) {
continue;
}
if (peer.mirror_uuid == m_local_mirror_uuid) {
matched_peer = &peer;
break;
} else if (peer.site_name == m_site_name) {
// keep searching in case we hit an exact match by fsid
matched_peer = &peer;
}
}
// older OSDs don't support peer ping so we might fail to find a match,
// which will prevent snapshot mirroring from functioning
std::string remote_mirror_peer_uuid;
if (matched_peer != nullptr) {
remote_mirror_peer_uuid = matched_peer->uuid;
}
dout(10) << "remote_mirror_peer_uuid=" << remote_mirror_peer_uuid << dendl;
if (m_remote_pool_meta.mirror_peer_uuid != remote_mirror_peer_uuid) {
m_remote_pool_meta.mirror_peer_uuid = remote_mirror_peer_uuid;
m_updated = true;
}
notify_listener();
}
template <typename I>
void RemotePoolPoller<I>::notify_listener() {
bool updated = false;
std::swap(updated, m_updated);
if (updated) {
dout(10) << dendl;
m_listener.handle_updated(m_remote_pool_meta);
}
schedule_task(0);
}
template <typename I>
void RemotePoolPoller<I>::schedule_task(int r) {
std::unique_lock locker{m_threads->timer_lock};
if (m_state == STATE_POLLING) {
dout(10) << dendl;
ceph_assert(m_timer_task == nullptr);
m_timer_task = new LambdaContext([this](int) {
handle_task();
});
m_threads->timer->add_event_after(POLL_INTERVAL_SECONDS, m_timer_task);
}
// finish init or shut down callback
if (m_on_finish != nullptr) {
locker.unlock();
Context* on_finish = nullptr;
std::swap(on_finish, m_on_finish);
on_finish->complete(m_state == STATE_SHUTTING_DOWN ? 0 : r);
}
}
template <typename I>
void RemotePoolPoller<I>::handle_task() {
dout(10) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_threads->timer_lock));
m_timer_task = nullptr;
auto ctx = new LambdaContext([this](int) {
get_mirror_uuid();
});
m_threads->work_queue->queue(ctx);
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::RemotePoolPoller<librbd::ImageCtx>;
| 7,198 | 25.86194 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/RemotePoolPoller.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_REMOTE_POOL_POLLER_H
#define CEPH_RBD_MIRROR_REMOTE_POOL_POLLER_H
#include "include/rados/librados.hpp"
#include "tools/rbd_mirror/Types.h"
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
template <typename> struct Threads;
namespace remote_pool_poller {
struct Listener {
virtual ~Listener() {}
virtual void handle_updated(const RemotePoolMeta& remote_pool_meta) = 0;
};
}; // namespace remote_pool_poller
template <typename ImageCtxT>
class RemotePoolPoller {
public:
static RemotePoolPoller* create(
Threads<ImageCtxT>* threads,
librados::IoCtx& remote_io_ctx,
const std::string& site_name,
const std::string& local_mirror_uuid,
remote_pool_poller::Listener& listener) {
return new RemotePoolPoller(threads, remote_io_ctx, site_name,
local_mirror_uuid, listener);
}
RemotePoolPoller(
Threads<ImageCtxT>* threads,
librados::IoCtx& remote_io_ctx,
const std::string& site_name,
const std::string& local_mirror_uuid,
remote_pool_poller::Listener& listener)
: m_threads(threads),
m_remote_io_ctx(remote_io_ctx),
m_site_name(site_name),
m_local_mirror_uuid(local_mirror_uuid),
m_listener(listener) {
}
~RemotePoolPoller();
void init(Context* on_finish);
void shut_down(Context* on_finish);
private:
/**
* @verbatim
*
* <start>
* |
* |/----------------------------\
* | |
* v |
* MIRROR_UUID_GET |
* | |
* v |
* MIRROR_PEER_PING |
* | |
* v |
* MIRROR_PEER_LIST |
* | |
* v |
* MIRROR_UUID_GET |
* | |
* v (skip if no changes) |
* NOTIFY_LISTENER |
* | |
* | (repeat periodically) |
* |\----------------------------/
* |
* v
* <finish>
*
* @endverbatim
*/
enum State {
STATE_INITIALIZING,
STATE_POLLING,
STATE_SHUTTING_DOWN
};
Threads<ImageCtxT>* m_threads;
librados::IoCtx& m_remote_io_ctx;
std::string m_site_name;
std::string m_local_mirror_uuid;
remote_pool_poller::Listener& m_listener;
bufferlist m_out_bl;
RemotePoolMeta m_remote_pool_meta;
bool m_updated = false;
State m_state = STATE_INITIALIZING;
Context* m_timer_task = nullptr;
Context* m_on_finish = nullptr;
void get_mirror_uuid();
void handle_get_mirror_uuid(int r);
void mirror_peer_ping();
void handle_mirror_peer_ping(int r);
void mirror_peer_list();
void handle_mirror_peer_list(int r);
void notify_listener();
void schedule_task(int r);
void handle_task();
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::RemotePoolPoller<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_REMOTE_POOL_POLLER_H
| 3,308 | 23.69403 | 74 |
h
|
null |
ceph-main/src/tools/rbd_mirror/ServiceDaemon.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/ServiceDaemon.h"
#include "include/Context.h"
#include "include/stringify.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/Timer.h"
#include "tools/rbd_mirror/Threads.h"
#include <sstream>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::ServiceDaemon: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace {
const std::string RBD_MIRROR_AUTH_ID_PREFIX("rbd-mirror.");
struct AttributeDumpVisitor : public boost::static_visitor<void> {
ceph::Formatter *f;
const std::string& name;
AttributeDumpVisitor(ceph::Formatter *f, const std::string& name)
: f(f), name(name) {
}
void operator()(bool val) const {
f->dump_bool(name.c_str(), val);
}
void operator()(uint64_t val) const {
f->dump_unsigned(name.c_str(), val);
}
void operator()(const std::string& val) const {
f->dump_string(name.c_str(), val);
}
};
} // anonymous namespace
using namespace service_daemon;
template <typename I>
ServiceDaemon<I>::ServiceDaemon(CephContext *cct, RadosRef rados,
Threads<I>* threads)
: m_cct(cct), m_rados(rados), m_threads(threads) {
dout(20) << dendl;
}
template <typename I>
ServiceDaemon<I>::~ServiceDaemon() {
dout(20) << dendl;
std::lock_guard timer_locker{m_threads->timer_lock};
if (m_timer_ctx != nullptr) {
m_threads->timer->cancel_event(m_timer_ctx);
update_status();
}
}
template <typename I>
int ServiceDaemon<I>::init() {
dout(20) << dendl;
std::string id = m_cct->_conf->name.get_id();
if (id.find(RBD_MIRROR_AUTH_ID_PREFIX) == 0) {
id = id.substr(RBD_MIRROR_AUTH_ID_PREFIX.size());
}
std::string instance_id = stringify(m_rados->get_instance_id());
std::map<std::string, std::string> service_metadata = {
{"id", id}, {"instance_id", instance_id}};
int r = m_rados->service_daemon_register("rbd-mirror", instance_id,
service_metadata);
if (r < 0) {
return r;
}
return 0;
}
template <typename I>
void ServiceDaemon<I>::add_pool(int64_t pool_id, const std::string& pool_name) {
dout(20) << "pool_id=" << pool_id << ", pool_name=" << pool_name << dendl;
{
std::lock_guard locker{m_lock};
m_pools.insert({pool_id, {pool_name}});
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::remove_pool(int64_t pool_id) {
dout(20) << "pool_id=" << pool_id << dendl;
{
std::lock_guard locker{m_lock};
m_pools.erase(pool_id);
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::add_namespace(int64_t pool_id,
const std::string& namespace_name) {
dout(20) << "pool_id=" << pool_id << ", namespace=" << namespace_name
<< dendl;
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
pool_it->second.ns_attributes[namespace_name];
// don't schedule update status as the namespace attributes are empty yet
}
template <typename I>
void ServiceDaemon<I>::remove_namespace(int64_t pool_id,
const std::string& namespace_name) {
dout(20) << "pool_id=" << pool_id << ", namespace=" << namespace_name
<< dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
pool_it->second.ns_attributes.erase(namespace_name);
}
schedule_update_status();
}
template <typename I>
uint64_t ServiceDaemon<I>::add_or_update_callout(int64_t pool_id,
uint64_t callout_id,
CalloutLevel callout_level,
const std::string& text) {
dout(20) << "pool_id=" << pool_id << ", "
<< "callout_id=" << callout_id << ", "
<< "callout_level=" << callout_level << ", "
<< "text=" << text << dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return CALLOUT_ID_NONE;
}
if (callout_id == CALLOUT_ID_NONE) {
callout_id = ++m_callout_id;
}
pool_it->second.callouts[callout_id] = {callout_level, text};
}
schedule_update_status();
return callout_id;
}
template <typename I>
void ServiceDaemon<I>::remove_callout(int64_t pool_id, uint64_t callout_id) {
dout(20) << "pool_id=" << pool_id << ", "
<< "callout_id=" << callout_id << dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
pool_it->second.callouts.erase(callout_id);
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::add_or_update_attribute(int64_t pool_id,
const std::string& key,
const AttributeValue& value) {
dout(20) << "pool_id=" << pool_id << ", "
<< "key=" << key << ", "
<< "value=" << value << dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
pool_it->second.attributes[key] = value;
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::add_or_update_namespace_attribute(
int64_t pool_id, const std::string& namespace_name, const std::string& key,
const AttributeValue& value) {
if (namespace_name.empty()) {
add_or_update_attribute(pool_id, key, value);
return;
}
dout(20) << "pool_id=" << pool_id << ", "
<< "namespace=" << namespace_name << ", "
<< "key=" << key << ", "
<< "value=" << value << dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
auto ns_it = pool_it->second.ns_attributes.find(namespace_name);
if (ns_it == pool_it->second.ns_attributes.end()) {
return;
}
ns_it->second[key] = value;
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::remove_attribute(int64_t pool_id,
const std::string& key) {
dout(20) << "pool_id=" << pool_id << ", "
<< "key=" << key << dendl;
{
std::lock_guard locker{m_lock};
auto pool_it = m_pools.find(pool_id);
if (pool_it == m_pools.end()) {
return;
}
pool_it->second.attributes.erase(key);
}
schedule_update_status();
}
template <typename I>
void ServiceDaemon<I>::schedule_update_status() {
std::lock_guard timer_locker{m_threads->timer_lock};
if (m_timer_ctx != nullptr) {
return;
}
dout(20) << dendl;
m_timer_ctx = new LambdaContext([this](int) {
m_timer_ctx = nullptr;
update_status();
});
m_threads->timer->add_event_after(1, m_timer_ctx);
}
template <typename I>
void ServiceDaemon<I>::update_status() {
ceph_assert(ceph_mutex_is_locked(m_threads->timer_lock));
ceph::JSONFormatter f;
{
std::lock_guard locker{m_lock};
f.open_object_section("pools");
for (auto& pool_pair : m_pools) {
f.open_object_section(stringify(pool_pair.first).c_str());
f.dump_string("name", pool_pair.second.name);
f.open_object_section("callouts");
for (auto& callout : pool_pair.second.callouts) {
f.open_object_section(stringify(callout.first).c_str());
f.dump_string("level", stringify(callout.second.level).c_str());
f.dump_string("text", callout.second.text.c_str());
f.close_section();
}
f.close_section(); // callouts
for (auto& attribute : pool_pair.second.attributes) {
AttributeDumpVisitor attribute_dump_visitor(&f, attribute.first);
boost::apply_visitor(attribute_dump_visitor, attribute.second);
}
if (!pool_pair.second.ns_attributes.empty()) {
f.open_object_section("namespaces");
for (auto& [ns, attributes] : pool_pair.second.ns_attributes) {
f.open_object_section(ns.c_str());
for (auto& [key, value] : attributes) {
AttributeDumpVisitor attribute_dump_visitor(&f, key);
boost::apply_visitor(attribute_dump_visitor, value);
}
f.close_section(); // namespace
}
f.close_section(); // namespaces
}
f.close_section(); // pool
}
f.close_section(); // pools
}
std::stringstream ss;
f.flush(ss);
dout(20) << ss.str() << dendl;
int r = m_rados->service_daemon_update_status({{"json", ss.str()}});
if (r < 0) {
derr << "failed to update service daemon status: " << cpp_strerror(r)
<< dendl;
}
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::ServiceDaemon<librbd::ImageCtx>;
| 9,242 | 26.924471 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/ServiceDaemon.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_SERVICE_DAEMON_H
#define CEPH_RBD_MIRROR_SERVICE_DAEMON_H
#include "common/ceph_mutex.h"
#include "include/common_fwd.h"
#include "tools/rbd_mirror/Types.h"
#include "tools/rbd_mirror/service_daemon/Types.h"
#include <map>
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
template <typename> struct Threads;
template <typename ImageCtxT = librbd::ImageCtx>
class ServiceDaemon {
public:
ServiceDaemon(CephContext *cct, RadosRef rados, Threads<ImageCtxT>* threads);
~ServiceDaemon();
int init();
void add_pool(int64_t pool_id, const std::string& pool_name);
void remove_pool(int64_t pool_id);
void add_namespace(int64_t pool_id, const std::string& namespace_name);
void remove_namespace(int64_t pool_id, const std::string& namespace_name);
uint64_t add_or_update_callout(int64_t pool_id, uint64_t callout_id,
service_daemon::CalloutLevel callout_level,
const std::string& text);
void remove_callout(int64_t pool_id, uint64_t callout_id);
void add_or_update_attribute(int64_t pool_id, const std::string& key,
const service_daemon::AttributeValue& value);
void add_or_update_namespace_attribute(
int64_t pool_id, const std::string& namespace_name,
const std::string& key, const service_daemon::AttributeValue& value);
void remove_attribute(int64_t pool_id, const std::string& key);
private:
struct Callout {
service_daemon::CalloutLevel level;
std::string text;
Callout() : level(service_daemon::CALLOUT_LEVEL_INFO) {
}
Callout(service_daemon::CalloutLevel level, const std::string& text)
: level(level), text(text) {
}
};
typedef std::map<uint64_t, Callout> Callouts;
typedef std::map<std::string, service_daemon::AttributeValue> Attributes;
typedef std::map<std::string, Attributes> NamespaceAttributes;
struct Pool {
std::string name;
Callouts callouts;
Attributes attributes;
NamespaceAttributes ns_attributes;
Pool(const std::string& name) : name(name) {
}
};
typedef std::map<int64_t, Pool> Pools;
CephContext *m_cct;
RadosRef m_rados;
Threads<ImageCtxT>* m_threads;
ceph::mutex m_lock = ceph::make_mutex("rbd::mirror::ServiceDaemon");
Pools m_pools;
uint64_t m_callout_id = service_daemon::CALLOUT_ID_NONE;
Context* m_timer_ctx = nullptr;
void schedule_update_status();
void update_status();
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::ServiceDaemon<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_SERVICE_DAEMON_H
| 2,775 | 28.221053 | 79 |
h
|
null |
ceph-main/src/tools/rbd_mirror/Threads.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/Threads.h"
#include "common/Timer.h"
#include "librbd/AsioEngine.h"
#include "librbd/ImageCtx.h"
#include "librbd/asio/ContextWQ.h"
namespace rbd {
namespace mirror {
template <typename I>
Threads<I>::Threads(std::shared_ptr<librados::Rados>& rados) {
auto cct = static_cast<CephContext*>(rados->cct());
asio_engine = new librbd::AsioEngine(rados);
work_queue = asio_engine->get_work_queue();
timer = new SafeTimer(cct, timer_lock, true);
timer->init();
}
template <typename I>
Threads<I>::~Threads() {
{
std::lock_guard timer_locker{timer_lock};
timer->shutdown();
}
delete timer;
work_queue->drain();
delete asio_engine;
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::Threads<librbd::ImageCtx>;
| 882 | 21.641026 | 70 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/Threads.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_THREADS_H
#define CEPH_RBD_MIRROR_THREADS_H
#include "include/common_fwd.h"
#include "include/rados/librados_fwd.hpp"
#include "common/ceph_mutex.h"
#include "common/Timer.h"
#include <memory>
class ThreadPool;
namespace librbd {
struct AsioEngine;
struct ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
template <typename ImageCtxT = librbd::ImageCtx>
class Threads {
public:
librbd::AsioEngine* asio_engine = nullptr;
librbd::asio::ContextWQ* work_queue = nullptr;
SafeTimer *timer = nullptr;
ceph::mutex timer_lock = ceph::make_mutex("Threads::timer_lock");
explicit Threads(std::shared_ptr<librados::Rados>& rados);
Threads(const Threads&) = delete;
Threads& operator=(const Threads&) = delete;
~Threads();
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::Threads<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_THREADS_H
| 1,059 | 22.043478 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/Throttler.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2016 SUSE LINUX GmbH
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "Throttler.h"
#include "common/Formatter.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/Utils.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::Throttler:: " << this \
<< " " << __func__ << ": "
namespace rbd {
namespace mirror {
template <typename I>
Throttler<I>::Throttler(CephContext *cct, const std::string &config_key)
: m_cct(cct), m_config_key(config_key),
m_config_keys{m_config_key.c_str(), nullptr},
m_lock(ceph::make_mutex(
librbd::util::unique_lock_name("rbd::mirror::Throttler", this))),
m_max_concurrent_ops(cct->_conf.get_val<uint64_t>(m_config_key)) {
dout(20) << m_config_key << "=" << m_max_concurrent_ops << dendl;
m_cct->_conf.add_observer(this);
}
template <typename I>
Throttler<I>::~Throttler() {
m_cct->_conf.remove_observer(this);
std::lock_guard locker{m_lock};
ceph_assert(m_inflight_ops.empty());
ceph_assert(m_queue.empty());
}
template <typename I>
void Throttler<I>::start_op(const std::string &ns,
const std::string &id_,
Context *on_start) {
Id id{ns, id_};
dout(20) << "id=" << id << dendl;
int r = 0;
{
std::lock_guard locker{m_lock};
if (m_inflight_ops.count(id) > 0) {
dout(20) << "duplicate for already started op " << id << dendl;
} else if (m_queued_ops.count(id) > 0) {
dout(20) << "duplicate for already queued op " << id << dendl;
std::swap(m_queued_ops[id], on_start);
r = -ENOENT;
} else if (m_max_concurrent_ops == 0 ||
m_inflight_ops.size() < m_max_concurrent_ops) {
ceph_assert(m_queue.empty());
m_inflight_ops.insert(id);
dout(20) << "ready to start op for " << id << " ["
<< m_inflight_ops.size() << "/" << m_max_concurrent_ops << "]"
<< dendl;
} else {
m_queue.push_back(id);
std::swap(m_queued_ops[id], on_start);
dout(20) << "op for " << id << " has been queued" << dendl;
}
}
if (on_start != nullptr) {
on_start->complete(r);
}
}
template <typename I>
bool Throttler<I>::cancel_op(const std::string &ns,
const std::string &id_) {
Id id{ns, id_};
dout(20) << "id=" << id << dendl;
Context *on_start = nullptr;
{
std::lock_guard locker{m_lock};
auto it = m_queued_ops.find(id);
if (it != m_queued_ops.end()) {
dout(20) << "canceled queued op for " << id << dendl;
m_queue.remove(id);
on_start = it->second;
m_queued_ops.erase(it);
}
}
if (on_start == nullptr) {
return false;
}
on_start->complete(-ECANCELED);
return true;
}
template <typename I>
void Throttler<I>::finish_op(const std::string &ns,
const std::string &id_) {
Id id{ns, id_};
dout(20) << "id=" << id << dendl;
if (cancel_op(ns, id_)) {
return;
}
Context *on_start = nullptr;
{
std::lock_guard locker{m_lock};
m_inflight_ops.erase(id);
if (m_inflight_ops.size() < m_max_concurrent_ops && !m_queue.empty()) {
auto id = m_queue.front();
auto it = m_queued_ops.find(id);
ceph_assert(it != m_queued_ops.end());
m_inflight_ops.insert(id);
dout(20) << "ready to start op for " << id << " ["
<< m_inflight_ops.size() << "/" << m_max_concurrent_ops << "]"
<< dendl;
on_start = it->second;
m_queued_ops.erase(it);
m_queue.pop_front();
}
}
if (on_start != nullptr) {
on_start->complete(0);
}
}
template <typename I>
void Throttler<I>::drain(const std::string &ns, int r) {
dout(20) << "ns=" << ns << dendl;
std::map<Id, Context *> queued_ops;
{
std::lock_guard locker{m_lock};
for (auto it = m_queued_ops.begin(); it != m_queued_ops.end(); ) {
if (it->first.first == ns) {
queued_ops[it->first] = it->second;
m_queue.remove(it->first);
it = m_queued_ops.erase(it);
} else {
it++;
}
}
for (auto it = m_inflight_ops.begin(); it != m_inflight_ops.end(); ) {
if (it->first == ns) {
dout(20) << "inflight_op " << *it << dendl;
it = m_inflight_ops.erase(it);
} else {
it++;
}
}
}
for (auto &it : queued_ops) {
dout(20) << "queued_op " << it.first << dendl;
it.second->complete(r);
}
}
template <typename I>
void Throttler<I>::set_max_concurrent_ops(uint32_t max) {
dout(20) << "max=" << max << dendl;
std::list<Context *> ops;
{
std::lock_guard locker{m_lock};
m_max_concurrent_ops = max;
// Start waiting ops in the case of available free slots
while ((m_max_concurrent_ops == 0 ||
m_inflight_ops.size() < m_max_concurrent_ops) &&
!m_queue.empty()) {
auto id = m_queue.front();
m_inflight_ops.insert(id);
dout(20) << "ready to start op for " << id << " ["
<< m_inflight_ops.size() << "/" << m_max_concurrent_ops << "]"
<< dendl;
auto it = m_queued_ops.find(id);
ceph_assert(it != m_queued_ops.end());
ops.push_back(it->second);
m_queued_ops.erase(it);
m_queue.pop_front();
}
}
for (const auto& ctx : ops) {
ctx->complete(0);
}
}
template <typename I>
void Throttler<I>::print_status(ceph::Formatter *f) {
dout(20) << dendl;
std::lock_guard locker{m_lock};
f->dump_int("max_parallel_requests", m_max_concurrent_ops);
f->dump_int("running_requests", m_inflight_ops.size());
f->dump_int("waiting_requests", m_queue.size());
}
template <typename I>
const char** Throttler<I>::get_tracked_conf_keys() const {
return m_config_keys;
}
template <typename I>
void Throttler<I>::handle_conf_change(const ConfigProxy& conf,
const std::set<std::string> &changed) {
if (changed.count(m_config_key)) {
set_max_concurrent_ops(conf.get_val<uint64_t>(m_config_key));
}
}
} // namespace mirror
} // namespace rbd
template class rbd::mirror::Throttler<librbd::ImageCtx>;
| 6,593 | 26.360996 | 77 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/Throttler.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_THROTTLER_H
#define RBD_MIRROR_THROTTLER_H
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include "common/ceph_mutex.h"
#include "common/config_obs.h"
#include "include/common_fwd.h"
class Context;
namespace ceph { class Formatter; }
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
template <typename ImageCtxT = librbd::ImageCtx>
class Throttler : public md_config_obs_t {
public:
static Throttler *create(
CephContext *cct,
const std::string &config_key) {
return new Throttler(cct, config_key);
}
void destroy() {
delete this;
}
Throttler(CephContext *cct,
const std::string &config_key);
~Throttler() override;
void set_max_concurrent_ops(uint32_t max);
void start_op(const std::string &ns, const std::string &id,
Context *on_start);
bool cancel_op(const std::string &ns, const std::string &id);
void finish_op(const std::string &ns, const std::string &id);
void drain(const std::string &ns, int r);
void print_status(ceph::Formatter *f);
private:
typedef std::pair<std::string, std::string> Id;
CephContext *m_cct;
const std::string m_config_key;
mutable const char* m_config_keys[2];
ceph::mutex m_lock;
uint32_t m_max_concurrent_ops;
std::list<Id> m_queue;
std::map<Id, Context *> m_queued_ops;
std::set<Id> m_inflight_ops;
const char **get_tracked_conf_keys() const override;
void handle_conf_change(const ConfigProxy& conf,
const std::set<std::string> &changed) override;
};
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::Throttler<librbd::ImageCtx>;
#endif // RBD_MIRROR_THROTTLER_H
| 1,856 | 23.76 | 73 |
h
|
null |
ceph-main/src/tools/rbd_mirror/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/Types.h"
namespace rbd {
namespace mirror {
std::ostream &operator<<(std::ostream &os, const ImageId &image_id) {
return os << "global id=" << image_id.global_id << ", "
<< "id=" << image_id.id;
}
std::ostream& operator<<(std::ostream& lhs,
const LocalPoolMeta& rhs) {
return lhs << "mirror_uuid=" << rhs.mirror_uuid;
}
std::ostream& operator<<(std::ostream& lhs,
const RemotePoolMeta& rhs) {
return lhs << "mirror_uuid=" << rhs.mirror_uuid << ", "
"mirror_peer_uuid=" << rhs.mirror_peer_uuid;
}
std::ostream& operator<<(std::ostream& lhs, const PeerSpec &peer) {
return lhs << "uuid: " << peer.uuid
<< " cluster: " << peer.cluster_name
<< " client: " << peer.client_name;
}
} // namespace mirror
} // namespace rbd
| 946 | 27.69697 | 70 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_TYPES_H
#define CEPH_RBD_MIRROR_TYPES_H
#include <iostream>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "include/rados/librados.hpp"
#include "include/rbd/librbd.hpp"
namespace rbd {
namespace mirror {
template <typename> struct MirrorStatusUpdater;
// Performance counters
enum {
l_rbd_mirror_journal_first = 27000,
l_rbd_mirror_journal_entries,
l_rbd_mirror_journal_replay_bytes,
l_rbd_mirror_journal_replay_latency,
l_rbd_mirror_journal_last,
l_rbd_mirror_snapshot_first,
l_rbd_mirror_snapshot_snapshots,
l_rbd_mirror_snapshot_sync_time,
l_rbd_mirror_snapshot_sync_bytes,
// per-image only counters below
l_rbd_mirror_snapshot_remote_timestamp,
l_rbd_mirror_snapshot_local_timestamp,
l_rbd_mirror_snapshot_last_sync_time,
l_rbd_mirror_snapshot_last_sync_bytes,
l_rbd_mirror_snapshot_last,
};
typedef std::shared_ptr<librados::Rados> RadosRef;
typedef std::shared_ptr<librados::IoCtx> IoCtxRef;
typedef std::shared_ptr<librbd::Image> ImageRef;
struct ImageId {
std::string global_id;
std::string id;
explicit ImageId(const std::string &global_id) : global_id(global_id) {
}
ImageId(const std::string &global_id, const std::string &id)
: global_id(global_id), id(id) {
}
inline bool operator==(const ImageId &rhs) const {
return (global_id == rhs.global_id && id == rhs.id);
}
inline bool operator<(const ImageId &rhs) const {
return global_id < rhs.global_id;
}
};
std::ostream &operator<<(std::ostream &, const ImageId &image_id);
typedef std::set<ImageId> ImageIds;
struct LocalPoolMeta {
LocalPoolMeta() {}
LocalPoolMeta(const std::string& mirror_uuid)
: mirror_uuid(mirror_uuid) {
}
std::string mirror_uuid;
};
std::ostream& operator<<(std::ostream& lhs,
const LocalPoolMeta& local_pool_meta);
struct RemotePoolMeta {
RemotePoolMeta() {}
RemotePoolMeta(const std::string& mirror_uuid,
const std::string& mirror_peer_uuid)
: mirror_uuid(mirror_uuid),
mirror_peer_uuid(mirror_peer_uuid) {
}
std::string mirror_uuid;
std::string mirror_peer_uuid;
};
std::ostream& operator<<(std::ostream& lhs,
const RemotePoolMeta& remote_pool_meta);
template <typename I>
struct Peer {
std::string uuid;
mutable librados::IoCtx io_ctx;
RemotePoolMeta remote_pool_meta;
MirrorStatusUpdater<I>* mirror_status_updater = nullptr;
Peer() {
}
Peer(const std::string& uuid,
librados::IoCtx& io_ctx,
const RemotePoolMeta& remote_pool_meta,
MirrorStatusUpdater<I>* mirror_status_updater)
: io_ctx(io_ctx),
remote_pool_meta(remote_pool_meta),
mirror_status_updater(mirror_status_updater) {
}
inline bool operator<(const Peer &rhs) const {
return uuid < rhs.uuid;
}
};
template <typename I>
std::ostream& operator<<(std::ostream& lhs, const Peer<I>& peer) {
return lhs << peer.remote_pool_meta;
}
struct PeerSpec {
PeerSpec() = default;
PeerSpec(const std::string &uuid, const std::string &cluster_name,
const std::string &client_name)
: uuid(uuid), cluster_name(cluster_name), client_name(client_name)
{
}
PeerSpec(const librbd::mirror_peer_site_t &peer) :
uuid(peer.uuid),
cluster_name(peer.site_name),
client_name(peer.client_name)
{
}
std::string uuid;
std::string cluster_name;
std::string client_name;
/// optional config properties
std::string mon_host;
std::string key;
bool operator==(const PeerSpec& rhs) const {
return (uuid == rhs.uuid &&
cluster_name == rhs.cluster_name &&
client_name == rhs.client_name &&
mon_host == rhs.mon_host &&
key == rhs.key);
}
bool operator<(const PeerSpec& rhs) const {
if (uuid != rhs.uuid) {
return uuid < rhs.uuid;
} else if (cluster_name != rhs.cluster_name) {
return cluster_name < rhs.cluster_name;
} else if (client_name != rhs.client_name) {
return client_name < rhs.client_name;
} else if (mon_host < rhs.mon_host) {
return mon_host < rhs.mon_host;
} else {
return key < rhs.key;
}
}
};
std::ostream& operator<<(std::ostream& lhs, const PeerSpec &peer);
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_TYPES_H
| 4,427 | 24.744186 | 73 |
h
|
null |
ceph-main/src/tools/rbd_mirror/main.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/ceph_argparse.h"
#include "common/config.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/perf_counters.h"
#include "global/global_init.h"
#include "global/signal_handler.h"
#include "Mirror.h"
#include "Types.h"
#include <vector>
rbd::mirror::Mirror *mirror = nullptr;
PerfCounters *g_journal_perf_counters = nullptr;
PerfCounters *g_snapshot_perf_counters = nullptr;
void usage() {
std::cout << "usage: rbd-mirror [options...]" << std::endl;
std::cout << "options:\n";
std::cout << " -m monaddress[:port] connect to specified monitor\n";
std::cout << " --keyring=<path> path to keyring for local cluster\n";
std::cout << " --log-file=<logfile> file to log debug output\n";
std::cout << " --debug-rbd-mirror=<log-level>/<memory-level> set rbd-mirror debug level\n";
generic_server_usage();
}
static void handle_signal(int signum)
{
if (mirror)
mirror->handle_signal(signum);
}
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
if (args.empty()) {
std::cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage();
exit(0);
}
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_DAEMON,
CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS);
if (g_conf()->daemonize) {
global_init_daemonize(g_ceph_context);
}
common_init_finish(g_ceph_context);
init_async_signal_handler();
register_async_signal_handler(SIGHUP, handle_signal);
register_async_signal_handler_oneshot(SIGINT, handle_signal);
register_async_signal_handler_oneshot(SIGTERM, handle_signal);
auto cmd_args = argv_to_vec(argc, argv);
// disable unnecessary librbd cache
g_ceph_context->_conf.set_val_or_die("rbd_cache", "false");
auto prio =
g_ceph_context->_conf.get_val<int64_t>("rbd_mirror_perf_stats_prio");
{
PerfCountersBuilder plb(g_ceph_context, "rbd_mirror_journal",
rbd::mirror::l_rbd_mirror_journal_first,
rbd::mirror::l_rbd_mirror_journal_last);
plb.add_u64_counter(rbd::mirror::l_rbd_mirror_journal_entries, "entries",
"Number of entries replayed", nullptr, prio);
plb.add_u64_counter(rbd::mirror::l_rbd_mirror_journal_replay_bytes,
"replay_bytes", "Total bytes replayed", nullptr, prio,
unit_t(UNIT_BYTES));
plb.add_time_avg(rbd::mirror::l_rbd_mirror_journal_replay_latency,
"replay_latency", "Replay latency", nullptr, prio);
g_journal_perf_counters = plb.create_perf_counters();
}
{
PerfCountersBuilder plb(
g_ceph_context, "rbd_mirror_snapshot",
rbd::mirror::l_rbd_mirror_snapshot_first,
rbd::mirror::l_rbd_mirror_snapshot_remote_timestamp);
plb.add_u64_counter(rbd::mirror::l_rbd_mirror_snapshot_snapshots,
"snapshots", "Number of snapshots synced", nullptr,
prio);
plb.add_time_avg(rbd::mirror::l_rbd_mirror_snapshot_sync_time, "sync_time",
"Average sync time", nullptr, prio);
plb.add_u64_counter(rbd::mirror::l_rbd_mirror_snapshot_sync_bytes,
"sync_bytes", "Total bytes synced", nullptr, prio,
unit_t(UNIT_BYTES));
g_snapshot_perf_counters = plb.create_perf_counters();
}
g_ceph_context->get_perfcounters_collection()->add(g_journal_perf_counters);
g_ceph_context->get_perfcounters_collection()->add(g_snapshot_perf_counters);
mirror = new rbd::mirror::Mirror(g_ceph_context, cmd_args);
int r = mirror->init();
if (r < 0) {
std::cerr << "failed to initialize: " << cpp_strerror(r) << std::endl;
goto cleanup;
}
mirror->run();
cleanup:
unregister_async_signal_handler(SIGHUP, handle_signal);
unregister_async_signal_handler(SIGINT, handle_signal);
unregister_async_signal_handler(SIGTERM, handle_signal);
shutdown_async_signal_handler();
g_ceph_context->get_perfcounters_collection()->remove(g_journal_perf_counters);
g_ceph_context->get_perfcounters_collection()->remove(g_snapshot_perf_counters);
delete mirror;
delete g_journal_perf_counters;
delete g_snapshot_perf_counters;
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
| 4,454 | 34.64 | 95 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/SnapshotPurgeRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_deleter/SnapshotPurgeRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#include "librbd/journal/Policy.h"
#include "tools/rbd_mirror/image_deleter/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_deleter::SnapshotPurgeRequest: " \
<< this << " " << __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_deleter {
using librbd::util::create_context_callback;
template <typename I>
void SnapshotPurgeRequest<I>::send() {
open_image();
}
template <typename I>
void SnapshotPurgeRequest<I>::open_image() {
dout(10) << dendl;
m_image_ctx = I::create("", m_image_id, nullptr, m_io_ctx, false);
// ensure non-primary images can be modified
m_image_ctx->read_only_mask &= ~librbd::IMAGE_READ_ONLY_FLAG_NON_PRIMARY;
{
std::unique_lock image_locker{m_image_ctx->image_lock};
m_image_ctx->set_journal_policy(new JournalPolicy());
}
Context *ctx = create_context_callback<
SnapshotPurgeRequest<I>, &SnapshotPurgeRequest<I>::handle_open_image>(
this);
m_image_ctx->state->open(librbd::OPEN_FLAG_SKIP_OPEN_PARENT, ctx);
}
template <typename I>
void SnapshotPurgeRequest<I>::handle_open_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to open image '" << m_image_id << "': " << cpp_strerror(r)
<< dendl;
m_image_ctx = nullptr;
finish(r);
return;
}
acquire_lock();
}
template <typename I>
void SnapshotPurgeRequest<I>::acquire_lock() {
dout(10) << dendl;
m_image_ctx->owner_lock.lock_shared();
if (m_image_ctx->exclusive_lock == nullptr) {
m_image_ctx->owner_lock.unlock_shared();
start_snap_unprotect();
return;
}
m_image_ctx->exclusive_lock->acquire_lock(create_context_callback<
SnapshotPurgeRequest<I>, &SnapshotPurgeRequest<I>::handle_acquire_lock>(
this));
m_image_ctx->owner_lock.unlock_shared();
}
template <typename I>
void SnapshotPurgeRequest<I>::handle_acquire_lock(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to acquire exclusive lock: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
start_snap_unprotect();
}
template <typename I>
void SnapshotPurgeRequest<I>::start_snap_unprotect() {
dout(10) << dendl;
{
std::shared_lock image_locker{m_image_ctx->image_lock};
m_snaps = m_image_ctx->snaps;
}
snap_unprotect();
}
template <typename I>
void SnapshotPurgeRequest<I>::snap_unprotect() {
if (m_snaps.empty()) {
close_image();
return;
}
librados::snap_t snap_id = m_snaps.back();
m_image_ctx->image_lock.lock_shared();
int r = m_image_ctx->get_snap_namespace(snap_id, &m_snap_namespace);
if (r < 0) {
m_image_ctx->image_lock.unlock_shared();
derr << "failed to get snap namespace: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
r = m_image_ctx->get_snap_name(snap_id, &m_snap_name);
if (r < 0) {
m_image_ctx->image_lock.unlock_shared();
derr << "failed to get snap name: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
bool is_protected;
r = m_image_ctx->is_snap_protected(snap_id, &is_protected);
if (r < 0) {
m_image_ctx->image_lock.unlock_shared();
derr << "failed to get snap protection status: " << cpp_strerror(r)
<< dendl;
m_ret_val = r;
close_image();
return;
}
m_image_ctx->image_lock.unlock_shared();
if (!is_protected) {
snap_remove();
return;
}
dout(10) << "snap_id=" << snap_id << ", "
<< "snap_namespace=" << m_snap_namespace << ", "
<< "snap_name=" << m_snap_name << dendl;
auto finish_op_ctx = start_lock_op(&r);
if (finish_op_ctx == nullptr) {
derr << "lost exclusive lock" << dendl;
m_ret_val = r;
close_image();
return;
}
auto ctx = new LambdaContext([this, finish_op_ctx](int r) {
handle_snap_unprotect(r);
finish_op_ctx->complete(0);
});
std::shared_lock owner_locker{m_image_ctx->owner_lock};
m_image_ctx->operations->execute_snap_unprotect(
m_snap_namespace, m_snap_name.c_str(), ctx);
}
template <typename I>
void SnapshotPurgeRequest<I>::handle_snap_unprotect(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBUSY) {
dout(10) << "snapshot in-use" << dendl;
m_ret_val = r;
close_image();
return;
} else if (r < 0) {
derr << "failed to unprotect snapshot: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
{
// avoid the need to refresh to delete the newly unprotected snapshot
std::shared_lock image_locker{m_image_ctx->image_lock};
librados::snap_t snap_id = m_snaps.back();
auto snap_info_it = m_image_ctx->snap_info.find(snap_id);
if (snap_info_it != m_image_ctx->snap_info.end()) {
snap_info_it->second.protection_status =
RBD_PROTECTION_STATUS_UNPROTECTED;
}
}
snap_remove();
}
template <typename I>
void SnapshotPurgeRequest<I>::snap_remove() {
librados::snap_t snap_id = m_snaps.back();
dout(10) << "snap_id=" << snap_id << ", "
<< "snap_namespace=" << m_snap_namespace << ", "
<< "snap_name=" << m_snap_name << dendl;
int r;
auto finish_op_ctx = start_lock_op(&r);
if (finish_op_ctx == nullptr) {
derr << "lost exclusive lock" << dendl;
m_ret_val = r;
close_image();
return;
}
auto ctx = new LambdaContext([this, finish_op_ctx](int r) {
handle_snap_remove(r);
finish_op_ctx->complete(0);
});
std::shared_lock owner_locker{m_image_ctx->owner_lock};
m_image_ctx->operations->execute_snap_remove(
m_snap_namespace, m_snap_name.c_str(), ctx);
}
template <typename I>
void SnapshotPurgeRequest<I>::handle_snap_remove(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBUSY) {
dout(10) << "snapshot in-use" << dendl;
m_ret_val = r;
close_image();
return;
} else if (r < 0) {
derr << "failed to remove snapshot: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
m_snaps.pop_back();
snap_unprotect();
}
template <typename I>
void SnapshotPurgeRequest<I>::close_image() {
dout(10) << dendl;
m_image_ctx->state->close(create_context_callback<
SnapshotPurgeRequest<I>,
&SnapshotPurgeRequest<I>::handle_close_image>(this));
}
template <typename I>
void SnapshotPurgeRequest<I>::handle_close_image(int r) {
dout(10) << "r=" << r << dendl;
m_image_ctx = nullptr;
if (r < 0) {
derr << "failed to close: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void SnapshotPurgeRequest<I>::finish(int r) {
if (m_ret_val < 0) {
r = m_ret_val;
}
m_on_finish->complete(r);
delete this;
}
template <typename I>
Context *SnapshotPurgeRequest<I>::start_lock_op(int* r) {
std::shared_lock owner_locker{m_image_ctx->owner_lock};
if (m_image_ctx->exclusive_lock == nullptr) {
return new LambdaContext([](int r) {});
}
return m_image_ctx->exclusive_lock->start_op(r);
}
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_deleter::SnapshotPurgeRequest<librbd::ImageCtx>;
| 7,618 | 24.396667 | 84 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/SnapshotPurgeRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_DELETER_SNAPSHOT_PURGE_REQUEST_H
#define CEPH_RBD_MIRROR_IMAGE_DELETER_SNAPSHOT_PURGE_REQUEST_H
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include <string>
#include <vector>
class Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_deleter {
template <typename ImageCtxT = librbd::ImageCtx>
class SnapshotPurgeRequest {
public:
static SnapshotPurgeRequest* create(librados::IoCtx &io_ctx,
const std::string &image_id,
Context *on_finish) {
return new SnapshotPurgeRequest(io_ctx, image_id, on_finish);
}
SnapshotPurgeRequest(librados::IoCtx &io_ctx, const std::string &image_id,
Context *on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id), m_on_finish(on_finish) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* OPEN_IMAGE
* |
* v
* ACQUIRE_LOCK
* |
* | (repeat for each snapshot)
* |/------------------------\
* | |
* v (skip if not needed) |
* SNAP_UNPROTECT |
* | |
* v (skip if not needed) |
* SNAP_REMOVE -----------------/
* |
* v
* CLOSE_IMAGE
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_image_id;
Context *m_on_finish;
ImageCtxT *m_image_ctx = nullptr;
int m_ret_val = 0;
std::vector<librados::snap_t> m_snaps;
cls::rbd::SnapshotNamespace m_snap_namespace;
std::string m_snap_name;
void open_image();
void handle_open_image(int r);
void acquire_lock();
void handle_acquire_lock(int r);
void start_snap_unprotect();
void snap_unprotect();
void handle_snap_unprotect(int r);
void snap_remove();
void handle_snap_remove(int r);
void close_image();
void handle_close_image(int r);
void finish(int r);
Context *start_lock_op(int* r);
};
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_deleter::SnapshotPurgeRequest<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_DELETER_SNAPSHOT_PURGE_REQUEST_H
| 2,399 | 21.641509 | 89 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashMoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_deleter/TrashMoveRequest.h"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/WorkQueue.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Journal.h"
#include "librbd/TrashWatcher.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/ResetRequest.h"
#include "librbd/mirror/ImageRemoveRequest.h"
#include "librbd/mirror/GetInfoRequest.h"
#include "librbd/trash/MoveRequest.h"
#include "tools/rbd_mirror/image_deleter/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_deleter::TrashMoveRequest: " \
<< this << " " << __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_deleter {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void TrashMoveRequest<I>::send() {
get_mirror_image_id();
}
template <typename I>
void TrashMoveRequest<I>::get_mirror_image_id() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_get_image_id_start(&op, m_global_image_id);
auto aio_comp = create_rados_callback<
TrashMoveRequest<I>,
&TrashMoveRequest<I>::handle_get_mirror_image_id>(this);
m_out_bl.clear();
int r = m_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashMoveRequest<I>::handle_get_mirror_image_id(int r) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(&bl_it,
&m_image_id);
}
if (r == -ENOENT) {
dout(10) << "image " << m_global_image_id << " is not mirrored" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "error retrieving local id for image " << m_global_image_id << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
get_mirror_info();
}
template <typename I>
void TrashMoveRequest<I>::get_mirror_info() {
dout(10) << dendl;
auto ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_get_mirror_info>(this);
auto req = librbd::mirror::GetInfoRequest<I>::create(
m_io_ctx, m_op_work_queue, m_image_id, &m_mirror_image, &m_promotion_state,
&m_primary_mirror_uuid, ctx);
req->send();
}
template <typename I>
void TrashMoveRequest<I>::handle_get_mirror_info(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(5) << "image " << m_global_image_id << " is not mirrored" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "error retrieving image primary info for image "
<< m_global_image_id << ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
if (m_promotion_state == librbd::mirror::PROMOTION_STATE_PRIMARY) {
dout(10) << "image " << m_global_image_id << " is local primary" << dendl;
finish(-EPERM);
return;
} else if (m_promotion_state == librbd::mirror::PROMOTION_STATE_ORPHAN &&
!m_resync) {
dout(10) << "image " << m_global_image_id << " is orphaned" << dendl;
finish(-EPERM);
return;
}
disable_mirror_image();
}
template <typename I>
void TrashMoveRequest<I>::disable_mirror_image() {
dout(10) << dendl;
m_mirror_image.state = cls::rbd::MIRROR_IMAGE_STATE_DISABLING;
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_set(&op, m_image_id, m_mirror_image);
auto aio_comp = create_rados_callback<
TrashMoveRequest<I>,
&TrashMoveRequest<I>::handle_disable_mirror_image>(this);
int r = m_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashMoveRequest<I>::handle_disable_mirror_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(10) << "local image is not mirrored, aborting deletion." << dendl;
finish(r);
return;
} else if (r == -EEXIST || r == -EINVAL) {
derr << "cannot disable mirroring for image " << m_global_image_id
<< ": global_image_id has changed/reused: "
<< cpp_strerror(r) << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "cannot disable mirroring for image " << m_global_image_id
<< ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
open_image();
}
template <typename I>
void TrashMoveRequest<I>::open_image() {
dout(10) << dendl;
m_image_ctx = I::create("", m_image_id, nullptr, m_io_ctx, false);
// ensure non-primary images can be modified
m_image_ctx->read_only_mask &= ~librbd::IMAGE_READ_ONLY_FLAG_NON_PRIMARY;
{
// don't attempt to open the journal
std::unique_lock image_locker{m_image_ctx->image_lock};
m_image_ctx->set_journal_policy(new JournalPolicy());
}
Context *ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_open_image>(this);
m_image_ctx->state->open(librbd::OPEN_FLAG_SKIP_OPEN_PARENT, ctx);
}
template <typename I>
void TrashMoveRequest<I>::handle_open_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(5) << "mirror image does not exist, removing orphaned metadata" << dendl;
m_image_ctx = nullptr;
remove_mirror_image();
return;
}
if (r < 0) {
derr << "failed to open image: " << cpp_strerror(r) << dendl;
m_image_ctx = nullptr;
finish(r);
return;
}
if (m_image_ctx->old_format) {
derr << "cannot move v1 image to trash" << dendl;
m_ret_val = -EINVAL;
close_image();
return;
}
reset_journal();
}
template <typename I>
void TrashMoveRequest<I>::reset_journal() {
if (m_mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT) {
// snapshot-based mirroring doesn't require journal feature
acquire_lock();
return;
}
dout(10) << dendl;
// TODO use Journal thread pool for journal ops until converted to ASIO
ContextWQ* context_wq;
librbd::Journal<>::get_work_queue(
reinterpret_cast<CephContext*>(m_io_ctx.cct()), &context_wq);
// ensure that if the image is recovered any peers will split-brain
auto ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_reset_journal>(this);
auto req = librbd::journal::ResetRequest<I>::create(
m_io_ctx, m_image_id, librbd::Journal<>::IMAGE_CLIENT_ID,
librbd::Journal<>::LOCAL_MIRROR_UUID, context_wq, ctx);
req->send();
}
template <typename I>
void TrashMoveRequest<I>::handle_reset_journal(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to reset journal: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
acquire_lock();
}
template <typename I>
void TrashMoveRequest<I>::acquire_lock() {
m_image_ctx->owner_lock.lock_shared();
if (m_image_ctx->exclusive_lock == nullptr) {
m_image_ctx->owner_lock.unlock_shared();
if (m_mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT) {
// snapshot-based mirroring doesn't require exclusive-lock
trash_move();
} else {
derr << "exclusive lock feature not enabled" << dendl;
m_ret_val = -EINVAL;
close_image();
}
return;
}
dout(10) << dendl;
Context *ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_acquire_lock>(this);
m_image_ctx->exclusive_lock->block_requests(0);
m_image_ctx->exclusive_lock->acquire_lock(ctx);
m_image_ctx->owner_lock.unlock_shared();
}
template <typename I>
void TrashMoveRequest<I>::handle_acquire_lock(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to acquire exclusive lock: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
trash_move();
}
template <typename I>
void TrashMoveRequest<I>::trash_move() {
dout(10) << dendl;
utime_t delete_time{ceph_clock_now()};
utime_t deferment_end_time{delete_time};
deferment_end_time +=
m_image_ctx->config.template get_val<uint64_t>("rbd_mirroring_delete_delay");
m_trash_image_spec = {
cls::rbd::TRASH_IMAGE_SOURCE_MIRRORING, m_image_ctx->name, delete_time,
deferment_end_time};
Context *ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_trash_move>(this);
auto req = librbd::trash::MoveRequest<I>::create(
m_io_ctx, m_image_id, m_trash_image_spec, ctx);
req->send();
}
template <typename I>
void TrashMoveRequest<I>::handle_trash_move(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to move image to trash: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_image();
return;
}
m_moved_to_trash = true;
remove_mirror_image();
}
template <typename I>
void TrashMoveRequest<I>::remove_mirror_image() {
dout(10) << dendl;
auto ctx = create_context_callback<
TrashMoveRequest<I>,
&TrashMoveRequest<I>::handle_remove_mirror_image>(this);
auto req = librbd::mirror::ImageRemoveRequest<I>::create(
m_io_ctx, m_global_image_id, m_image_id, ctx);
req->send();
}
template <typename I>
void TrashMoveRequest<I>::handle_remove_mirror_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(10) << "local image is not mirrored" << dendl;
} else if (r < 0) {
derr << "failed to remove mirror image state for " << m_global_image_id
<< ": " << cpp_strerror(r) << dendl;
m_ret_val = r;
}
close_image();
}
template <typename I>
void TrashMoveRequest<I>::close_image() {
dout(10) << dendl;
if (m_image_ctx == nullptr) {
handle_close_image(0);
return;
}
Context *ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_close_image>(this);
m_image_ctx->state->close(ctx);
}
template <typename I>
void TrashMoveRequest<I>::handle_close_image(int r) {
dout(10) << "r=" << r << dendl;
m_image_ctx = nullptr;
if (r < 0) {
derr << "failed to close image: " << cpp_strerror(r) << dendl;
}
// don't send notification if we failed
if (!m_moved_to_trash) {
finish(0);
return;
}
notify_trash_add();
}
template <typename I>
void TrashMoveRequest<I>::notify_trash_add() {
dout(10) << dendl;
Context *ctx = create_context_callback<
TrashMoveRequest<I>, &TrashMoveRequest<I>::handle_notify_trash_add>(this);
librbd::TrashWatcher<I>::notify_image_added(m_io_ctx, m_image_id,
m_trash_image_spec, ctx);
}
template <typename I>
void TrashMoveRequest<I>::handle_notify_trash_add(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to notify trash watchers: " << cpp_strerror(r) << dendl;
}
finish(0);
}
template <typename I>
void TrashMoveRequest<I>::finish(int r) {
if (m_ret_val < 0) {
r = m_ret_val;
}
dout(10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_deleter::TrashMoveRequest<librbd::ImageCtx>;
| 11,458 | 26.283333 | 82 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashMoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_MOVE_REQUEST_H
#define CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_MOVE_REQUEST_H
#include "include/buffer.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/mirror/Types.h"
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_deleter {
template <typename ImageCtxT = librbd::ImageCtx>
class TrashMoveRequest {
public:
static TrashMoveRequest* create(librados::IoCtx& io_ctx,
const std::string& global_image_id,
bool resync,
librbd::asio::ContextWQ* op_work_queue,
Context* on_finish) {
return new TrashMoveRequest(io_ctx, global_image_id, resync, op_work_queue,
on_finish);
}
TrashMoveRequest(librados::IoCtx& io_ctx, const std::string& global_image_id,
bool resync, librbd::asio::ContextWQ* op_work_queue,
Context* on_finish)
: m_io_ctx(io_ctx), m_global_image_id(global_image_id), m_resync(resync),
m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* GET_MIRROR_IMAGE_ID
* |
* v
* GET_MIRROR_INFO
* |
* v
* DISABLE_MIRROR_IMAGE
* |
* v
* OPEN_IMAGE
* |
* v (skip if not needed)
* RESET_JOURNAL
* |
* v (skip if not needed)
* ACQUIRE_LOCK
* |
* v
* TRASH_MOVE
* |
* v
* REMOVE_MIRROR_IMAGE
* |
* v
* CLOSE_IMAGE
* |
* v
* NOTIFY_TRASH_ADD
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_global_image_id;
bool m_resync;
librbd::asio::ContextWQ *m_op_work_queue;
Context *m_on_finish;
ceph::bufferlist m_out_bl;
std::string m_image_id;
cls::rbd::MirrorImage m_mirror_image;
librbd::mirror::PromotionState m_promotion_state;
std::string m_primary_mirror_uuid;
cls::rbd::TrashImageSpec m_trash_image_spec;
ImageCtxT *m_image_ctx = nullptr;;
int m_ret_val = 0;
bool m_moved_to_trash = false;
void get_mirror_image_id();
void handle_get_mirror_image_id(int r);
void get_mirror_info();
void handle_get_mirror_info(int r);
void disable_mirror_image();
void handle_disable_mirror_image(int r);
void open_image();
void handle_open_image(int r);
void reset_journal();
void handle_reset_journal(int r);
void acquire_lock();
void handle_acquire_lock(int r);
void trash_move();
void handle_trash_move(int r);
void remove_mirror_image();
void handle_remove_mirror_image(int r);
void close_image();
void handle_close_image(int r);
void notify_trash_add();
void handle_notify_trash_add(int r);
void finish(int r);
};
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_deleter::TrashMoveRequest<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_WATCHER_H
| 3,322 | 22.237762 | 85 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashRemoveRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_deleter/TrashRemoveRequest.h"
#include "include/ceph_assert.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/WorkQueue.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/TrashWatcher.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/trash/RemoveRequest.h"
#include "tools/rbd_mirror/image_deleter/SnapshotPurgeRequest.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_deleter::TrashRemoveRequest: " \
<< this << " " << __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_deleter {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void TrashRemoveRequest<I>::send() {
*m_error_result = ERROR_RESULT_RETRY;
get_trash_image_spec();
}
template <typename I>
void TrashRemoveRequest<I>::get_trash_image_spec() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::trash_get_start(&op, m_image_id);
auto aio_comp = create_rados_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_get_trash_image_spec>(this);
m_out_bl.clear();
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashRemoveRequest<I>::handle_get_trash_image_spec(int r) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::trash_get_finish(&bl_it, &m_trash_image_spec);
}
if (r == -ENOENT || (r >= 0 && m_trash_image_spec.source !=
cls::rbd::TRASH_IMAGE_SOURCE_MIRRORING)) {
dout(10) << "image id " << m_image_id << " not in mirroring trash" << dendl;
finish(0);
return;
} else if (r < 0) {
derr << "error getting image id " << m_image_id << " info from trash: "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
if (m_trash_image_spec.state != cls::rbd::TRASH_IMAGE_STATE_NORMAL &&
m_trash_image_spec.state != cls::rbd::TRASH_IMAGE_STATE_REMOVING) {
dout(10) << "image " << m_image_id << " is not in an expected trash state: "
<< m_trash_image_spec.state << dendl;
*m_error_result = ERROR_RESULT_RETRY_IMMEDIATELY;
finish(-EBUSY);
return;
}
set_trash_state();
}
template <typename I>
void TrashRemoveRequest<I>::set_trash_state() {
if (m_trash_image_spec.state == cls::rbd::TRASH_IMAGE_STATE_REMOVING) {
get_snap_context();
return;
}
dout(10) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::trash_state_set(&op, m_image_id,
cls::rbd::TRASH_IMAGE_STATE_REMOVING,
cls::rbd::TRASH_IMAGE_STATE_NORMAL);
auto aio_comp = create_rados_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_set_trash_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 TrashRemoveRequest<I>::handle_set_trash_state(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(10) << "image id " << m_image_id << " not in mirroring trash" << dendl;
finish(0);
return;
} else if (r < 0 && r != -EOPNOTSUPP) {
derr << "error setting trash image state for image id " << m_image_id
<< ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
get_snap_context();
}
template <typename I>
void TrashRemoveRequest<I>::get_snap_context() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::get_snapcontext_start(&op);
std::string header_oid = librbd::util::header_name(m_image_id);
auto aio_comp = create_rados_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_get_snap_context>(this);
m_out_bl.clear();
int r = m_io_ctx.aio_operate(header_oid, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashRemoveRequest<I>::handle_get_snap_context(int r) {
dout(10) << "r=" << r << dendl;
::SnapContext snapc;
if (r == 0) {
auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::get_snapcontext_finish(&bl_it, &snapc);
}
if (r < 0 && r != -ENOENT) {
derr << "error retrieving snapshot context for image "
<< m_image_id << ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
m_has_snapshots = (!snapc.empty());
purge_snapshots();
}
template <typename I>
void TrashRemoveRequest<I>::purge_snapshots() {
if (!m_has_snapshots) {
remove_image();
return;
}
dout(10) << dendl;
auto ctx = create_context_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_purge_snapshots>(this);
auto req = SnapshotPurgeRequest<I>::create(m_io_ctx, m_image_id, ctx);
req->send();
}
template <typename I>
void TrashRemoveRequest<I>::handle_purge_snapshots(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBUSY) {
dout(10) << "snapshots still in-use" << dendl;
*m_error_result = ERROR_RESULT_RETRY_IMMEDIATELY;
finish(r);
return;
} else if (r < 0) {
derr << "failed to purge image snapshots: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
remove_image();
}
template <typename I>
void TrashRemoveRequest<I>::remove_image() {
dout(10) << dendl;
auto ctx = create_context_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_remove_image>(this);
auto req = librbd::trash::RemoveRequest<I>::create(
m_io_ctx, m_image_id, m_op_work_queue, true, m_progress_ctx,
ctx);
req->send();
}
template <typename I>
void TrashRemoveRequest<I>::handle_remove_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOTEMPTY) {
// image must have clone v2 snapshot still associated to child
dout(10) << "snapshots still in-use" << dendl;
*m_error_result = ERROR_RESULT_RETRY_IMMEDIATELY;
finish(-EBUSY);
return;
}
if (r < 0 && r != -ENOENT) {
derr << "error removing image " << m_image_id << " "
<< "(" << m_image_id << ") from local pool: "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
notify_trash_removed();
}
template <typename I>
void TrashRemoveRequest<I>::notify_trash_removed() {
dout(10) << dendl;
Context *ctx = create_context_callback<
TrashRemoveRequest<I>,
&TrashRemoveRequest<I>::handle_notify_trash_removed>(this);
librbd::TrashWatcher<I>::notify_image_removed(m_io_ctx, m_image_id, ctx);
}
template <typename I>
void TrashRemoveRequest<I>::handle_notify_trash_removed(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to notify trash watchers: " << cpp_strerror(r) << dendl;
}
finish(0);
}
template <typename I>
void TrashRemoveRequest<I>::finish(int r) {
dout(10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_deleter::TrashRemoveRequest<librbd::ImageCtx>;
| 7,343 | 26.609023 | 82 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashRemoveRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_DELETER_TRASH_REMOVE_REQUEST_H
#define CEPH_RBD_MIRROR_IMAGE_DELETER_TRASH_REMOVE_REQUEST_H
#include "include/rados/librados.hpp"
#include "include/buffer.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/internal.h"
#include "tools/rbd_mirror/image_deleter/Types.h"
#include <string>
#include <vector>
class Context;
class ContextWQ;
namespace librbd {
struct ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_deleter {
template <typename ImageCtxT = librbd::ImageCtx>
class TrashRemoveRequest {
public:
static TrashRemoveRequest* create(librados::IoCtx &io_ctx,
const std::string &image_id,
ErrorResult *error_result,
librbd::asio::ContextWQ *op_work_queue,
Context *on_finish) {
return new TrashRemoveRequest(io_ctx, image_id, error_result, op_work_queue,
on_finish);
}
TrashRemoveRequest(librados::IoCtx &io_ctx, const std::string &image_id,
ErrorResult *error_result,
librbd::asio::ContextWQ *op_work_queue,
Context *on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id), m_error_result(error_result),
m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
}
void send();
private:
/*
* @verbatim
*
* <start>
* |
* v
* GET_TRASH_IMAGE_SPEC
* |
* v
* SET_TRASH_STATE
* |
* v
* GET_SNAP_CONTEXT
* |
* v
* PURGE_SNAPSHOTS
* |
* v
* TRASH_REMOVE
* |
* v
* NOTIFY_TRASH_REMOVE
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_image_id;
ErrorResult *m_error_result;
librbd::asio::ContextWQ *m_op_work_queue;
Context *m_on_finish;
ceph::bufferlist m_out_bl;
cls::rbd::TrashImageSpec m_trash_image_spec;
bool m_has_snapshots = false;
librbd::NoOpProgressContext m_progress_ctx;
void get_trash_image_spec();
void handle_get_trash_image_spec(int r);
void set_trash_state();
void handle_set_trash_state(int r);
void get_snap_context();
void handle_get_snap_context(int r);
void purge_snapshots();
void handle_purge_snapshots(int r);
void remove_image();
void handle_remove_image(int r);
void notify_trash_removed();
void handle_notify_trash_removed(int r);
void finish(int r);
};
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_deleter::TrashRemoveRequest<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_DELETER_TRASH_REMOVE_REQUEST_H
| 2,883 | 23.440678 | 87 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashWatcher.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_deleter/TrashWatcher.h"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/Timer.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_deleter/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_deleter::TrashWatcher: " \
<< this << " " << __func__ << ": "
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
namespace rbd {
namespace mirror {
namespace image_deleter {
namespace {
const size_t MAX_RETURN = 1024;
} // anonymous namespace
template <typename I>
TrashWatcher<I>::TrashWatcher(librados::IoCtx &io_ctx, Threads<I> *threads,
TrashListener& trash_listener)
: librbd::TrashWatcher<I>(io_ctx, threads->work_queue),
m_io_ctx(io_ctx), m_threads(threads), m_trash_listener(trash_listener),
m_lock(ceph::make_mutex(librbd::util::unique_lock_name(
"rbd::mirror::image_deleter::TrashWatcher", this))) {
}
template <typename I>
void TrashWatcher<I>::init(Context *on_finish) {
dout(5) << dendl;
{
std::lock_guard locker{m_lock};
m_on_init_finish = on_finish;
ceph_assert(!m_trash_list_in_progress);
m_trash_list_in_progress = true;
}
create_trash();
}
template <typename I>
void TrashWatcher<I>::shut_down(Context *on_finish) {
dout(5) << dendl;
{
std::scoped_lock locker{m_threads->timer_lock, m_lock};
ceph_assert(!m_shutting_down);
m_shutting_down = true;
if (m_timer_ctx != nullptr) {
m_threads->timer->cancel_event(m_timer_ctx);
m_timer_ctx = nullptr;
}
}
auto ctx = new LambdaContext([this, on_finish](int r) {
unregister_watcher(on_finish);
});
m_async_op_tracker.wait_for_ops(ctx);
}
template <typename I>
void TrashWatcher<I>::handle_image_added(const std::string &image_id,
const cls::rbd::TrashImageSpec& spec) {
dout(10) << "image_id=" << image_id << dendl;
std::lock_guard locker{m_lock};
add_image(image_id, spec);
}
template <typename I>
void TrashWatcher<I>::handle_image_removed(const std::string &image_id) {
// ignore removals -- the image deleter will ignore -ENOENTs
}
template <typename I>
void TrashWatcher<I>::handle_rewatch_complete(int r) {
dout(5) << "r=" << r << dendl;
if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted" << dendl;
return;
} else if (r == -ENOENT) {
dout(5) << "trash directory deleted" << dendl;
} else if (r < 0) {
derr << "unexpected error re-registering trash directory watch: "
<< cpp_strerror(r) << dendl;
}
schedule_trash_list(30);
}
template <typename I>
void TrashWatcher<I>::create_trash() {
dout(20) << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
}
librados::ObjectWriteOperation op;
op.create(false);
m_async_op_tracker.start_op();
auto aio_comp = create_rados_callback<
TrashWatcher<I>, &TrashWatcher<I>::handle_create_trash>(this);
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashWatcher<I>::handle_create_trash(int r) {
dout(20) << "r=" << r << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
}
Context* on_init_finish = nullptr;
if (r == -EBLOCKLISTED || r == -ENOENT) {
if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted" << dendl;
} else {
dout(0) << "detected pool no longer exists" << dendl;
}
std::lock_guard locker{m_lock};
std::swap(on_init_finish, m_on_init_finish);
m_trash_list_in_progress = false;
} else if (r < 0 && r != -EEXIST) {
derr << "failed to create trash object: " << cpp_strerror(r) << dendl;
{
std::lock_guard locker{m_lock};
m_trash_list_in_progress = false;
}
schedule_trash_list(30);
} else {
register_watcher();
}
m_async_op_tracker.finish_op();
if (on_init_finish != nullptr) {
on_init_finish->complete(r);
}
}
template <typename I>
void TrashWatcher<I>::register_watcher() {
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
}
// if the watch registration is in-flight, let the watcher
// handle the transition -- only (re-)register if it's not registered
if (!this->is_unregistered()) {
trash_list(true);
return;
}
// first time registering or the watch failed
dout(5) << dendl;
m_async_op_tracker.start_op();
Context *ctx = create_context_callback<
TrashWatcher, &TrashWatcher<I>::handle_register_watcher>(this);
this->register_watch(ctx);
}
template <typename I>
void TrashWatcher<I>::handle_register_watcher(int r) {
dout(5) << "r=" << r << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
if (r < 0) {
m_trash_list_in_progress = false;
}
}
Context *on_init_finish = nullptr;
if (r >= 0) {
trash_list(true);
} else if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted" << dendl;
std::lock_guard locker{m_lock};
std::swap(on_init_finish, m_on_init_finish);
} else {
derr << "unexpected error registering trash directory watch: "
<< cpp_strerror(r) << dendl;
schedule_trash_list(10);
}
m_async_op_tracker.finish_op();
if (on_init_finish != nullptr) {
on_init_finish->complete(r);
}
}
template <typename I>
void TrashWatcher<I>::unregister_watcher(Context* on_finish) {
dout(5) << dendl;
m_async_op_tracker.start_op();
Context *ctx = new LambdaContext([this, on_finish](int r) {
handle_unregister_watcher(r, on_finish);
});
this->unregister_watch(ctx);
}
template <typename I>
void TrashWatcher<I>::handle_unregister_watcher(int r, Context* on_finish) {
dout(5) << "unregister_watcher: r=" << r << dendl;
if (r < 0) {
derr << "error unregistering watcher for trash directory: "
<< cpp_strerror(r) << dendl;
}
m_async_op_tracker.finish_op();
on_finish->complete(0);
}
template <typename I>
void TrashWatcher<I>::trash_list(bool initial_request) {
if (initial_request) {
m_async_op_tracker.start_op();
m_last_image_id = "";
}
dout(5) << "last_image_id=" << m_last_image_id << dendl;
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
}
librados::ObjectReadOperation op;
librbd::cls_client::trash_list_start(&op, m_last_image_id, MAX_RETURN);
librados::AioCompletion *aio_comp = create_rados_callback<
TrashWatcher<I>, &TrashWatcher<I>::handle_trash_list>(this);
m_out_bl.clear();
int r = m_io_ctx.aio_operate(RBD_TRASH, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void TrashWatcher<I>::handle_trash_list(int r) {
dout(5) << "r=" << r << dendl;
std::map<std::string, cls::rbd::TrashImageSpec> images;
if (r >= 0) {
auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::trash_list_finish(&bl_it, &images);
}
Context *on_init_finish = nullptr;
{
std::lock_guard locker{m_lock};
ceph_assert(m_trash_list_in_progress);
if (r >= 0) {
for (auto& image : images) {
add_image(image.first, image.second);
}
} else if (r == -ENOENT) {
r = 0;
}
if (r == -EBLOCKLISTED) {
dout(0) << "detected client is blocklisted during trash refresh" << dendl;
m_trash_list_in_progress = false;
std::swap(on_init_finish, m_on_init_finish);
} else if (r >= 0 && images.size() < MAX_RETURN) {
m_trash_list_in_progress = false;
std::swap(on_init_finish, m_on_init_finish);
} else if (r < 0) {
m_trash_list_in_progress = false;
}
}
if (r >= 0 && images.size() == MAX_RETURN) {
m_last_image_id = images.rbegin()->first;
trash_list(false);
return;
} else if (r < 0 && r != -EBLOCKLISTED) {
derr << "failed to retrieve trash directory: " << cpp_strerror(r) << dendl;
schedule_trash_list(10);
}
m_async_op_tracker.finish_op();
if (on_init_finish != nullptr) {
on_init_finish->complete(r);
}
}
template <typename I>
void TrashWatcher<I>::schedule_trash_list(double interval) {
std::scoped_lock locker{m_threads->timer_lock, m_lock};
if (m_shutting_down || m_trash_list_in_progress || m_timer_ctx != nullptr) {
if (m_trash_list_in_progress && !m_deferred_trash_list) {
dout(5) << "deferring refresh until in-flight refresh completes" << dendl;
m_deferred_trash_list = true;
}
return;
}
dout(5) << dendl;
m_timer_ctx = m_threads->timer->add_event_after(
interval,
new LambdaContext([this](int r) {
process_trash_list();
}));
}
template <typename I>
void TrashWatcher<I>::process_trash_list() {
dout(5) << dendl;
ceph_assert(ceph_mutex_is_locked(m_threads->timer_lock));
ceph_assert(m_timer_ctx != nullptr);
m_timer_ctx = nullptr;
{
std::lock_guard locker{m_lock};
ceph_assert(!m_trash_list_in_progress);
m_trash_list_in_progress = true;
}
// execute outside of the timer's lock
m_async_op_tracker.start_op();
Context *ctx = new LambdaContext([this](int r) {
create_trash();
m_async_op_tracker.finish_op();
});
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
void TrashWatcher<I>::add_image(const std::string& image_id,
const cls::rbd::TrashImageSpec& spec) {
if (spec.source != cls::rbd::TRASH_IMAGE_SOURCE_MIRRORING) {
return;
}
ceph_assert(ceph_mutex_is_locked(m_lock));
auto& deferment_end_time = spec.deferment_end_time;
dout(10) << "image_id=" << image_id << ", "
<< "deferment_end_time=" << deferment_end_time << dendl;
m_async_op_tracker.start_op();
auto ctx = new LambdaContext([this, image_id, deferment_end_time](int r) {
m_trash_listener.handle_trash_image(image_id,
deferment_end_time.to_real_time());
m_async_op_tracker.finish_op();
});
m_threads->work_queue->queue(ctx, 0);
}
} // namespace image_deleter;
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_deleter::TrashWatcher<librbd::ImageCtx>;
| 10,581 | 26.485714 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/TrashWatcher.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_WATCHER_H
#define CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_WATCHER_H
#include "include/rados/librados.hpp"
#include "common/AsyncOpTracker.h"
#include "common/ceph_mutex.h"
#include "librbd/TrashWatcher.h"
#include <set>
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
template <typename> struct Threads;
namespace image_deleter {
struct TrashListener;
template <typename ImageCtxT = librbd::ImageCtx>
class TrashWatcher : public librbd::TrashWatcher<ImageCtxT> {
public:
static TrashWatcher* create(librados::IoCtx &io_ctx,
Threads<ImageCtxT> *threads,
TrashListener& trash_listener) {
return new TrashWatcher(io_ctx, threads, trash_listener);
}
TrashWatcher(librados::IoCtx &io_ctx, Threads<ImageCtxT> *threads,
TrashListener& trash_listener);
TrashWatcher(const TrashWatcher&) = delete;
TrashWatcher& operator=(const TrashWatcher&) = delete;
void init(Context *on_finish);
void shut_down(Context *on_finish);
protected:
void handle_image_added(const std::string &image_id,
const cls::rbd::TrashImageSpec& spec) override;
void handle_image_removed(const std::string &image_id) override;
void handle_rewatch_complete(int r) override;
private:
/**
* @verbatim
*
* <start>
* |
* v
* INIT
* |
* v
* CREATE_TRASH
* |
* v
* REGISTER_WATCHER
* |
* |/--------------------------------\
* | |
* |/---------\ |
* | | |
* v | (more images) |
* TRASH_LIST ---/ |
* | |
* |/----------------------------\ |
* | | |
* v | |
* <idle> --\ | |
* | | | |
* | |\---> IMAGE_ADDED -----/ |
* | | |
* | \----> WATCH_ERROR ---------/
* v
* SHUT_DOWN
* |
* v
* UNREGISTER_WATCHER
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx m_io_ctx;
Threads<ImageCtxT> *m_threads;
TrashListener& m_trash_listener;
std::string m_last_image_id;
bufferlist m_out_bl;
mutable ceph::mutex m_lock;
Context *m_on_init_finish = nullptr;
Context *m_timer_ctx = nullptr;
AsyncOpTracker m_async_op_tracker;
bool m_trash_list_in_progress = false;
bool m_deferred_trash_list = false;
bool m_shutting_down = false;
void register_watcher();
void handle_register_watcher(int r);
void create_trash();
void handle_create_trash(int r);
void unregister_watcher(Context* on_finish);
void handle_unregister_watcher(int r, Context* on_finish);
void trash_list(bool initial_request);
void handle_trash_list(int r);
void schedule_trash_list(double interval);
void process_trash_list();
void get_mirror_uuid();
void handle_get_mirror_uuid(int r);
void add_image(const std::string& image_id,
const cls::rbd::TrashImageSpec& spec);
};
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_deleter::TrashWatcher<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_DELETE_TRASH_WATCHER_H
| 3,602 | 24.735714 | 81 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_deleter/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_DELETER_TYPES_H
#define CEPH_RBD_MIRROR_IMAGE_DELETER_TYPES_H
#include "include/Context.h"
#include "librbd/journal/Policy.h"
#include <string>
struct utime_t;
namespace rbd {
namespace mirror {
namespace image_deleter {
enum ErrorResult {
ERROR_RESULT_COMPLETE,
ERROR_RESULT_RETRY,
ERROR_RESULT_RETRY_IMMEDIATELY
};
struct TrashListener {
TrashListener() {
}
TrashListener(const TrashListener&) = delete;
TrashListener& operator=(const TrashListener&) = delete;
virtual ~TrashListener() {
}
virtual void handle_trash_image(const std::string& image_id,
const ceph::real_clock::time_point& deferment_end_time) = 0;
};
struct JournalPolicy : public librbd::journal::Policy {
bool append_disabled() const override {
return true;
}
bool journal_disabled() const override {
return true;
}
void allocate_tag_on_lock(Context *on_finish) override {
on_finish->complete(0);
}
};
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_DELETER_TYPES_H
| 1,177 | 20.418182 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/LoadRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/Utils.h"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "UpdateRequest.h"
#include "LoadRequest.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_map::LoadRequest: " \
<< this << " " << __func__
namespace rbd {
namespace mirror {
namespace image_map {
static const uint32_t MAX_RETURN = 1024;
using librbd::util::create_rados_callback;
using librbd::util::create_context_callback;
template<typename I>
LoadRequest<I>::LoadRequest(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> *image_mapping,
Context *on_finish)
: m_ioctx(ioctx),
m_image_mapping(image_mapping),
m_on_finish(on_finish) {
}
template<typename I>
void LoadRequest<I>::send() {
dout(20) << dendl;
image_map_list();
}
template<typename I>
void LoadRequest<I>::image_map_list() {
dout(20) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_map_list_start(&op, m_start_after, MAX_RETURN);
librados::AioCompletion *aio_comp = create_rados_callback<
LoadRequest, &LoadRequest::handle_image_map_list>(this);
m_out_bl.clear();
int r = m_ioctx.aio_operate(RBD_MIRROR_LEADER, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template<typename I>
void LoadRequest<I>::handle_image_map_list(int r) {
dout(20) << ": r=" << r << dendl;
std::map<std::string, cls::rbd::MirrorImageMap> image_mapping;
if (r == 0) {
auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_map_list_finish(&it, &image_mapping);
}
if (r < 0) {
derr << ": failed to get image map: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
m_image_mapping->insert(image_mapping.begin(), image_mapping.end());
if (image_mapping.size() == MAX_RETURN) {
m_start_after = image_mapping.rbegin()->first;
image_map_list();
return;
}
mirror_image_list();
}
template<typename I>
void LoadRequest<I>::mirror_image_list() {
dout(20) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_list_start(&op, m_start_after, MAX_RETURN);
m_out_bl.clear();
librados::AioCompletion *aio_comp = create_rados_callback<
LoadRequest<I>,
&LoadRequest<I>::handle_mirror_image_list>(this);
int r = m_ioctx.aio_operate(RBD_MIRRORING, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template<typename I>
void LoadRequest<I>::handle_mirror_image_list(int r) {
dout(20) << ": r=" << r << dendl;
std::map<std::string, std::string> ids;
if (r == 0) {
auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_list_finish(&it, &ids);
}
if (r < 0 && r != -ENOENT) {
derr << "failed to list mirrored images: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
for (auto &id : ids) {
m_global_image_ids.emplace(id.second);
}
if (ids.size() == MAX_RETURN) {
m_start_after = ids.rbegin()->first;
mirror_image_list();
return;
}
cleanup_image_map();
}
template<typename I>
void LoadRequest<I>::cleanup_image_map() {
dout(20) << dendl;
std::set<std::string> map_removals;
auto it = m_image_mapping->begin();
while (it != m_image_mapping->end()) {
if (m_global_image_ids.count(it->first) > 0) {
++it;
continue;
}
map_removals.emplace(it->first);
it = m_image_mapping->erase(it);
}
if (map_removals.size() == 0) {
finish(0);
return;
}
auto ctx = create_context_callback<
LoadRequest<I>,
&LoadRequest<I>::finish>(this);
image_map::UpdateRequest<I> *req = image_map::UpdateRequest<I>::create(
m_ioctx, {}, std::move(map_removals), ctx);
req->send();
}
template<typename I>
void LoadRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_map::LoadRequest<librbd::ImageCtx>;
| 4,296 | 23.554286 | 91 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/LoadRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_LOAD_REQUEST_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_LOAD_REQUEST_H
#include "cls/rbd/cls_rbd_types.h"
#include "include/rados/librados.hpp"
class Context;
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_map {
template<typename ImageCtxT = librbd::ImageCtx>
class LoadRequest {
public:
static LoadRequest *create(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> *image_mapping,
Context *on_finish) {
return new LoadRequest(ioctx, image_mapping, on_finish);
}
void send();
private:
/**
* @verbatim
*
* <start>
* | . . . . . . . .
* v v . MAX_RETURN
* IMAGE_MAP_LIST. . . . . . .
* |
* v
* MIRROR_IMAGE_LIST
* |
* v
* CLEANUP_IMAGE_MAP
* |
* v
* <finish>
*
* @endverbatim
*/
LoadRequest(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> *image_mapping,
Context *on_finish);
librados::IoCtx &m_ioctx;
std::map<std::string, cls::rbd::MirrorImageMap> *m_image_mapping;
Context *m_on_finish;
std::set<std::string> m_global_image_ids;
bufferlist m_out_bl;
std::string m_start_after;
void image_map_list();
void handle_image_map_list(int r);
void mirror_image_list();
void handle_mirror_image_list(int r);
void cleanup_image_map();
void finish(int r);
};
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_LOAD_REQUEST_H
| 1,758 | 21.551282 | 92 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/Policy.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/Utils.h"
#include "Policy.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_map::Policy: " << this \
<< " " << __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_map {
namespace {
bool is_instance_action(ActionType action_type) {
switch (action_type) {
case ACTION_TYPE_ACQUIRE:
case ACTION_TYPE_RELEASE:
return true;
case ACTION_TYPE_NONE:
case ACTION_TYPE_MAP_UPDATE:
case ACTION_TYPE_MAP_REMOVE:
break;
}
return false;
}
} // anonymous namespace
using ::operator<<;
using librbd::util::unique_lock_name;
Policy::Policy(librados::IoCtx &ioctx)
: m_ioctx(ioctx),
m_map_lock(ceph::make_shared_mutex(
unique_lock_name("rbd::mirror::image_map::Policy::m_map_lock", this))) {
// map should at least have once instance
std::string instance_id = stringify(ioctx.get_instance_id());
m_map.emplace(instance_id, std::set<std::string>{});
}
void Policy::init(
const std::map<std::string, cls::rbd::MirrorImageMap> &image_mapping) {
dout(20) << dendl;
std::unique_lock map_lock{m_map_lock};
for (auto& it : image_mapping) {
ceph_assert(!it.second.instance_id.empty());
auto map_result = m_map[it.second.instance_id].emplace(it.first);
ceph_assert(map_result.second);
auto image_state_result = m_image_states.emplace(
it.first, ImageState{it.second.instance_id, it.second.mapped_time});
ceph_assert(image_state_result.second);
// ensure we (re)send image acquire actions to the instance
auto& image_state = image_state_result.first->second;
auto start_action = set_state(&image_state,
StateTransition::STATE_INITIALIZING, false);
ceph_assert(start_action);
}
}
LookupInfo Policy::lookup(const std::string &global_image_id) {
dout(20) << "global_image_id=" << global_image_id << dendl;
std::shared_lock map_lock{m_map_lock};
LookupInfo info;
auto it = m_image_states.find(global_image_id);
if (it != m_image_states.end()) {
info.instance_id = it->second.instance_id;
info.mapped_time = it->second.mapped_time;
}
return info;
}
bool Policy::add_image(const std::string &global_image_id) {
dout(5) << "global_image_id=" << global_image_id << dendl;
std::unique_lock map_lock{m_map_lock};
auto image_state_result = m_image_states.emplace(global_image_id,
ImageState{});
auto& image_state = image_state_result.first->second;
if (image_state.state == StateTransition::STATE_INITIALIZING) {
// avoid duplicate acquire notifications upon leader startup
return false;
}
return set_state(&image_state, StateTransition::STATE_ASSOCIATING, false);
}
bool Policy::remove_image(const std::string &global_image_id) {
dout(5) << "global_image_id=" << global_image_id << dendl;
std::unique_lock map_lock{m_map_lock};
auto it = m_image_states.find(global_image_id);
if (it == m_image_states.end()) {
return false;
}
auto& image_state = it->second;
return set_state(&image_state, StateTransition::STATE_DISSOCIATING, false);
}
void Policy::add_instances(const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids) {
dout(5) << "instance_ids=" << instance_ids << dendl;
std::unique_lock map_lock{m_map_lock};
for (auto& instance : instance_ids) {
ceph_assert(!instance.empty());
m_map.emplace(instance, std::set<std::string>{});
}
// post-failover, remove any dead instances and re-shuffle their images
if (m_initial_update) {
dout(5) << "initial instance update" << dendl;
m_initial_update = false;
std::set<std::string> alive_instances(instance_ids.begin(),
instance_ids.end());
InstanceIds dead_instances;
for (auto& map_pair : m_map) {
if (alive_instances.find(map_pair.first) == alive_instances.end()) {
dead_instances.push_back(map_pair.first);
}
}
if (!dead_instances.empty()) {
remove_instances(m_map_lock, dead_instances, global_image_ids);
}
}
GlobalImageIds shuffle_global_image_ids;
do_shuffle_add_instances(m_map, m_image_states.size(), &shuffle_global_image_ids);
dout(5) << "shuffling global_image_ids=[" << shuffle_global_image_ids
<< "]" << dendl;
for (auto& global_image_id : shuffle_global_image_ids) {
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
if (set_state(&image_state, StateTransition::STATE_SHUFFLING, false)) {
global_image_ids->emplace(global_image_id);
}
}
}
void Policy::remove_instances(const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids) {
std::unique_lock map_lock{m_map_lock};
remove_instances(m_map_lock, instance_ids, global_image_ids);
}
void Policy::remove_instances(const ceph::shared_mutex& lock,
const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids) {
ceph_assert(ceph_mutex_is_wlocked(m_map_lock));
dout(5) << "instance_ids=" << instance_ids << dendl;
for (auto& instance_id : instance_ids) {
auto map_it = m_map.find(instance_id);
if (map_it == m_map.end()) {
continue;
}
auto& instance_global_image_ids = map_it->second;
if (instance_global_image_ids.empty()) {
m_map.erase(map_it);
continue;
}
m_dead_instances.insert(instance_id);
dout(5) << "force shuffling: instance_id=" << instance_id << ", "
<< "global_image_ids=[" << instance_global_image_ids << "]"<< dendl;
for (auto& global_image_id : instance_global_image_ids) {
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
if (is_state_scheduled(image_state,
StateTransition::STATE_DISSOCIATING)) {
// don't shuffle images that no longer exist
continue;
}
if (set_state(&image_state, StateTransition::STATE_SHUFFLING, true)) {
global_image_ids->emplace(global_image_id);
}
}
}
}
ActionType Policy::start_action(const std::string &global_image_id) {
std::unique_lock map_lock{m_map_lock};
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
auto& transition = image_state.transition;
ceph_assert(transition.action_type != ACTION_TYPE_NONE);
dout(5) << "global_image_id=" << global_image_id << ", "
<< "state=" << image_state.state << ", "
<< "action_type=" << transition.action_type << dendl;
if (transition.start_policy_action) {
execute_policy_action(global_image_id, &image_state,
*transition.start_policy_action);
transition.start_policy_action = boost::none;
}
return transition.action_type;
}
bool Policy::finish_action(const std::string &global_image_id, int r) {
std::unique_lock map_lock{m_map_lock};
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
auto& transition = image_state.transition;
dout(5) << "global_image_id=" << global_image_id << ", "
<< "state=" << image_state.state << ", "
<< "action_type=" << transition.action_type << ", "
<< "r=" << r << dendl;
// retry on failure unless it's an RPC message to an instance that is dead
if (r < 0 &&
(!is_instance_action(image_state.transition.action_type) ||
image_state.instance_id == UNMAPPED_INSTANCE_ID ||
m_dead_instances.find(image_state.instance_id) ==
m_dead_instances.end())) {
return true;
}
auto finish_policy_action = transition.finish_policy_action;
StateTransition::transit(image_state.state, &image_state.transition);
if (transition.finish_state) {
// in-progress state machine complete
ceph_assert(StateTransition::is_idle(*transition.finish_state));
image_state.state = *transition.finish_state;
image_state.transition = {};
}
if (StateTransition::is_idle(image_state.state) && image_state.next_state) {
// advance to pending state machine
bool start_action = set_state(&image_state, *image_state.next_state, false);
ceph_assert(start_action);
}
// image state may get purged in execute_policy_action()
bool pending_action = image_state.transition.action_type != ACTION_TYPE_NONE;
if (finish_policy_action) {
execute_policy_action(global_image_id, &image_state, *finish_policy_action);
}
return pending_action;
}
void Policy::execute_policy_action(
const std::string& global_image_id, ImageState* image_state,
StateTransition::PolicyAction policy_action) {
dout(5) << "global_image_id=" << global_image_id << ", "
<< "policy_action=" << policy_action << dendl;
switch (policy_action) {
case StateTransition::POLICY_ACTION_MAP:
map(global_image_id, image_state);
break;
case StateTransition::POLICY_ACTION_UNMAP:
unmap(global_image_id, image_state);
break;
case StateTransition::POLICY_ACTION_REMOVE:
if (image_state->state == StateTransition::STATE_UNASSOCIATED) {
ceph_assert(image_state->instance_id == UNMAPPED_INSTANCE_ID);
ceph_assert(!image_state->next_state);
m_image_states.erase(global_image_id);
}
break;
}
}
void Policy::map(const std::string& global_image_id, ImageState* image_state) {
ceph_assert(ceph_mutex_is_wlocked(m_map_lock));
std::string instance_id = image_state->instance_id;
if (instance_id != UNMAPPED_INSTANCE_ID && !is_dead_instance(instance_id)) {
return;
}
if (is_dead_instance(instance_id)) {
unmap(global_image_id, image_state);
}
instance_id = do_map(m_map, global_image_id);
ceph_assert(!instance_id.empty());
dout(5) << "global_image_id=" << global_image_id << ", "
<< "instance_id=" << instance_id << dendl;
image_state->instance_id = instance_id;
image_state->mapped_time = ceph_clock_now();
auto ins = m_map[instance_id].emplace(global_image_id);
ceph_assert(ins.second);
}
void Policy::unmap(const std::string &global_image_id,
ImageState* image_state) {
ceph_assert(ceph_mutex_is_wlocked(m_map_lock));
std::string instance_id = image_state->instance_id;
if (instance_id == UNMAPPED_INSTANCE_ID) {
return;
}
dout(5) << "global_image_id=" << global_image_id << ", "
<< "instance_id=" << instance_id << dendl;
ceph_assert(!instance_id.empty());
m_map[instance_id].erase(global_image_id);
image_state->instance_id = UNMAPPED_INSTANCE_ID;
image_state->mapped_time = {};
if (is_dead_instance(instance_id) && m_map[instance_id].empty()) {
dout(5) << "removing dead instance_id=" << instance_id << dendl;
m_map.erase(instance_id);
m_dead_instances.erase(instance_id);
}
}
bool Policy::is_image_shuffling(const std::string &global_image_id) {
ceph_assert(ceph_mutex_is_locked(m_map_lock));
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
// avoid attempting to re-shuffle a pending shuffle
auto result = is_state_scheduled(image_state,
StateTransition::STATE_SHUFFLING);
dout(20) << "global_image_id=" << global_image_id << ", "
<< "result=" << result << dendl;
return result;
}
bool Policy::can_shuffle_image(const std::string &global_image_id) {
ceph_assert(ceph_mutex_is_locked(m_map_lock));
CephContext *cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
int migration_throttle = cct->_conf.get_val<uint64_t>(
"rbd_mirror_image_policy_migration_throttle");
auto it = m_image_states.find(global_image_id);
ceph_assert(it != m_image_states.end());
auto& image_state = it->second;
utime_t last_shuffled_time = image_state.mapped_time;
// idle images that haven't been recently remapped can shuffle
utime_t now = ceph_clock_now();
auto result = (StateTransition::is_idle(image_state.state) &&
((migration_throttle <= 0) ||
(now - last_shuffled_time >= migration_throttle)));
dout(10) << "global_image_id=" << global_image_id << ", "
<< "migration_throttle=" << migration_throttle << ", "
<< "last_shuffled_time=" << last_shuffled_time << ", "
<< "result=" << result << dendl;
return result;
}
bool Policy::set_state(ImageState* image_state, StateTransition::State state,
bool ignore_current_state) {
if (!ignore_current_state && image_state->state == state) {
image_state->next_state = boost::none;
return false;
} else if (StateTransition::is_idle(image_state->state)) {
image_state->state = state;
image_state->next_state = boost::none;
StateTransition::transit(image_state->state, &image_state->transition);
ceph_assert(image_state->transition.action_type != ACTION_TYPE_NONE);
ceph_assert(!image_state->transition.finish_state);
return true;
}
image_state->next_state = state;
return false;
}
bool Policy::is_state_scheduled(const ImageState& image_state,
StateTransition::State state) const {
return (image_state.state == state ||
(image_state.next_state && *image_state.next_state == state));
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
| 13,796 | 32.816176 | 84 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/Policy.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_POLICY_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_POLICY_H
#include <map>
#include <tuple>
#include <boost/optional.hpp>
#include "cls/rbd/cls_rbd_types.h"
#include "include/rados/librados.hpp"
#include "tools/rbd_mirror/image_map/StateTransition.h"
#include "tools/rbd_mirror/image_map/Types.h"
class Context;
namespace rbd {
namespace mirror {
namespace image_map {
class Policy {
public:
Policy(librados::IoCtx &ioctx);
virtual ~Policy() {
}
// init -- called during initialization
void init(
const std::map<std::string, cls::rbd::MirrorImageMap> &image_mapping);
// lookup an image from the map
LookupInfo lookup(const std::string &global_image_id);
// add, remove
bool add_image(const std::string &global_image_id);
bool remove_image(const std::string &global_image_id);
// shuffle images when instances are added/removed
void add_instances(const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids);
void remove_instances(const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids);
ActionType start_action(const std::string &global_image_id);
bool finish_action(const std::string &global_image_id, int r);
protected:
typedef std::map<std::string, std::set<std::string> > InstanceToImageMap;
bool is_dead_instance(const std::string instance_id) {
ceph_assert(ceph_mutex_is_locked(m_map_lock));
return m_dead_instances.find(instance_id) != m_dead_instances.end();
}
bool is_image_shuffling(const std::string &global_image_id);
bool can_shuffle_image(const std::string &global_image_id);
// map an image (global image id) to an instance
virtual std::string do_map(const InstanceToImageMap& map,
const std::string &global_image_id) = 0;
// shuffle images when instances are added/removed
virtual void do_shuffle_add_instances(
const InstanceToImageMap& map, size_t image_count,
std::set<std::string> *remap_global_image_ids) = 0;
private:
struct ImageState {
std::string instance_id = UNMAPPED_INSTANCE_ID;
utime_t mapped_time;
ImageState() {}
ImageState(const std::string& instance_id, const utime_t& mapped_time)
: instance_id(instance_id), mapped_time(mapped_time) {
}
// active state and action
StateTransition::State state = StateTransition::STATE_UNASSOCIATED;
StateTransition::Transition transition;
// next scheduled state
boost::optional<StateTransition::State> next_state = boost::none;
};
typedef std::map<std::string, ImageState> ImageStates;
librados::IoCtx &m_ioctx;
ceph::shared_mutex m_map_lock; // protects m_map
InstanceToImageMap m_map; // instance_id -> global_id map
ImageStates m_image_states;
std::set<std::string> m_dead_instances;
bool m_initial_update = true;
void remove_instances(const ceph::shared_mutex& lock,
const InstanceIds &instance_ids,
GlobalImageIds* global_image_ids);
bool set_state(ImageState* image_state, StateTransition::State state,
bool ignore_current_state);
void execute_policy_action(const std::string& global_image_id,
ImageState* image_state,
StateTransition::PolicyAction policy_action);
void map(const std::string& global_image_id, ImageState* image_state);
void unmap(const std::string &global_image_id, ImageState* image_state);
bool is_state_scheduled(const ImageState& image_state,
StateTransition::State state) const;
};
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_POLICY_H
| 3,826 | 30.113821 | 76 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/SimplePolicy.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/debug.h"
#include "common/errno.h"
#include "SimplePolicy.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_map::SimplePolicy: " << this \
<< " " << __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_map {
SimplePolicy::SimplePolicy(librados::IoCtx &ioctx)
: Policy(ioctx) {
}
size_t SimplePolicy::calc_images_per_instance(const InstanceToImageMap& map,
size_t image_count) {
size_t nr_instances = 0;
for (auto const &it : map) {
if (!Policy::is_dead_instance(it.first)) {
++nr_instances;
}
}
ceph_assert(nr_instances > 0);
size_t images_per_instance = image_count / nr_instances;
if (images_per_instance == 0) {
++images_per_instance;
}
return images_per_instance;
}
void SimplePolicy::do_shuffle_add_instances(
const InstanceToImageMap& map, size_t image_count,
std::set<std::string> *remap_global_image_ids) {
uint64_t images_per_instance = calc_images_per_instance(map, image_count);
dout(5) << "images per instance=" << images_per_instance << dendl;
for (auto const &instance : map) {
if (instance.second.size() <= images_per_instance) {
continue;
}
auto it = instance.second.begin();
uint64_t cut_off = instance.second.size() - images_per_instance;
while (it != instance.second.end() && cut_off > 0) {
if (Policy::is_image_shuffling(*it)) {
--cut_off;
} else if (Policy::can_shuffle_image(*it)) {
--cut_off;
remap_global_image_ids->emplace(*it);
}
++it;
}
}
}
std::string SimplePolicy::do_map(const InstanceToImageMap& map,
const std::string &global_image_id) {
auto min_it = map.end();
for (auto it = map.begin(); it != map.end(); ++it) {
ceph_assert(it->second.find(global_image_id) == it->second.end());
if (Policy::is_dead_instance(it->first)) {
continue;
} else if (min_it == map.end()) {
min_it = it;
} else if (it->second.size() < min_it->second.size()) {
min_it = it;
}
}
ceph_assert(min_it != map.end());
dout(20) << "global_image_id=" << global_image_id << " maps to instance_id="
<< min_it->first << dendl;
return min_it->first;
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
| 2,559 | 27.444444 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/SimplePolicy.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_SIMPLE_POLICY_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_SIMPLE_POLICY_H
#include "Policy.h"
namespace rbd {
namespace mirror {
namespace image_map {
class SimplePolicy : public Policy {
public:
static SimplePolicy *create(librados::IoCtx &ioctx) {
return new SimplePolicy(ioctx);
}
protected:
SimplePolicy(librados::IoCtx &ioctx);
std::string do_map(const InstanceToImageMap& map,
const std::string &global_image_id) override;
void do_shuffle_add_instances(
const InstanceToImageMap& map, size_t image_count,
std::set<std::string> *remap_global_image_ids) override;
private:
size_t calc_images_per_instance(const InstanceToImageMap& map,
size_t image_count);
};
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_SIMPLE_POLICY_H
| 1,000 | 24.025 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/StateTransition.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <ostream>
#include "include/ceph_assert.h"
#include "StateTransition.h"
namespace rbd {
namespace mirror {
namespace image_map {
std::ostream &operator<<(std::ostream &os,
const StateTransition::State &state) {
switch(state) {
case StateTransition::STATE_INITIALIZING:
os << "INITIALIZING";
break;
case StateTransition::STATE_ASSOCIATING:
os << "ASSOCIATING";
break;
case StateTransition::STATE_ASSOCIATED:
os << "ASSOCIATED";
break;
case StateTransition::STATE_SHUFFLING:
os << "SHUFFLING";
break;
case StateTransition::STATE_DISSOCIATING:
os << "DISSOCIATING";
break;
case StateTransition::STATE_UNASSOCIATED:
os << "UNASSOCIATED";
break;
}
return os;
}
std::ostream &operator<<(std::ostream &os,
const StateTransition::PolicyAction &policy_action) {
switch(policy_action) {
case StateTransition::POLICY_ACTION_MAP:
os << "MAP";
break;
case StateTransition::POLICY_ACTION_UNMAP:
os << "UNMAP";
break;
case StateTransition::POLICY_ACTION_REMOVE:
os << "REMOVE";
break;
}
return os;
}
const StateTransition::TransitionTable StateTransition::s_transition_table {
// state current_action Transition
// ---------------------------------------------------------------------------
{{STATE_INITIALIZING, ACTION_TYPE_NONE}, {ACTION_TYPE_ACQUIRE, {}, {},
{}}},
{{STATE_INITIALIZING, ACTION_TYPE_ACQUIRE}, {ACTION_TYPE_NONE, {}, {},
{STATE_ASSOCIATED}}},
{{STATE_ASSOCIATING, ACTION_TYPE_NONE}, {ACTION_TYPE_MAP_UPDATE,
{POLICY_ACTION_MAP}, {}, {}}},
{{STATE_ASSOCIATING, ACTION_TYPE_MAP_UPDATE}, {ACTION_TYPE_ACQUIRE, {}, {},
{}}},
{{STATE_ASSOCIATING, ACTION_TYPE_ACQUIRE}, {ACTION_TYPE_NONE, {}, {},
{STATE_ASSOCIATED}}},
{{STATE_DISSOCIATING, ACTION_TYPE_NONE}, {ACTION_TYPE_RELEASE, {},
{POLICY_ACTION_UNMAP}, {}}},
{{STATE_DISSOCIATING, ACTION_TYPE_RELEASE}, {ACTION_TYPE_MAP_REMOVE, {},
{POLICY_ACTION_REMOVE}, {}}},
{{STATE_DISSOCIATING, ACTION_TYPE_MAP_REMOVE}, {ACTION_TYPE_NONE, {},
{}, {STATE_UNASSOCIATED}}},
{{STATE_SHUFFLING, ACTION_TYPE_NONE}, {ACTION_TYPE_RELEASE, {},
{POLICY_ACTION_UNMAP}, {}}},
{{STATE_SHUFFLING, ACTION_TYPE_RELEASE}, {ACTION_TYPE_MAP_UPDATE,
{POLICY_ACTION_MAP}, {}, {}}},
{{STATE_SHUFFLING, ACTION_TYPE_MAP_UPDATE}, {ACTION_TYPE_ACQUIRE, {}, {},
{}}},
{{STATE_SHUFFLING, ACTION_TYPE_ACQUIRE}, {ACTION_TYPE_NONE, {}, {},
{STATE_ASSOCIATED}}}
};
void StateTransition::transit(State state, Transition* transition) {
auto it = s_transition_table.find({state, transition->action_type});
ceph_assert(it != s_transition_table.end());
*transition = it->second;
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
| 3,531 | 36.178947 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/StateTransition.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_STATE_TRANSITION_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_STATE_TRANSITION_H
#include "tools/rbd_mirror/image_map/Types.h"
#include <boost/optional.hpp>
#include <map>
namespace rbd {
namespace mirror {
namespace image_map {
class StateTransition {
public:
enum State {
STATE_UNASSOCIATED,
STATE_INITIALIZING,
STATE_ASSOCIATING,
STATE_ASSOCIATED,
STATE_SHUFFLING,
STATE_DISSOCIATING
};
enum PolicyAction {
POLICY_ACTION_MAP,
POLICY_ACTION_UNMAP,
POLICY_ACTION_REMOVE
};
struct Transition {
// image map action
ActionType action_type = ACTION_TYPE_NONE;
// policy internal action
boost::optional<PolicyAction> start_policy_action;
boost::optional<PolicyAction> finish_policy_action;
// state machine complete
boost::optional<State> finish_state;
Transition() {
}
Transition(ActionType action_type,
const boost::optional<PolicyAction>& start_policy_action,
const boost::optional<PolicyAction>& finish_policy_action,
const boost::optional<State>& finish_state)
: action_type(action_type), start_policy_action(start_policy_action),
finish_policy_action(finish_policy_action), finish_state(finish_state) {
}
};
static bool is_idle(State state) {
return (state == STATE_UNASSOCIATED || state == STATE_ASSOCIATED);
}
static void transit(State state, Transition* transition);
private:
typedef std::pair<State, ActionType> TransitionKey;
typedef std::map<TransitionKey, Transition> TransitionTable;
// image transition table
static const TransitionTable s_transition_table;
};
std::ostream &operator<<(std::ostream &os, const StateTransition::State &state);
std::ostream &operator<<(std::ostream &os,
const StateTransition::PolicyAction &policy_action);
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_STATE_TRANSITION_H
| 2,103 | 26.324675 | 80 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Types.h"
#include "include/ceph_assert.h"
#include "include/stringify.h"
#include "common/Formatter.h"
#include <iostream>
namespace rbd {
namespace mirror {
namespace image_map {
const std::string UNMAPPED_INSTANCE_ID("");
namespace {
template <typename E>
class GetTypeVisitor : public boost::static_visitor<E> {
public:
template <typename T>
inline E operator()(const T&) const {
return T::TYPE;
}
};
class EncodeVisitor : public boost::static_visitor<void> {
public:
explicit EncodeVisitor(bufferlist &bl) : m_bl(bl) {
}
template <typename T>
inline void operator()(const T& t) const {
using ceph::encode;
encode(static_cast<uint32_t>(T::TYPE), m_bl);
t.encode(m_bl);
}
private:
bufferlist &m_bl;
};
class DecodeVisitor : public boost::static_visitor<void> {
public:
DecodeVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {
}
template <typename T>
inline void operator()(T& t) const {
t.decode(m_version, m_iter);
}
private:
__u8 m_version;
bufferlist::const_iterator &m_iter;
};
class DumpVisitor : public boost::static_visitor<void> {
public:
explicit DumpVisitor(Formatter *formatter, const std::string &key)
: m_formatter(formatter), m_key(key) {}
template <typename T>
inline void operator()(const T& t) const {
auto type = T::TYPE;
m_formatter->dump_string(m_key.c_str(), stringify(type));
t.dump(m_formatter);
}
private:
ceph::Formatter *m_formatter;
std::string m_key;
};
} // anonymous namespace
PolicyMetaType PolicyData::get_policy_meta_type() const {
return boost::apply_visitor(GetTypeVisitor<PolicyMetaType>(), policy_meta);
}
void PolicyData::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
boost::apply_visitor(EncodeVisitor(bl), policy_meta);
ENCODE_FINISH(bl);
}
void PolicyData::decode(bufferlist::const_iterator& it) {
DECODE_START(1, it);
uint32_t policy_meta_type;
decode(policy_meta_type, it);
switch (policy_meta_type) {
case POLICY_META_TYPE_NONE:
policy_meta = PolicyMetaNone();
break;
default:
policy_meta = PolicyMetaUnknown();
break;
}
boost::apply_visitor(DecodeVisitor(struct_v, it), policy_meta);
DECODE_FINISH(it);
}
void PolicyData::dump(Formatter *f) const {
boost::apply_visitor(DumpVisitor(f, "policy_meta_type"), policy_meta);
}
void PolicyData::generate_test_instances(std::list<PolicyData *> &o) {
o.push_back(new PolicyData(PolicyMetaNone()));
}
std::ostream &operator<<(std::ostream &os, const ActionType& action_type) {
switch (action_type) {
case ACTION_TYPE_NONE:
os << "NONE";
break;
case ACTION_TYPE_MAP_UPDATE:
os << "MAP_UPDATE";
break;
case ACTION_TYPE_MAP_REMOVE:
os << "MAP_REMOVE";
break;
case ACTION_TYPE_ACQUIRE:
os << "ACQUIRE";
break;
case ACTION_TYPE_RELEASE:
os << "RELEASE";
break;
default:
os << "UNKNOWN (" << static_cast<uint32_t>(action_type) << ")";
break;
}
return os;
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
| 3,182 | 21.899281 | 77 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_TYPES_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_TYPES_H
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <boost/variant.hpp>
#include "include/buffer.h"
#include "include/encoding.h"
#include "include/utime.h"
#include "tools/rbd_mirror/Types.h"
struct Context;
namespace ceph {
class Formatter;
}
namespace rbd {
namespace mirror {
namespace image_map {
extern const std::string UNMAPPED_INSTANCE_ID;
struct Listener {
virtual ~Listener() {
}
virtual void acquire_image(const std::string &global_image_id,
const std::string &instance_id,
Context* on_finish) = 0;
virtual void release_image(const std::string &global_image_id,
const std::string &instance_id,
Context* on_finish) = 0;
virtual void remove_image(const std::string &mirror_uuid,
const std::string &global_image_id,
const std::string &instance_id,
Context* on_finish) = 0;
};
struct LookupInfo {
std::string instance_id = UNMAPPED_INSTANCE_ID;
utime_t mapped_time;
};
enum ActionType {
ACTION_TYPE_NONE,
ACTION_TYPE_MAP_UPDATE,
ACTION_TYPE_MAP_REMOVE,
ACTION_TYPE_ACQUIRE,
ACTION_TYPE_RELEASE
};
typedef std::vector<std::string> InstanceIds;
typedef std::set<std::string> GlobalImageIds;
typedef std::map<std::string, ActionType> ImageActionTypes;
enum PolicyMetaType {
POLICY_META_TYPE_NONE = 0,
};
struct PolicyMetaNone {
static const PolicyMetaType TYPE = POLICY_META_TYPE_NONE;
PolicyMetaNone() {
}
void encode(bufferlist& bl) const {
}
void decode(__u8 version, bufferlist::const_iterator& it) {
}
void dump(Formatter *f) const {
}
};
struct PolicyMetaUnknown {
static const PolicyMetaType TYPE = static_cast<PolicyMetaType>(-1);
PolicyMetaUnknown() {
}
void encode(bufferlist& bl) const {
ceph_abort();
}
void decode(__u8 version, bufferlist::const_iterator& it) {
}
void dump(Formatter *f) const {
}
};
typedef boost::variant<PolicyMetaNone,
PolicyMetaUnknown> PolicyMeta;
struct PolicyData {
PolicyData()
: policy_meta(PolicyMetaUnknown()) {
}
PolicyData(const PolicyMeta &policy_meta)
: policy_meta(policy_meta) {
}
PolicyMeta policy_meta;
PolicyMetaType get_policy_meta_type() const;
void encode(bufferlist& bl) const;
void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<PolicyData *> &o);
};
WRITE_CLASS_ENCODER(PolicyData);
std::ostream &operator<<(std::ostream &os, const ActionType &action_type);
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_TYPES_H
| 2,955 | 21.564885 | 74 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_map/UpdateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/Utils.h"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_client.h"
#include "UpdateRequest.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_map::UpdateRequest: " \
<< this << " " << __func__
namespace rbd {
namespace mirror {
namespace image_map {
using librbd::util::create_rados_callback;
static const uint32_t MAX_UPDATE = 256;
template <typename I>
UpdateRequest<I>::UpdateRequest(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> &&update_mapping,
std::set<std::string> &&remove_global_image_ids, Context *on_finish)
: m_ioctx(ioctx),
m_update_mapping(update_mapping),
m_remove_global_image_ids(remove_global_image_ids),
m_on_finish(on_finish) {
}
template <typename I>
void UpdateRequest<I>::send() {
dout(20) << dendl;
update_image_map();
}
template <typename I>
void UpdateRequest<I>::update_image_map() {
dout(20) << dendl;
if (m_update_mapping.empty() && m_remove_global_image_ids.empty()) {
finish(0);
return;
}
uint32_t nr_updates = 0;
librados::ObjectWriteOperation op;
auto it1 = m_update_mapping.begin();
while (it1 != m_update_mapping.end() && nr_updates++ < MAX_UPDATE) {
librbd::cls_client::mirror_image_map_update(&op, it1->first, it1->second);
it1 = m_update_mapping.erase(it1);
}
auto it2 = m_remove_global_image_ids.begin();
while (it2 != m_remove_global_image_ids.end() && nr_updates++ < MAX_UPDATE) {
librbd::cls_client::mirror_image_map_remove(&op, *it2);
it2 = m_remove_global_image_ids.erase(it2);
}
librados::AioCompletion *aio_comp = create_rados_callback<
UpdateRequest, &UpdateRequest::handle_update_image_map>(this);
int r = m_ioctx.aio_operate(RBD_MIRROR_LEADER, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void UpdateRequest<I>::handle_update_image_map(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to update image map: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
update_image_map();
}
template <typename I>
void UpdateRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_map
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_map::UpdateRequest<librbd::ImageCtx>;
| 2,686 | 25.60396 | 100 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_map/UpdateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_MAP_UPDATE_REQUEST_H
#define CEPH_RBD_MIRROR_IMAGE_MAP_UPDATE_REQUEST_H
#include "cls/rbd/cls_rbd_types.h"
#include "include/rados/librados.hpp"
class Context;
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_map {
template<typename ImageCtxT = librbd::ImageCtx>
class UpdateRequest {
public:
// accepts an image map for updation and a collection of
// global image ids to purge.
static UpdateRequest *create(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> &&update_mapping,
std::set<std::string> &&remove_global_image_ids, Context *on_finish) {
return new UpdateRequest(ioctx, std::move(update_mapping), std::move(remove_global_image_ids),
on_finish);
}
void send();
private:
/**
* @verbatim
*
* <start>
* | . . . . . . . .
* v v . MAX_UPDATE
* UPDATE_IMAGE_MAP. . . . . . .
* |
* v
* <finish>
*
* @endverbatim
*/
UpdateRequest(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> &&update_mapping,
std::set<std::string> &&remove_global_image_ids, Context *on_finish);
librados::IoCtx &m_ioctx;
std::map<std::string, cls::rbd::MirrorImageMap> m_update_mapping;
std::set<std::string> m_remove_global_image_ids;
Context *m_on_finish;
void update_image_map();
void handle_update_image_map(int r);
void finish(int r);
};
} // namespace image_map
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_UPDATE_REQUEST_H
| 1,811 | 26.454545 | 101 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/BootstrapRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/compat.h"
#include "BootstrapRequest.h"
#include "CreateImageRequest.h"
#include "OpenImageRequest.h"
#include "OpenLocalImageRequest.h"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "journal/Journaler.h"
#include "journal/Settings.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/internal.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/Types.h"
#include "tools/rbd_mirror/BaseRequest.h"
#include "tools/rbd_mirror/ImageSync.h"
#include "tools/rbd_mirror/ProgressContext.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#include "tools/rbd_mirror/image_replayer/journal/SyncPointHandler.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::" \
<< "BootstrapRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_context_callback;
using librbd::util::unique_lock_name;
template <typename I>
BootstrapRequest<I>::BootstrapRequest(
Threads<I>* threads,
librados::IoCtx& local_io_ctx,
librados::IoCtx& remote_io_ctx,
InstanceWatcher<I>* instance_watcher,
const std::string& global_image_id,
const std::string& local_mirror_uuid,
const RemotePoolMeta& remote_pool_meta,
::journal::CacheManagerHandler* cache_manager_handler,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<I>** state_builder,
bool* do_resync,
Context* on_finish)
: CancelableRequest("rbd::mirror::image_replayer::BootstrapRequest",
reinterpret_cast<CephContext*>(local_io_ctx.cct()),
on_finish),
m_threads(threads),
m_local_io_ctx(local_io_ctx),
m_remote_io_ctx(remote_io_ctx),
m_instance_watcher(instance_watcher),
m_global_image_id(global_image_id),
m_local_mirror_uuid(local_mirror_uuid),
m_remote_pool_meta(remote_pool_meta),
m_cache_manager_handler(cache_manager_handler),
m_pool_meta_cache(pool_meta_cache),
m_progress_ctx(progress_ctx),
m_state_builder(state_builder),
m_do_resync(do_resync),
m_lock(ceph::make_mutex(unique_lock_name("BootstrapRequest::m_lock",
this))) {
dout(10) << dendl;
}
template <typename I>
bool BootstrapRequest<I>::is_syncing() const {
std::lock_guard locker{m_lock};
return (m_image_sync != nullptr);
}
template <typename I>
void BootstrapRequest<I>::send() {
*m_do_resync = false;
prepare_local_image();
}
template <typename I>
void BootstrapRequest<I>::cancel() {
dout(10) << dendl;
std::lock_guard locker{m_lock};
m_canceled = true;
if (m_image_sync != nullptr) {
m_image_sync->cancel();
}
}
template <typename I>
std::string BootstrapRequest<I>::get_local_image_name() const {
std::unique_lock locker{m_lock};
return m_local_image_name;
}
template <typename I>
void BootstrapRequest<I>::prepare_local_image() {
dout(10) << dendl;
update_progress("PREPARE_LOCAL_IMAGE");
{
std::unique_lock locker{m_lock};
m_local_image_name = m_global_image_id;
}
ceph_assert(*m_state_builder == nullptr);
auto ctx = create_context_callback<
BootstrapRequest, &BootstrapRequest<I>::handle_prepare_local_image>(this);
auto req = image_replayer::PrepareLocalImageRequest<I>::create(
m_local_io_ctx, m_global_image_id, &m_prepare_local_image_name,
m_state_builder, m_threads->work_queue, ctx);
req->send();
}
template <typename I>
void BootstrapRequest<I>::handle_prepare_local_image(int r) {
dout(10) << "r=" << r << dendl;
ceph_assert(r < 0 || *m_state_builder != nullptr);
if (r == -ENOENT) {
dout(10) << "local image does not exist" << dendl;
} else if (r < 0) {
derr << "error preparing local image for replay: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
// image replayer will detect the name change (if any) at next
// status update
if (r >= 0 && !m_prepare_local_image_name.empty()) {
std::unique_lock locker{m_lock};
m_local_image_name = m_prepare_local_image_name;
}
prepare_remote_image();
}
template <typename I>
void BootstrapRequest<I>::prepare_remote_image() {
dout(10) << dendl;
update_progress("PREPARE_REMOTE_IMAGE");
Context *ctx = create_context_callback<
BootstrapRequest, &BootstrapRequest<I>::handle_prepare_remote_image>(this);
auto req = image_replayer::PrepareRemoteImageRequest<I>::create(
m_threads, m_local_io_ctx, m_remote_io_ctx, m_global_image_id,
m_local_mirror_uuid, m_remote_pool_meta, m_cache_manager_handler,
m_state_builder, ctx);
req->send();
}
template <typename I>
void BootstrapRequest<I>::handle_prepare_remote_image(int r) {
dout(10) << "r=" << r << dendl;
auto state_builder = *m_state_builder;
ceph_assert(state_builder == nullptr ||
!state_builder->remote_mirror_uuid.empty());
if (state_builder != nullptr && state_builder->is_local_primary()) {
dout(5) << "local image is primary" << dendl;
finish(-ENOMSG);
return;
} else if (r == -ENOENT || state_builder == nullptr) {
dout(10) << "remote image does not exist";
if (state_builder != nullptr) {
*_dout << ": "
<< "local_image_id=" << state_builder->local_image_id << ", "
<< "remote_image_id=" << state_builder->remote_image_id << ", "
<< "is_linked=" << state_builder->is_linked();
}
*_dout << dendl;
// TODO need to support multiple remote images
if (state_builder != nullptr &&
state_builder->remote_image_id.empty() &&
(state_builder->local_image_id.empty() ||
state_builder->is_linked())) {
// both images doesn't exist or local image exists and is non-primary
// and linked to the missing remote image
finish(-ENOLINK);
} else {
finish(-ENOENT);
}
return;
} else if (r < 0) {
derr << "error preparing remote image for replay: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
if (!state_builder->is_remote_primary()) {
ceph_assert(!state_builder->remote_image_id.empty());
if (state_builder->local_image_id.empty()) {
dout(10) << "local image does not exist and remote image is not primary"
<< dendl;
finish(-EREMOTEIO);
return;
} else if (!state_builder->is_linked()) {
dout(10) << "local image is unlinked and remote image is not primary"
<< dendl;
finish(-EREMOTEIO);
return;
}
// if the local image is linked to the remote image, we ignore that
// the remote image is not primary so that we can replay demotion
}
open_remote_image();
}
template <typename I>
void BootstrapRequest<I>::open_remote_image() {
ceph_assert(*m_state_builder != nullptr);
auto remote_image_id = (*m_state_builder)->remote_image_id;
dout(15) << "remote_image_id=" << remote_image_id << dendl;
update_progress("OPEN_REMOTE_IMAGE");
auto ctx = create_context_callback<
BootstrapRequest<I>,
&BootstrapRequest<I>::handle_open_remote_image>(this);
ceph_assert(*m_state_builder != nullptr);
OpenImageRequest<I> *request = OpenImageRequest<I>::create(
m_remote_io_ctx, &(*m_state_builder)->remote_image_ctx, remote_image_id,
false, ctx);
request->send();
}
template <typename I>
void BootstrapRequest<I>::handle_open_remote_image(int r) {
dout(15) << "r=" << r << dendl;
ceph_assert(*m_state_builder != nullptr);
if (r < 0) {
derr << "failed to open remote image: " << cpp_strerror(r) << dendl;
ceph_assert((*m_state_builder)->remote_image_ctx == nullptr);
finish(r);
return;
}
if ((*m_state_builder)->local_image_id.empty()) {
create_local_image();
return;
}
open_local_image();
}
template <typename I>
void BootstrapRequest<I>::open_local_image() {
ceph_assert(*m_state_builder != nullptr);
auto local_image_id = (*m_state_builder)->local_image_id;
dout(15) << "local_image_id=" << local_image_id << dendl;
update_progress("OPEN_LOCAL_IMAGE");
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_open_local_image>(
this);
OpenLocalImageRequest<I> *request = OpenLocalImageRequest<I>::create(
m_local_io_ctx, &(*m_state_builder)->local_image_ctx, local_image_id,
m_threads->work_queue, ctx);
request->send();
}
template <typename I>
void BootstrapRequest<I>::handle_open_local_image(int r) {
dout(15) << "r=" << r << dendl;
ceph_assert(*m_state_builder != nullptr);
auto local_image_ctx = (*m_state_builder)->local_image_ctx;
ceph_assert((r >= 0 && local_image_ctx != nullptr) ||
(r < 0 && local_image_ctx == nullptr));
if (r == -ENOENT) {
dout(10) << "local image missing" << dendl;
create_local_image();
return;
} else if (r == -EREMOTEIO) {
dout(10) << "local image is primary -- skipping image replay" << dendl;
m_ret_val = r;
close_remote_image();
return;
} else if (r < 0) {
derr << "failed to open local image: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_remote_image();
return;
}
prepare_replay();
}
template <typename I>
void BootstrapRequest<I>::prepare_replay() {
dout(10) << dendl;
update_progress("PREPARE_REPLAY");
ceph_assert(*m_state_builder != nullptr);
auto ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_prepare_replay>(this);
auto request = (*m_state_builder)->create_prepare_replay_request(
m_local_mirror_uuid, m_progress_ctx, m_do_resync, &m_syncing, ctx);
request->send();
}
template <typename I>
void BootstrapRequest<I>::handle_prepare_replay(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to prepare local replay: " << cpp_strerror(r) << dendl;
m_ret_val = r;
close_remote_image();
return;
} else if (*m_do_resync) {
dout(10) << "local image resync requested" << dendl;
close_remote_image();
return;
} else if ((*m_state_builder)->is_disconnected()) {
dout(10) << "client flagged disconnected -- skipping bootstrap" << dendl;
// The caller is expected to detect disconnect initializing remote journal.
m_ret_val = 0;
close_remote_image();
return;
} else if (m_syncing) {
dout(10) << "local image still syncing to remote image" << dendl;
image_sync();
return;
}
close_remote_image();
}
template <typename I>
void BootstrapRequest<I>::create_local_image() {
dout(10) << dendl;
update_progress("CREATE_LOCAL_IMAGE");
ceph_assert(*m_state_builder != nullptr);
auto ctx = create_context_callback<
BootstrapRequest<I>,
&BootstrapRequest<I>::handle_create_local_image>(this);
auto request = (*m_state_builder)->create_local_image_request(
m_threads, m_local_io_ctx, m_global_image_id, m_pool_meta_cache,
m_progress_ctx, ctx);
request->send();
}
template <typename I>
void BootstrapRequest<I>::handle_create_local_image(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
if (r == -ENOENT) {
dout(10) << "parent image does not exist" << dendl;
} else {
derr << "failed to create local image: " << cpp_strerror(r) << dendl;
}
m_ret_val = r;
close_remote_image();
return;
}
open_local_image();
}
template <typename I>
void BootstrapRequest<I>::image_sync() {
std::unique_lock locker{m_lock};
if (m_canceled) {
locker.unlock();
m_ret_val = -ECANCELED;
dout(10) << "request canceled" << dendl;
close_remote_image();
return;
}
dout(15) << dendl;
ceph_assert(m_image_sync == nullptr);
auto state_builder = *m_state_builder;
auto sync_point_handler = state_builder->create_sync_point_handler();
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_image_sync>(this);
m_image_sync = ImageSync<I>::create(
m_threads, state_builder->local_image_ctx, state_builder->remote_image_ctx,
m_local_mirror_uuid, sync_point_handler, m_instance_watcher,
m_progress_ctx, ctx);
m_image_sync->get();
locker.unlock();
update_progress("IMAGE_SYNC");
m_image_sync->send();
}
template <typename I>
void BootstrapRequest<I>::handle_image_sync(int r) {
dout(15) << "r=" << r << dendl;
{
std::lock_guard locker{m_lock};
m_image_sync->put();
m_image_sync = nullptr;
(*m_state_builder)->destroy_sync_point_handler();
}
if (r < 0) {
if (r == -ECANCELED) {
dout(10) << "request canceled" << dendl;
} else {
derr << "failed to sync remote image: " << cpp_strerror(r) << dendl;
}
m_ret_val = r;
}
close_remote_image();
}
template <typename I>
void BootstrapRequest<I>::close_remote_image() {
if ((*m_state_builder)->replay_requires_remote_image()) {
finish(m_ret_val);
return;
}
dout(15) << dendl;
update_progress("CLOSE_REMOTE_IMAGE");
auto ctx = create_context_callback<
BootstrapRequest<I>,
&BootstrapRequest<I>::handle_close_remote_image>(this);
ceph_assert(*m_state_builder != nullptr);
(*m_state_builder)->close_remote_image(ctx);
}
template <typename I>
void BootstrapRequest<I>::handle_close_remote_image(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "error encountered closing remote image: " << cpp_strerror(r)
<< dendl;
}
finish(m_ret_val);
}
template <typename I>
void BootstrapRequest<I>::update_progress(const std::string &description) {
dout(15) << description << dendl;
if (m_progress_ctx) {
m_progress_ctx->update_progress(description);
}
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::BootstrapRequest<librbd::ImageCtx>;
| 14,292 | 28.409465 | 79 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/BootstrapRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_BOOTSTRAP_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_BOOTSTRAP_REQUEST_H
#include "include/int_types.h"
#include "include/rados/librados.hpp"
#include "common/ceph_mutex.h"
#include "common/Timer.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/mirror/Types.h"
#include "tools/rbd_mirror/CancelableRequest.h"
#include "tools/rbd_mirror/Types.h"
#include <string>
class Context;
namespace journal { class CacheManagerHandler; }
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
class ProgressContext;
template <typename> class ImageSync;
template <typename> class InstanceWatcher;
struct PoolMetaCache;
template <typename> struct Threads;
namespace image_replayer {
template <typename> class StateBuilder;
template <typename ImageCtxT = librbd::ImageCtx>
class BootstrapRequest : public CancelableRequest {
public:
typedef rbd::mirror::ProgressContext ProgressContext;
static BootstrapRequest* create(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
librados::IoCtx& remote_io_ctx,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& global_image_id,
const std::string& local_mirror_uuid,
const RemotePoolMeta& remote_pool_meta,
::journal::CacheManagerHandler* cache_manager_handler,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>** state_builder,
bool* do_resync,
Context* on_finish) {
return new BootstrapRequest(
threads, local_io_ctx, remote_io_ctx, instance_watcher, global_image_id,
local_mirror_uuid, remote_pool_meta, cache_manager_handler,
pool_meta_cache, progress_ctx, state_builder, do_resync, on_finish);
}
BootstrapRequest(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
librados::IoCtx& remote_io_ctx,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& global_image_id,
const std::string& local_mirror_uuid,
const RemotePoolMeta& remote_pool_meta,
::journal::CacheManagerHandler* cache_manager_handler,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>** state_builder,
bool* do_resync,
Context* on_finish);
bool is_syncing() const;
void send() override;
void cancel() override;
std::string get_local_image_name() const;
private:
/**
* @verbatim
*
* <start>
* |
* v (error)
* PREPARE_LOCAL_IMAGE * * * * * * * * * * * * * * * * * *
* | *
* v (error) *
* PREPARE_REMOTE_IMAGE * * * * * * * * * * * * * * * * * *
* | *
* v (error) *
* OPEN_REMOTE_IMAGE * * * * * * * * * * * * * * * * * * *
* | *
* | *
* \----> CREATE_LOCAL_IMAGE * * * * * * * * * * * * *
* | | ^ * *
* | | . * *
* | v . (image DNE) * *
* \----> OPEN_LOCAL_IMAGE * * * * * * * * * * * * * *
* | * *
* | * *
* v * *
* PREPARE_REPLAY * * * * * * * * * * * * * * *
* | * *
* | * *
* v (skip if not needed) * *
* IMAGE_SYNC * * * * * * * * * * * * * * * * *
* | * *
* | * *
* /---------/ * *
* | * *
* v * *
* CLOSE_REMOTE_IMAGE < * * * * * * * * * * * * * * * * *
* | *
* v *
* <finish> < * * * * * * * * * * * * * * * * * * * * * * *
*
* @endverbatim
*/
Threads<ImageCtxT>* m_threads;
librados::IoCtx &m_local_io_ctx;
librados::IoCtx &m_remote_io_ctx;
InstanceWatcher<ImageCtxT> *m_instance_watcher;
std::string m_global_image_id;
std::string m_local_mirror_uuid;
RemotePoolMeta m_remote_pool_meta;
::journal::CacheManagerHandler *m_cache_manager_handler;
PoolMetaCache* m_pool_meta_cache;
ProgressContext *m_progress_ctx;
StateBuilder<ImageCtxT>** m_state_builder;
bool *m_do_resync;
mutable ceph::mutex m_lock;
bool m_canceled = false;
int m_ret_val = 0;
std::string m_local_image_name;
std::string m_prepare_local_image_name;
bool m_syncing = false;
ImageSync<ImageCtxT> *m_image_sync = nullptr;
void prepare_local_image();
void handle_prepare_local_image(int r);
void prepare_remote_image();
void handle_prepare_remote_image(int r);
void open_remote_image();
void handle_open_remote_image(int r);
void open_local_image();
void handle_open_local_image(int r);
void create_local_image();
void handle_create_local_image(int r);
void prepare_replay();
void handle_prepare_replay(int r);
void image_sync();
void handle_image_sync(int r);
void close_remote_image();
void handle_close_remote_image(int r);
void update_progress(const std::string &description);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::BootstrapRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_BOOTSTRAP_REQUEST_H
| 6,112 | 32.587912 | 86 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/CloseImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "CloseImageRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::CloseImageRequest: " \
<< this << " " << __func__
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_context_callback;
template <typename I>
CloseImageRequest<I>::CloseImageRequest(I **image_ctx, Context *on_finish)
: m_image_ctx(image_ctx), m_on_finish(on_finish) {
}
template <typename I>
void CloseImageRequest<I>::send() {
close_image();
}
template <typename I>
void CloseImageRequest<I>::close_image() {
dout(20) << dendl;
Context *ctx = create_context_callback<
CloseImageRequest<I>, &CloseImageRequest<I>::handle_close_image>(this);
(*m_image_ctx)->state->close(ctx);
}
template <typename I>
void CloseImageRequest<I>::handle_close_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": error encountered while closing image: " << cpp_strerror(r)
<< dendl;
}
*m_image_ctx = nullptr;
m_on_finish->complete(0);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::CloseImageRequest<librbd::ImageCtx>;
| 1,545 | 23.539683 | 82 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/CloseImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_CLOSE_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_CLOSE_IMAGE_REQUEST_H
#include "include/int_types.h"
#include "librbd/ImageCtx.h"
#include <string>
class Context;
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename ImageCtxT = librbd::ImageCtx>
class CloseImageRequest {
public:
static CloseImageRequest* create(ImageCtxT **image_ctx, Context *on_finish) {
return new CloseImageRequest(image_ctx, on_finish);
}
CloseImageRequest(ImageCtxT **image_ctx, Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* CLOSE_IMAGE
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT **m_image_ctx;
Context *m_on_finish;
void close_image();
void handle_close_image(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::CloseImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_CLOSE_IMAGE_REQUEST_H
| 1,191 | 19.912281 | 87 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/CreateImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "CreateImageRequest.h"
#include "CloseImageRequest.h"
#include "OpenImageRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/internal.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/image/CreateRequest.h"
#include "librbd/image/CloneRequest.h"
#include "tools/rbd_mirror/PoolMetaCache.h"
#include "tools/rbd_mirror/Types.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "tools/rbd_mirror/image_sync/Utils.h"
#include <boost/algorithm/string/predicate.hpp>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::CreateImageRequest: " \
<< this << " " << __func__ << ": "
using librbd::util::create_async_context_callback;
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename I>
CreateImageRequest<I>::CreateImageRequest(
Threads<I>* threads,
librados::IoCtx &local_io_ctx,
const std::string &global_image_id,
const std::string &remote_mirror_uuid,
const std::string &local_image_name,
const std::string &local_image_id,
I *remote_image_ctx,
PoolMetaCache* pool_meta_cache,
cls::rbd::MirrorImageMode mirror_image_mode,
Context *on_finish)
: m_threads(threads), m_local_io_ctx(local_io_ctx),
m_global_image_id(global_image_id),
m_remote_mirror_uuid(remote_mirror_uuid),
m_local_image_name(local_image_name), m_local_image_id(local_image_id),
m_remote_image_ctx(remote_image_ctx),
m_pool_meta_cache(pool_meta_cache),
m_mirror_image_mode(mirror_image_mode), m_on_finish(on_finish) {
}
template <typename I>
void CreateImageRequest<I>::send() {
int r = validate_parent();
if (r < 0) {
error(r);
return;
}
if (m_remote_parent_spec.pool_id == -1) {
create_image();
} else {
get_parent_global_image_id();
}
}
template <typename I>
void CreateImageRequest<I>::create_image() {
dout(10) << dendl;
using klass = CreateImageRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_create_image>(this);
std::shared_lock image_locker{m_remote_image_ctx->image_lock};
auto& config{
reinterpret_cast<CephContext*>(m_local_io_ctx.cct())->_conf};
librbd::ImageOptions image_options;
populate_image_options(&image_options);
auto req = librbd::image::CreateRequest<I>::create(
config, m_local_io_ctx, m_local_image_name, m_local_image_id,
m_remote_image_ctx->size, image_options, 0U, m_mirror_image_mode,
m_global_image_id, m_remote_mirror_uuid, m_remote_image_ctx->op_work_queue,
ctx);
req->send();
}
template <typename I>
void CreateImageRequest<I>::handle_create_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBADF) {
dout(5) << "image id " << m_local_image_id << " already in-use" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "failed to create local image: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void CreateImageRequest<I>::get_parent_global_image_id() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_get_start(&op,
m_remote_parent_spec.image_id);
librados::AioCompletion *aio_comp = create_rados_callback<
CreateImageRequest<I>,
&CreateImageRequest<I>::handle_get_parent_global_image_id>(this);
m_out_bl.clear();
int r = m_remote_parent_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op,
&m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void CreateImageRequest<I>::handle_get_parent_global_image_id(int r) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
cls::rbd::MirrorImage mirror_image;
auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_finish(&iter, &mirror_image);
if (r == 0) {
m_parent_global_image_id = mirror_image.global_image_id;
dout(15) << "parent_global_image_id=" << m_parent_global_image_id
<< dendl;
}
}
if (r == -ENOENT) {
dout(10) << "parent image " << m_remote_parent_spec.image_id
<< " not mirrored" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "failed to retrieve global image id for parent image "
<< m_remote_parent_spec.image_id << ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
get_local_parent_image_id();
}
template <typename I>
void CreateImageRequest<I>::get_local_parent_image_id() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_get_image_id_start(
&op, m_parent_global_image_id);
librados::AioCompletion *aio_comp = create_rados_callback<
CreateImageRequest<I>,
&CreateImageRequest<I>::handle_get_local_parent_image_id>(this);
m_out_bl.clear();
int r = m_local_parent_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op,
&m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void CreateImageRequest<I>::handle_get_local_parent_image_id(int r) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(
&iter, &m_local_parent_spec.image_id);
}
if (r == -ENOENT) {
dout(10) << "parent image " << m_parent_global_image_id << " not "
<< "registered locally" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "failed to retrieve local image id for parent image "
<< m_parent_global_image_id << ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
open_remote_parent_image();
}
template <typename I>
void CreateImageRequest<I>::open_remote_parent_image() {
dout(10) << dendl;
Context *ctx = create_context_callback<
CreateImageRequest<I>,
&CreateImageRequest<I>::handle_open_remote_parent_image>(this);
OpenImageRequest<I> *request = OpenImageRequest<I>::create(
m_remote_parent_io_ctx, &m_remote_parent_image_ctx,
m_remote_parent_spec.image_id, true, ctx);
request->send();
}
template <typename I>
void CreateImageRequest<I>::handle_open_remote_parent_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to open remote parent image " << m_parent_pool_name << "/"
<< m_remote_parent_spec.image_id << dendl;
finish(r);
return;
}
clone_image();
}
template <typename I>
void CreateImageRequest<I>::clone_image() {
dout(10) << dendl;
LocalPoolMeta local_parent_pool_meta;
int r = m_pool_meta_cache->get_local_pool_meta(
m_local_parent_io_ctx.get_id(), &local_parent_pool_meta);
if (r < 0) {
derr << "failed to retrieve local parent mirror uuid for pool "
<< m_local_parent_io_ctx.get_id() << dendl;
m_ret_val = r;
close_remote_parent_image();
return;
}
// ensure no image sync snapshots for the local cluster exist in the
// remote image
bool found_parent_snap = false;
bool found_image_sync_snap = false;
std::string snap_name;
cls::rbd::SnapshotNamespace snap_namespace;
{
auto snap_prefix = image_sync::util::get_snapshot_name_prefix(
local_parent_pool_meta.mirror_uuid);
std::shared_lock remote_image_locker(m_remote_parent_image_ctx->image_lock);
for (auto snap_info : m_remote_parent_image_ctx->snap_info) {
if (snap_info.first == m_remote_parent_spec.snap_id) {
found_parent_snap = true;
snap_name = snap_info.second.name;
snap_namespace = snap_info.second.snap_namespace;
} else if (boost::starts_with(snap_info.second.name, snap_prefix)) {
found_image_sync_snap = true;
}
}
}
if (!found_parent_snap) {
dout(15) << "remote parent image snapshot not found" << dendl;
m_ret_val = -ENOENT;
close_remote_parent_image();
return;
} else if (found_image_sync_snap) {
dout(15) << "parent image not synced to local cluster" << dendl;
m_ret_val = -ENOENT;
close_remote_parent_image();
return;
}
librbd::ImageOptions opts;
populate_image_options(&opts);
auto& config{
reinterpret_cast<CephContext*>(m_local_io_ctx.cct())->_conf};
using klass = CreateImageRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_clone_image>(this);
librbd::image::CloneRequest<I> *req = librbd::image::CloneRequest<I>::create(
config, m_local_parent_io_ctx, m_local_parent_spec.image_id, snap_name,
snap_namespace, CEPH_NOSNAP, m_local_io_ctx, m_local_image_name,
m_local_image_id, opts, m_mirror_image_mode, m_global_image_id,
m_remote_mirror_uuid, m_remote_image_ctx->op_work_queue, ctx);
req->send();
}
template <typename I>
void CreateImageRequest<I>::handle_clone_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBADF) {
dout(5) << "image id " << m_local_image_id << " already in-use" << dendl;
m_ret_val = r;
} else if (r < 0) {
derr << "failed to clone image " << m_parent_pool_name << "/"
<< m_remote_parent_spec.image_id << " to "
<< m_local_image_name << dendl;
m_ret_val = r;
}
close_remote_parent_image();
}
template <typename I>
void CreateImageRequest<I>::close_remote_parent_image() {
dout(10) << dendl;
Context *ctx = create_context_callback<
CreateImageRequest<I>,
&CreateImageRequest<I>::handle_close_remote_parent_image>(this);
CloseImageRequest<I> *request = CloseImageRequest<I>::create(
&m_remote_parent_image_ctx, ctx);
request->send();
}
template <typename I>
void CreateImageRequest<I>::handle_close_remote_parent_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "error encountered closing remote parent image: "
<< cpp_strerror(r) << dendl;
}
finish(m_ret_val);
}
template <typename I>
void CreateImageRequest<I>::error(int r) {
dout(10) << "r=" << r << dendl;
m_threads->work_queue->queue(create_context_callback<
CreateImageRequest<I>, &CreateImageRequest<I>::finish>(this), r);
}
template <typename I>
void CreateImageRequest<I>::finish(int r) {
dout(10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
template <typename I>
int CreateImageRequest<I>::validate_parent() {
std::shared_lock owner_locker{m_remote_image_ctx->owner_lock};
std::shared_lock image_locker{m_remote_image_ctx->image_lock};
m_remote_parent_spec = m_remote_image_ctx->parent_md.spec;
// scan all remote snapshots for a linked parent
for (auto &snap_info_pair : m_remote_image_ctx->snap_info) {
auto &parent_spec = snap_info_pair.second.parent.spec;
if (parent_spec.pool_id == -1) {
continue;
} else if (m_remote_parent_spec.pool_id == -1) {
m_remote_parent_spec = parent_spec;
continue;
}
if (m_remote_parent_spec != parent_spec) {
derr << "remote image parent spec mismatch" << dendl;
return -EINVAL;
}
}
if (m_remote_parent_spec.pool_id == -1) {
return 0;
}
// map remote parent pool to local parent pool
int r = librbd::util::create_ioctx(
m_remote_image_ctx->md_ctx, "remote parent pool",
m_remote_parent_spec.pool_id, m_remote_parent_spec.pool_namespace,
&m_remote_parent_io_ctx);
if (r < 0) {
derr << "failed to open remote parent pool " << m_remote_parent_spec.pool_id
<< ": " << cpp_strerror(r) << dendl;
return r;
}
m_parent_pool_name = m_remote_parent_io_ctx.get_pool_name();
librados::Rados local_rados(m_local_io_ctx);
r = local_rados.ioctx_create(m_parent_pool_name.c_str(),
m_local_parent_io_ctx);
if (r < 0) {
derr << "failed to open local parent pool " << m_parent_pool_name << ": "
<< cpp_strerror(r) << dendl;
return r;
}
m_local_parent_io_ctx.set_namespace(m_remote_parent_io_ctx.get_namespace());
return 0;
}
template <typename I>
void CreateImageRequest<I>::populate_image_options(
librbd::ImageOptions* image_options) {
image_options->set(RBD_IMAGE_OPTION_FEATURES,
m_remote_image_ctx->features);
image_options->set(RBD_IMAGE_OPTION_ORDER, m_remote_image_ctx->order);
image_options->set(RBD_IMAGE_OPTION_STRIPE_UNIT,
m_remote_image_ctx->stripe_unit);
image_options->set(RBD_IMAGE_OPTION_STRIPE_COUNT,
m_remote_image_ctx->stripe_count);
// Determine the data pool for the local image as follows:
// 1. If the local pool has a default data pool, use it.
// 2. If the remote image has a data pool different from its metadata pool and
// a pool with the same name exists locally, use it.
// 3. Don't set the data pool explicitly.
std::string data_pool;
librados::Rados local_rados(m_local_io_ctx);
auto default_data_pool = g_ceph_context->_conf.get_val<std::string>("rbd_default_data_pool");
auto remote_md_pool = m_remote_image_ctx->md_ctx.get_pool_name();
auto remote_data_pool = m_remote_image_ctx->data_ctx.get_pool_name();
if (default_data_pool != "") {
data_pool = default_data_pool;
} else if (remote_data_pool != remote_md_pool) {
if (local_rados.pool_lookup(remote_data_pool.c_str()) >= 0) {
data_pool = remote_data_pool;
}
}
if (data_pool != "") {
image_options->set(RBD_IMAGE_OPTION_DATA_POOL, data_pool);
}
if (m_remote_parent_spec.pool_id != -1) {
uint64_t clone_format = 1;
if (m_remote_image_ctx->test_op_features(
RBD_OPERATION_FEATURE_CLONE_CHILD)) {
clone_format = 2;
}
image_options->set(RBD_IMAGE_OPTION_CLONE_FORMAT, clone_format);
}
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::CreateImageRequest<librbd::ImageCtx>;
| 14,206 | 30.431416 | 95 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/CreateImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_CREATE_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_CREATE_IMAGE_REQUEST_H
#include "include/int_types.h"
#include "include/types.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/Types.h"
#include <string>
class Context;
namespace librbd { class ImageCtx; }
namespace librbd { class ImageOptions; }
namespace rbd {
namespace mirror {
class PoolMetaCache;
template <typename> struct Threads;
namespace image_replayer {
template <typename ImageCtxT = librbd::ImageCtx>
class CreateImageRequest {
public:
static CreateImageRequest *create(
Threads<ImageCtxT> *threads,
librados::IoCtx &local_io_ctx,
const std::string &global_image_id,
const std::string &remote_mirror_uuid,
const std::string &local_image_name,
const std::string &local_image_id,
ImageCtxT *remote_image_ctx,
PoolMetaCache* pool_meta_cache,
cls::rbd::MirrorImageMode mirror_image_mode,
Context *on_finish) {
return new CreateImageRequest(threads, local_io_ctx, global_image_id,
remote_mirror_uuid, local_image_name,
local_image_id, remote_image_ctx,
pool_meta_cache, mirror_image_mode,
on_finish);
}
CreateImageRequest(
Threads<ImageCtxT> *threads, librados::IoCtx &local_io_ctx,
const std::string &global_image_id,
const std::string &remote_mirror_uuid,
const std::string &local_image_name,
const std::string &local_image_id,
ImageCtxT *remote_image_ctx,
PoolMetaCache* pool_meta_cache,
cls::rbd::MirrorImageMode mirror_image_mode,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start> * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* | *
* | (non-clone) *
* |\------------> CREATE_IMAGE ---------------------\ * (error)
* | | *
* | (clone) | *
* \-------------> GET_PARENT_GLOBAL_IMAGE_ID * * * | * * * *
* | | * *
* v | *
* GET_LOCAL_PARENT_IMAGE_ID * * * * | * * * *
* | | * *
* v | *
* OPEN_REMOTE_PARENT * * * * * * * | * * * *
* | | * *
* v | *
* CLONE_IMAGE | *
* | | *
* v | *
* CLOSE_REMOTE_PARENT | *
* | v *
* \------------------------> <finish> < * *
* @endverbatim
*/
Threads<ImageCtxT> *m_threads;
librados::IoCtx &m_local_io_ctx;
std::string m_global_image_id;
std::string m_remote_mirror_uuid;
std::string m_local_image_name;
std::string m_local_image_id;
ImageCtxT *m_remote_image_ctx;
PoolMetaCache* m_pool_meta_cache;
cls::rbd::MirrorImageMode m_mirror_image_mode;
Context *m_on_finish;
librados::IoCtx m_remote_parent_io_ctx;
ImageCtxT *m_remote_parent_image_ctx = nullptr;
cls::rbd::ParentImageSpec m_remote_parent_spec;
librados::IoCtx m_local_parent_io_ctx;
cls::rbd::ParentImageSpec m_local_parent_spec;
bufferlist m_out_bl;
std::string m_parent_global_image_id;
std::string m_parent_pool_name;
int m_ret_val = 0;
void create_image();
void handle_create_image(int r);
void get_parent_global_image_id();
void handle_get_parent_global_image_id(int r);
void get_local_parent_image_id();
void handle_get_local_parent_image_id(int r);
void open_remote_parent_image();
void handle_open_remote_parent_image(int r);
void clone_image();
void handle_clone_image(int r);
void close_remote_parent_image();
void handle_close_remote_parent_image(int r);
void error(int r);
void finish(int r);
int validate_parent();
void populate_image_options(librbd::ImageOptions* image_options);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::CreateImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_CREATE_IMAGE_REQUEST_H
| 4,941 | 33.082759 | 88 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::" \
<< "GetMirrorImageIdRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_rados_callback;
template <typename I>
void GetMirrorImageIdRequest<I>::send() {
dout(20) << dendl;
get_image_id();
}
template <typename I>
void GetMirrorImageIdRequest<I>::get_image_id() {
dout(20) << dendl;
// attempt to cross-reference a image id by the global image id
librados::ObjectReadOperation op;
librbd::cls_client::mirror_image_get_image_id_start(&op, m_global_image_id);
librados::AioCompletion *aio_comp = create_rados_callback<
GetMirrorImageIdRequest<I>,
&GetMirrorImageIdRequest<I>::handle_get_image_id>(
this);
int r = m_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void GetMirrorImageIdRequest<I>::handle_get_image_id(int r) {
if (r == 0) {
auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(
&iter, m_image_id);
}
dout(20) << "r=" << r << ", "
<< "image_id=" << *m_image_id << dendl;
if (r < 0) {
if (r == -ENOENT) {
dout(10) << "global image " << m_global_image_id << " not registered"
<< dendl;
} else {
derr << "failed to retrieve image id: " << cpp_strerror(r) << dendl;
}
finish(r);
return;
}
finish(0);
}
template <typename I>
void GetMirrorImageIdRequest<I>::finish(int r) {
dout(20) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::GetMirrorImageIdRequest<librbd::ImageCtx>;
| 2,312 | 25.895349 | 86 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_GET_MIRROR_IMAGE_ID_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_GET_MIRROR_IMAGE_ID_REQUEST_H
#include "include/buffer.h"
#include "include/rados/librados_fwd.hpp"
#include <string>
namespace librbd { struct ImageCtx; }
struct Context;
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename ImageCtxT = librbd::ImageCtx>
class GetMirrorImageIdRequest {
public:
static GetMirrorImageIdRequest *create(librados::IoCtx &io_ctx,
const std::string &global_image_id,
std::string *image_id,
Context *on_finish) {
return new GetMirrorImageIdRequest(io_ctx, global_image_id, image_id,
on_finish);
}
GetMirrorImageIdRequest(librados::IoCtx &io_ctx,
const std::string &global_image_id,
std::string *image_id,
Context *on_finish)
: m_io_ctx(io_ctx), m_global_image_id(global_image_id),
m_image_id(image_id), m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* GET_IMAGE_ID
* |
* v
* <finish>
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_global_image_id;
std::string *m_image_id;
Context *m_on_finish;
bufferlist m_out_bl;
void get_image_id();
void handle_get_image_id(int r);
void finish(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::GetMirrorImageIdRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_GET_MIRROR_IMAGE_ID_REQUEST_H
| 1,873 | 23.657895 | 93 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/OpenImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "OpenImageRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
#include <type_traits>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::OpenImageRequest: " \
<< this << " " << __func__ << " "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_context_callback;
template <typename I>
OpenImageRequest<I>::OpenImageRequest(librados::IoCtx &io_ctx, I **image_ctx,
const std::string &image_id,
bool read_only, Context *on_finish)
: m_io_ctx(io_ctx), m_image_ctx(image_ctx), m_image_id(image_id),
m_read_only(read_only), m_on_finish(on_finish) {
}
template <typename I>
void OpenImageRequest<I>::send() {
send_open_image();
}
template <typename I>
void OpenImageRequest<I>::send_open_image() {
dout(20) << dendl;
*m_image_ctx = I::create("", m_image_id, nullptr, m_io_ctx, m_read_only);
if (!m_read_only) {
// ensure non-primary images can be modified
(*m_image_ctx)->read_only_mask = ~librbd::IMAGE_READ_ONLY_FLAG_NON_PRIMARY;
}
Context *ctx = create_context_callback<
OpenImageRequest<I>, &OpenImageRequest<I>::handle_open_image>(
this);
(*m_image_ctx)->state->open(0, ctx);
}
template <typename I>
void OpenImageRequest<I>::handle_open_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to open image '" << m_image_id << "': "
<< cpp_strerror(r) << dendl;
*m_image_ctx = nullptr;
}
finish(r);
}
template <typename I>
void OpenImageRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::OpenImageRequest<librbd::ImageCtx>;
| 2,150 | 25.8875 | 81 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/OpenImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_OPEN_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_OPEN_IMAGE_REQUEST_H
#include "include/int_types.h"
#include "librbd/ImageCtx.h"
#include <string>
class Context;
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename ImageCtxT = librbd::ImageCtx>
class OpenImageRequest {
public:
static OpenImageRequest* create(librados::IoCtx &io_ctx,
ImageCtxT **image_ctx,
const std::string &image_id,
bool read_only, Context *on_finish) {
return new OpenImageRequest(io_ctx, image_ctx, image_id, read_only,
on_finish);
}
OpenImageRequest(librados::IoCtx &io_ctx, ImageCtxT **image_ctx,
const std::string &image_id, bool read_only,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* OPEN_IMAGE
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
ImageCtxT **m_image_ctx;
std::string m_image_id;
bool m_read_only;
Context *m_on_finish;
void send_open_image();
void handle_open_image(int r);
void send_close_image(int r);
void handle_close_image(int r);
void finish(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::OpenImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_OPEN_IMAGE_REQUEST_H
| 1,692 | 22.513889 | 86 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/OpenLocalImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/compat.h"
#include "CloseImageRequest.h"
#include "OpenLocalImageRequest.h"
#include "common/debug.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/asio/ContextWQ.h"
#include "librbd/exclusive_lock/Policy.h"
#include "librbd/journal/Policy.h"
#include "librbd/mirror/GetInfoRequest.h"
#include <type_traits>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::OpenLocalImageRequest: " \
<< this << " " << __func__ << " "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_context_callback;
namespace {
template <typename I>
struct MirrorExclusiveLockPolicy : public librbd::exclusive_lock::Policy {
I *image_ctx;
MirrorExclusiveLockPolicy(I *image_ctx) : image_ctx(image_ctx) {
}
bool may_auto_request_lock() override {
return false;
}
int lock_requested(bool force) override {
int r = -EROFS;
{
std::shared_lock owner_locker{image_ctx->owner_lock};
std::shared_lock image_locker{image_ctx->image_lock};
if (image_ctx->journal == nullptr || image_ctx->journal->is_tag_owner()) {
r = 0;
}
}
if (r == 0) {
// if the local image journal has been closed or if it was (force)
// promoted allow the lock to be released to another client
image_ctx->exclusive_lock->release_lock(nullptr);
}
return r;
}
bool accept_blocked_request(
librbd::exclusive_lock::OperationRequestType request_type) override {
switch (request_type) {
case librbd::exclusive_lock::OPERATION_REQUEST_TYPE_TRASH_SNAP_REMOVE:
case librbd::exclusive_lock::OPERATION_REQUEST_TYPE_FORCE_PROMOTION:
return true;
default:
return false;
}
}
};
struct MirrorJournalPolicy : public librbd::journal::Policy {
librbd::asio::ContextWQ *work_queue;
MirrorJournalPolicy(librbd::asio::ContextWQ *work_queue)
: work_queue(work_queue) {
}
bool append_disabled() const override {
// avoid recording any events to the local journal
return true;
}
bool journal_disabled() const override {
return false;
}
void allocate_tag_on_lock(Context *on_finish) override {
// rbd-mirror will manually create tags by copying them from the peer
work_queue->queue(on_finish, 0);
}
};
} // anonymous namespace
template <typename I>
OpenLocalImageRequest<I>::OpenLocalImageRequest(
librados::IoCtx &local_io_ctx,
I **local_image_ctx,
const std::string &local_image_id,
librbd::asio::ContextWQ *work_queue,
Context *on_finish)
: m_local_io_ctx(local_io_ctx), m_local_image_ctx(local_image_ctx),
m_local_image_id(local_image_id), m_work_queue(work_queue),
m_on_finish(on_finish) {
}
template <typename I>
void OpenLocalImageRequest<I>::send() {
send_open_image();
}
template <typename I>
void OpenLocalImageRequest<I>::send_open_image() {
dout(20) << dendl;
*m_local_image_ctx = I::create("", m_local_image_id, nullptr,
m_local_io_ctx, false);
// ensure non-primary images can be modified
(*m_local_image_ctx)->read_only_mask =
~librbd::IMAGE_READ_ONLY_FLAG_NON_PRIMARY;
{
std::scoped_lock locker{(*m_local_image_ctx)->owner_lock,
(*m_local_image_ctx)->image_lock};
(*m_local_image_ctx)->set_exclusive_lock_policy(
new MirrorExclusiveLockPolicy<I>(*m_local_image_ctx));
(*m_local_image_ctx)->set_journal_policy(
new MirrorJournalPolicy(m_work_queue));
}
Context *ctx = create_context_callback<
OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_open_image>(
this);
(*m_local_image_ctx)->state->open(0, ctx);
}
template <typename I>
void OpenLocalImageRequest<I>::handle_open_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
if (r == -ENOENT) {
dout(10) << ": local image does not exist" << dendl;
} else {
derr << ": failed to open image '" << m_local_image_id << "': "
<< cpp_strerror(r) << dendl;
}
*m_local_image_ctx = nullptr;
finish(r);
return;
}
send_get_mirror_info();
}
template <typename I>
void OpenLocalImageRequest<I>::send_get_mirror_info() {
dout(20) << dendl;
Context *ctx = create_context_callback<
OpenLocalImageRequest<I>,
&OpenLocalImageRequest<I>::handle_get_mirror_info>(
this);
auto request = librbd::mirror::GetInfoRequest<I>::create(
**m_local_image_ctx, &m_mirror_image, &m_promotion_state,
&m_primary_mirror_uuid, ctx);
request->send();
}
template <typename I>
void OpenLocalImageRequest<I>::handle_get_mirror_info(int r) {
dout(20) << ": r=" << r << dendl;
if (r == -ENOENT) {
dout(5) << ": local image is not mirrored" << dendl;
send_close_image(r);
return;
} else if (r < 0) {
derr << ": error querying local image primary status: " << cpp_strerror(r)
<< dendl;
send_close_image(r);
return;
}
if (m_mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_DISABLING) {
dout(5) << ": local image mirroring is being disabled" << dendl;
send_close_image(-ENOENT);
return;
}
// if the local image owns the tag -- don't steal the lock since
// we aren't going to mirror peer data into this image anyway
if (m_promotion_state == librbd::mirror::PROMOTION_STATE_PRIMARY) {
dout(10) << ": local image is primary -- skipping image replay" << dendl;
send_close_image(-EREMOTEIO);
return;
}
send_lock_image();
}
template <typename I>
void OpenLocalImageRequest<I>::send_lock_image() {
std::shared_lock owner_locker{(*m_local_image_ctx)->owner_lock};
if ((*m_local_image_ctx)->exclusive_lock == nullptr) {
owner_locker.unlock();
if (m_mirror_image.mode == cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT) {
finish(0);
} else {
derr << ": image does not support exclusive lock" << dendl;
send_close_image(-EINVAL);
}
return;
}
dout(20) << dendl;
// disallow any proxied maintenance operations before grabbing lock
(*m_local_image_ctx)->exclusive_lock->block_requests(-EROFS);
Context *ctx = create_context_callback<
OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_lock_image>(
this);
(*m_local_image_ctx)->exclusive_lock->acquire_lock(ctx);
}
template <typename I>
void OpenLocalImageRequest<I>::handle_lock_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to lock image '" << m_local_image_id << "': "
<< cpp_strerror(r) << dendl;
send_close_image(r);
return;
}
{
std::shared_lock owner_locker{(*m_local_image_ctx)->owner_lock};
if ((*m_local_image_ctx)->exclusive_lock == nullptr ||
!(*m_local_image_ctx)->exclusive_lock->is_lock_owner()) {
derr << ": image is not locked" << dendl;
send_close_image(-EBUSY);
return;
}
}
finish(0);
}
template <typename I>
void OpenLocalImageRequest<I>::send_close_image(int r) {
dout(20) << dendl;
if (m_ret_val == 0 && r < 0) {
m_ret_val = r;
}
Context *ctx = create_context_callback<
OpenLocalImageRequest<I>, &OpenLocalImageRequest<I>::handle_close_image>(
this);
CloseImageRequest<I> *request = CloseImageRequest<I>::create(
m_local_image_ctx, ctx);
request->send();
}
template <typename I>
void OpenLocalImageRequest<I>::handle_close_image(int r) {
dout(20) << dendl;
ceph_assert(r == 0);
finish(m_ret_val);
}
template <typename I>
void OpenLocalImageRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::OpenLocalImageRequest<librbd::ImageCtx>;
| 8,058 | 26.505119 | 86 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/OpenLocalImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_OPEN_LOCAL_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_OPEN_LOCAL_IMAGE_REQUEST_H
#include "include/int_types.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/ImageCtx.h"
#include "librbd/mirror/Types.h"
#include <string>
class Context;
namespace librbd {
class ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename ImageCtxT = librbd::ImageCtx>
class OpenLocalImageRequest {
public:
static OpenLocalImageRequest* create(librados::IoCtx &local_io_ctx,
ImageCtxT **local_image_ctx,
const std::string &local_image_id,
librbd::asio::ContextWQ *work_queue,
Context *on_finish) {
return new OpenLocalImageRequest(local_io_ctx, local_image_ctx,
local_image_id, work_queue, on_finish);
}
OpenLocalImageRequest(librados::IoCtx &local_io_ctx,
ImageCtxT **local_image_ctx,
const std::string &local_image_id,
librbd::asio::ContextWQ *work_queue,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* OPEN_IMAGE * * * * * * * *
* | *
* v *
* GET_MIRROR_INFO * * * * *
* | *
* v (skip if primary) v
* LOCK_IMAGE * * * > CLOSE_IMAGE
* | |
* v |
* <finish> <---------------/
*
* @endverbatim
*/
librados::IoCtx &m_local_io_ctx;
ImageCtxT **m_local_image_ctx;
std::string m_local_image_id;
librbd::asio::ContextWQ *m_work_queue;
Context *m_on_finish;
cls::rbd::MirrorImage m_mirror_image;
librbd::mirror::PromotionState m_promotion_state =
librbd::mirror::PROMOTION_STATE_NON_PRIMARY;
std::string m_primary_mirror_uuid;
int m_ret_val = 0;
void send_open_image();
void handle_open_image(int r);
void send_get_mirror_info();
void handle_get_mirror_info(int r);
void send_lock_image();
void handle_lock_image(int r);
void send_close_image(int r);
void handle_close_image(int r);
void finish(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::OpenLocalImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_OPEN_LOCAL_IMAGE_REQUEST_H
| 2,718 | 26.744898 | 91 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/mirror/GetInfoRequest.h"
#include "tools/rbd_mirror/ImageDeleter.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#include "tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h"
#include <type_traits>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::" \
<< "PrepareLocalImageRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void PrepareLocalImageRequest<I>::send() {
dout(10) << dendl;
get_local_image_id();
}
template <typename I>
void PrepareLocalImageRequest<I>::get_local_image_id() {
dout(10) << dendl;
Context *ctx = create_context_callback<
PrepareLocalImageRequest<I>,
&PrepareLocalImageRequest<I>::handle_get_local_image_id>(this);
auto req = GetMirrorImageIdRequest<I>::create(m_io_ctx, m_global_image_id,
&m_local_image_id, ctx);
req->send();
}
template <typename I>
void PrepareLocalImageRequest<I>::handle_get_local_image_id(int r) {
dout(10) << "r=" << r << ", "
<< "local_image_id=" << m_local_image_id << dendl;
if (r < 0) {
finish(r);
return;
}
get_local_image_name();
}
template <typename I>
void PrepareLocalImageRequest<I>::get_local_image_name() {
dout(10) << dendl;
librados::ObjectReadOperation op;
librbd::cls_client::dir_get_name_start(&op, m_local_image_id);
m_out_bl.clear();
librados::AioCompletion *aio_comp = create_rados_callback<
PrepareLocalImageRequest<I>,
&PrepareLocalImageRequest<I>::handle_get_local_image_name>(this);
int r = m_io_ctx.aio_operate(RBD_DIRECTORY, aio_comp, &op, &m_out_bl);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void PrepareLocalImageRequest<I>::handle_get_local_image_name(int r) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
auto it = m_out_bl.cbegin();
r = librbd::cls_client::dir_get_name_finish(&it, m_local_image_name);
}
if (r == -ENOENT) {
// proceed we should have a mirror image record if we got this far
dout(10) << "image does not exist for local image id " << m_local_image_id
<< dendl;
*m_local_image_name = "";
} else if (r < 0) {
derr << "failed to retrieve image name: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
get_mirror_info();
}
template <typename I>
void PrepareLocalImageRequest<I>::get_mirror_info() {
dout(10) << dendl;
auto ctx = create_context_callback<
PrepareLocalImageRequest<I>,
&PrepareLocalImageRequest<I>::handle_get_mirror_info>(this);
auto req = librbd::mirror::GetInfoRequest<I>::create(
m_io_ctx, m_work_queue, m_local_image_id, &m_mirror_image,
&m_promotion_state, &m_primary_mirror_uuid, ctx);
req->send();
}
template <typename I>
void PrepareLocalImageRequest<I>::handle_get_mirror_info(int r) {
dout(10) << ": r=" << r << dendl;
if (r < 0) {
derr << "failed to retrieve local mirror image info: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
if (m_mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_CREATING) {
dout(5) << "local image is still in creating state, issuing a removal"
<< dendl;
move_to_trash();
return;
} else if (m_mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_DISABLING) {
dout(5) << "local image mirroring is in disabling state" << dendl;
finish(-ERESTART);
return;
}
switch (m_mirror_image.mode) {
case cls::rbd::MIRROR_IMAGE_MODE_JOURNAL:
// journal-based local image exists
{
auto state_builder = journal::StateBuilder<I>::create(m_global_image_id);
state_builder->local_primary_mirror_uuid = m_primary_mirror_uuid;
*m_state_builder = state_builder;
}
break;
case cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT:
// snapshot-based local image exists
*m_state_builder = snapshot::StateBuilder<I>::create(m_global_image_id);
break;
default:
derr << "unsupported mirror image mode " << m_mirror_image.mode << " "
<< "for image " << m_global_image_id << dendl;
finish(-EOPNOTSUPP);
break;
}
dout(10) << "local_image_id=" << m_local_image_id << ", "
<< "local_promotion_state=" << m_promotion_state << ", "
<< "local_primary_mirror_uuid=" << m_primary_mirror_uuid << dendl;
(*m_state_builder)->local_image_id = m_local_image_id;
(*m_state_builder)->local_promotion_state = m_promotion_state;
finish(0);
}
template <typename I>
void PrepareLocalImageRequest<I>::move_to_trash() {
dout(10) << dendl;
Context *ctx = create_context_callback<
PrepareLocalImageRequest<I>,
&PrepareLocalImageRequest<I>::handle_move_to_trash>(this);
ImageDeleter<I>::trash_move(m_io_ctx, m_global_image_id,
false, m_work_queue, ctx);
}
template <typename I>
void PrepareLocalImageRequest<I>::handle_move_to_trash(int r) {
dout(10) << ": r=" << r << dendl;
finish(-ENOENT);
}
template <typename I>
void PrepareLocalImageRequest<I>::finish(int r) {
dout(10) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::PrepareLocalImageRequest<librbd::ImageCtx>;
| 6,027 | 29.444444 | 87 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/PrepareLocalImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_PREPARE_LOCAL_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_PREPARE_LOCAL_IMAGE_REQUEST_H
#include "include/buffer.h"
#include "include/rados/librados_fwd.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/mirror/Types.h"
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename> class StateBuilder;
template <typename ImageCtxT = librbd::ImageCtx>
class PrepareLocalImageRequest {
public:
static PrepareLocalImageRequest *create(
librados::IoCtx &io_ctx,
const std::string &global_image_id,
std::string *local_image_name,
StateBuilder<ImageCtxT>** state_builder,
librbd::asio::ContextWQ *work_queue,
Context *on_finish) {
return new PrepareLocalImageRequest(io_ctx, global_image_id,
local_image_name, state_builder,
work_queue, on_finish);
}
PrepareLocalImageRequest(
librados::IoCtx &io_ctx,
const std::string &global_image_id,
std::string *local_image_name,
StateBuilder<ImageCtxT>** state_builder,
librbd::asio::ContextWQ *work_queue,
Context *on_finish)
: m_io_ctx(io_ctx), m_global_image_id(global_image_id),
m_local_image_name(local_image_name), m_state_builder(state_builder),
m_work_queue(work_queue), m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* GET_LOCAL_IMAGE_ID
* |
* v
* GET_LOCAL_IMAGE_NAME
* |
* v
* GET_MIRROR_INFO
* |
* | (if the image mirror state is CREATING)
* v
* TRASH_MOVE
* |
* v
* <finish>
*
* @endverbatim
*/
librados::IoCtx &m_io_ctx;
std::string m_global_image_id;
std::string *m_local_image_name;
StateBuilder<ImageCtxT>** m_state_builder;
librbd::asio::ContextWQ *m_work_queue;
Context *m_on_finish;
bufferlist m_out_bl;
std::string m_local_image_id;
cls::rbd::MirrorImage m_mirror_image;
librbd::mirror::PromotionState m_promotion_state;
std::string m_primary_mirror_uuid;
void get_local_image_id();
void handle_get_local_image_id(int r);
void get_local_image_name();
void handle_get_local_image_name(int r);
void get_mirror_info();
void handle_get_mirror_info(int r);
void move_to_trash();
void handle_move_to_trash(int r);
void finish(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::PrepareLocalImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_PREPARE_LOCAL_IMAGE_REQUEST_H
| 2,893 | 23.948276 | 94 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h"
#include "include/rados/librados.hpp"
#include "cls/rbd/cls_rbd_client.h"
#include "common/debug.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "journal/Settings.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/mirror/GetInfoRequest.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_replayer/GetMirrorImageIdRequest.h"
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#include "tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::" \
<< "PrepareRemoteImageRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
using librbd::util::create_async_context_callback;
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void PrepareRemoteImageRequest<I>::send() {
if (*m_state_builder != nullptr) {
(*m_state_builder)->remote_mirror_uuid = m_remote_pool_meta.mirror_uuid;
auto state_builder = dynamic_cast<snapshot::StateBuilder<I>*>(*m_state_builder);
if (state_builder) {
state_builder->remote_mirror_peer_uuid = m_remote_pool_meta.mirror_peer_uuid;
}
}
get_remote_image_id();
}
template <typename I>
void PrepareRemoteImageRequest<I>::get_remote_image_id() {
dout(10) << dendl;
Context *ctx = create_context_callback<
PrepareRemoteImageRequest<I>,
&PrepareRemoteImageRequest<I>::handle_get_remote_image_id>(this);
auto req = GetMirrorImageIdRequest<I>::create(m_remote_io_ctx,
m_global_image_id,
&m_remote_image_id, ctx);
req->send();
}
template <typename I>
void PrepareRemoteImageRequest<I>::handle_get_remote_image_id(int r) {
dout(10) << "r=" << r << ", "
<< "remote_image_id=" << m_remote_image_id << dendl;
if (r < 0) {
finish(r);
return;
}
get_mirror_info();
}
template <typename I>
void PrepareRemoteImageRequest<I>::get_mirror_info() {
dout(10) << dendl;
auto ctx = create_context_callback<
PrepareRemoteImageRequest<I>,
&PrepareRemoteImageRequest<I>::handle_get_mirror_info>(this);
auto req = librbd::mirror::GetInfoRequest<I>::create(
m_remote_io_ctx, m_threads->work_queue, m_remote_image_id,
&m_mirror_image, &m_promotion_state, &m_primary_mirror_uuid,
ctx);
req->send();
}
template <typename I>
void PrepareRemoteImageRequest<I>::handle_get_mirror_info(int r) {
dout(10) << "r=" << r << dendl;
if (r == -ENOENT) {
dout(10) << "image " << m_global_image_id << " not mirrored" << dendl;
finish(r);
return;
} else if (r < 0) {
derr << "failed to retrieve mirror image details for image "
<< m_global_image_id << ": " << cpp_strerror(r) << dendl;
finish(r);
return;
}
auto state_builder = *m_state_builder;
if (state_builder != nullptr &&
state_builder->get_mirror_image_mode() != m_mirror_image.mode) {
derr << "local and remote mirror image using different mirroring modes "
<< "for image " << m_global_image_id << ": split-brain" << dendl;
finish(-EEXIST);
return;
} else if (m_mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_DISABLING) {
dout(5) << "remote image mirroring is being disabled" << dendl;
finish(-ENOENT);
return;
}
switch (m_mirror_image.mode) {
case cls::rbd::MIRROR_IMAGE_MODE_JOURNAL:
get_client();
break;
case cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT:
finalize_snapshot_state_builder();
finish(0);
break;
default:
derr << "unsupported mirror image mode " << m_mirror_image.mode << " "
<< "for image " << m_global_image_id << dendl;
finish(-EOPNOTSUPP);
break;
}
}
template <typename I>
void PrepareRemoteImageRequest<I>::get_client() {
dout(10) << dendl;
auto cct = static_cast<CephContext *>(m_local_io_ctx.cct());
::journal::Settings journal_settings;
journal_settings.commit_interval = cct->_conf.get_val<double>(
"rbd_mirror_journal_commit_age");
// TODO use Journal thread pool for journal ops until converted to ASIO
ContextWQ* context_wq;
librbd::Journal<>::get_work_queue(cct, &context_wq);
ceph_assert(m_remote_journaler == nullptr);
m_remote_journaler = new Journaler(context_wq, m_threads->timer,
&m_threads->timer_lock, m_remote_io_ctx,
m_remote_image_id, m_local_mirror_uuid,
journal_settings, m_cache_manager_handler);
Context *ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
PrepareRemoteImageRequest<I>,
&PrepareRemoteImageRequest<I>::handle_get_client>(this));
m_remote_journaler->get_client(m_local_mirror_uuid, &m_client, ctx);
}
template <typename I>
void PrepareRemoteImageRequest<I>::handle_get_client(int r) {
dout(10) << "r=" << r << dendl;
MirrorPeerClientMeta client_meta;
if (r == -ENOENT) {
dout(10) << "client not registered" << dendl;
register_client();
} else if (r < 0) {
derr << "failed to retrieve client: " << cpp_strerror(r) << dendl;
finish(r);
} else if (!util::decode_client_meta(m_client, &client_meta)) {
// require operator intervention since the data is corrupt
finish(-EBADMSG);
} else {
// skip registration if it already exists
finalize_journal_state_builder(m_client.state, client_meta);
finish(0);
}
}
template <typename I>
void PrepareRemoteImageRequest<I>::register_client() {
dout(10) << dendl;
auto state_builder = *m_state_builder;
librbd::journal::MirrorPeerClientMeta client_meta{
(state_builder == nullptr ? "" : state_builder->local_image_id)};
client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
librbd::journal::ClientData client_data{client_meta};
bufferlist client_data_bl;
encode(client_data, client_data_bl);
Context *ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
PrepareRemoteImageRequest<I>,
&PrepareRemoteImageRequest<I>::handle_register_client>(this));
m_remote_journaler->register_client(client_data_bl, ctx);
}
template <typename I>
void PrepareRemoteImageRequest<I>::handle_register_client(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to register with remote journal: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
auto state_builder = *m_state_builder;
librbd::journal::MirrorPeerClientMeta client_meta{
(state_builder == nullptr ? "" : state_builder->local_image_id)};
client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
finalize_journal_state_builder(cls::journal::CLIENT_STATE_CONNECTED,
client_meta);
finish(0);
}
template <typename I>
void PrepareRemoteImageRequest<I>::finalize_journal_state_builder(
cls::journal::ClientState client_state,
const MirrorPeerClientMeta& client_meta) {
journal::StateBuilder<I>* state_builder = nullptr;
if (*m_state_builder != nullptr) {
// already verified that it's a matching builder in
// 'handle_get_mirror_info'
state_builder = dynamic_cast<journal::StateBuilder<I>*>(*m_state_builder);
ceph_assert(state_builder != nullptr);
} else {
state_builder = journal::StateBuilder<I>::create(m_global_image_id);
*m_state_builder = state_builder;
}
state_builder->remote_mirror_uuid = m_remote_pool_meta.mirror_uuid;
state_builder->remote_image_id = m_remote_image_id;
state_builder->remote_promotion_state = m_promotion_state;
state_builder->remote_journaler = m_remote_journaler;
state_builder->remote_client_state = client_state;
state_builder->remote_client_meta = client_meta;
}
template <typename I>
void PrepareRemoteImageRequest<I>::finalize_snapshot_state_builder() {
snapshot::StateBuilder<I>* state_builder = nullptr;
if (*m_state_builder != nullptr) {
state_builder = dynamic_cast<snapshot::StateBuilder<I>*>(*m_state_builder);
ceph_assert(state_builder != nullptr);
} else {
state_builder = snapshot::StateBuilder<I>::create(m_global_image_id);
*m_state_builder = state_builder;
}
dout(10) << "remote_mirror_uuid=" << m_remote_pool_meta.mirror_uuid << ", "
<< "remote_mirror_peer_uuid="
<< m_remote_pool_meta.mirror_peer_uuid << ", "
<< "remote_image_id=" << m_remote_image_id << ", "
<< "remote_promotion_state=" << m_promotion_state << dendl;
state_builder->remote_mirror_uuid = m_remote_pool_meta.mirror_uuid;
state_builder->remote_mirror_peer_uuid = m_remote_pool_meta.mirror_peer_uuid;
state_builder->remote_image_id = m_remote_image_id;
state_builder->remote_promotion_state = m_promotion_state;
}
template <typename I>
void PrepareRemoteImageRequest<I>::finish(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
delete m_remote_journaler;
m_remote_journaler = nullptr;
}
m_on_finish->complete(r);
delete this;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::PrepareRemoteImageRequest<librbd::ImageCtx>;
| 9,702 | 33.165493 | 88 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/PrepareRemoteImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_PREPARE_REMOTE_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_PREPARE_REMOTE_IMAGE_REQUEST_H
#include "include/buffer_fwd.h"
#include "include/rados/librados_fwd.hpp"
#include "cls/journal/cls_journal_types.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/Types.h"
#include "tools/rbd_mirror/Types.h"
#include <string>
namespace journal { class Journaler; }
namespace journal { struct CacheManagerHandler; }
namespace librbd { struct ImageCtx; }
namespace librbd { namespace journal { struct MirrorPeerClientMeta; } }
struct Context;
namespace rbd {
namespace mirror {
template <typename> struct Threads;
namespace image_replayer {
template <typename> class StateBuilder;
template <typename ImageCtxT = librbd::ImageCtx>
class PrepareRemoteImageRequest {
public:
typedef librbd::journal::TypeTraits<ImageCtxT> TypeTraits;
typedef typename TypeTraits::Journaler Journaler;
typedef librbd::journal::MirrorPeerClientMeta MirrorPeerClientMeta;
static PrepareRemoteImageRequest *create(
Threads<ImageCtxT> *threads,
librados::IoCtx &local_io_ctx,
librados::IoCtx &remote_io_ctx,
const std::string &global_image_id,
const std::string &local_mirror_uuid,
const RemotePoolMeta& remote_pool_meta,
::journal::CacheManagerHandler *cache_manager_handler,
StateBuilder<ImageCtxT>** state_builder,
Context *on_finish) {
return new PrepareRemoteImageRequest(threads, local_io_ctx, remote_io_ctx,
global_image_id, local_mirror_uuid,
remote_pool_meta,
cache_manager_handler, state_builder,
on_finish);
}
PrepareRemoteImageRequest(
Threads<ImageCtxT> *threads,
librados::IoCtx &local_io_ctx,
librados::IoCtx &remote_io_ctx,
const std::string &global_image_id,
const std::string &local_mirror_uuid,
const RemotePoolMeta& remote_pool_meta,
::journal::CacheManagerHandler *cache_manager_handler,
StateBuilder<ImageCtxT>** state_builder,
Context *on_finish)
: m_threads(threads),
m_local_io_ctx(local_io_ctx),
m_remote_io_ctx(remote_io_ctx),
m_global_image_id(global_image_id),
m_local_mirror_uuid(local_mirror_uuid),
m_remote_pool_meta(remote_pool_meta),
m_cache_manager_handler(cache_manager_handler),
m_state_builder(state_builder),
m_on_finish(on_finish) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* GET_REMOTE_IMAGE_ID
* |
* v
* GET_REMOTE_MIRROR_INFO
* |
* | (journal)
* \-----------> GET_CLIENT
* | |
* | v (skip if not needed)
* | REGISTER_CLIENT
* | |
* | |
* |/----------------/
* |
* v
* <finish>
*
* @endverbatim
*/
Threads<ImageCtxT> *m_threads;
librados::IoCtx &m_local_io_ctx;
librados::IoCtx &m_remote_io_ctx;
std::string m_global_image_id;
std::string m_local_mirror_uuid;
RemotePoolMeta m_remote_pool_meta;
::journal::CacheManagerHandler *m_cache_manager_handler;
StateBuilder<ImageCtxT>** m_state_builder;
Context *m_on_finish;
bufferlist m_out_bl;
std::string m_remote_image_id;
cls::rbd::MirrorImage m_mirror_image;
librbd::mirror::PromotionState m_promotion_state =
librbd::mirror::PROMOTION_STATE_UNKNOWN;
std::string m_primary_mirror_uuid;
// journal-based mirroring
Journaler *m_remote_journaler = nullptr;
cls::journal::Client m_client;
void get_remote_image_id();
void handle_get_remote_image_id(int r);
void get_mirror_info();
void handle_get_mirror_info(int r);
void get_client();
void handle_get_client(int r);
void register_client();
void handle_register_client(int r);
void finalize_journal_state_builder(cls::journal::ClientState client_state,
const MirrorPeerClientMeta& client_meta);
void finalize_snapshot_state_builder();
void finish(int r);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::PrepareRemoteImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_PREPARE_REMOTE_IMAGE_REQUEST_H
| 4,596 | 28.850649 | 95 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/Replayer.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_H
#define RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_H
#include <string>
struct Context;
namespace rbd {
namespace mirror {
namespace image_replayer {
struct Replayer {
virtual ~Replayer() {}
virtual void destroy() = 0;
virtual void init(Context* on_finish) = 0;
virtual void shut_down(Context* on_finish) = 0;
virtual void flush(Context* on_finish) = 0;
virtual bool get_replay_status(std::string* description,
Context* on_finish) = 0;
virtual bool is_replaying() const = 0;
virtual bool is_resync_requested() const = 0;
virtual int get_error_code() const = 0;
virtual std::string get_error_description() const = 0;
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_H
| 937 | 22.45 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/ReplayerListener.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_LISTENER_H
#define RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_LISTENER_H
namespace rbd {
namespace mirror {
namespace image_replayer {
struct ReplayerListener {
virtual ~ReplayerListener() {}
virtual void handle_notification() = 0;
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_REPLAYER_REPLAYER_LISTENER_H
| 505 | 22 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/StateBuilder.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "StateBuilder.h"
#include "include/ceph_assert.h"
#include "include/Context.h"
#include "common/debug.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
#include "tools/rbd_mirror/image_sync/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::" \
<< "StateBuilder: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
template <typename I>
StateBuilder<I>::StateBuilder(const std::string& global_image_id)
: global_image_id(global_image_id) {
dout(10) << "global_image_id=" << global_image_id << dendl;
}
template <typename I>
StateBuilder<I>::~StateBuilder() {
ceph_assert(local_image_ctx == nullptr);
ceph_assert(remote_image_ctx == nullptr);
ceph_assert(m_sync_point_handler == nullptr);
}
template <typename I>
bool StateBuilder<I>::is_local_primary() const {
if (local_promotion_state == librbd::mirror::PROMOTION_STATE_PRIMARY) {
ceph_assert(!local_image_id.empty());
return true;
}
return false;
}
template <typename I>
bool StateBuilder<I>::is_remote_primary() const {
if (remote_promotion_state == librbd::mirror::PROMOTION_STATE_PRIMARY) {
ceph_assert(!remote_image_id.empty());
return true;
}
return false;
}
template <typename I>
bool StateBuilder<I>::is_linked() const {
if (local_promotion_state == librbd::mirror::PROMOTION_STATE_NON_PRIMARY) {
ceph_assert(!local_image_id.empty());
return is_linked_impl();
}
return false;
}
template <typename I>
void StateBuilder<I>::close_local_image(Context* on_finish) {
if (local_image_ctx == nullptr) {
on_finish->complete(0);
return;
}
dout(10) << dendl;
auto ctx = new LambdaContext([this, on_finish](int r) {
handle_close_local_image(r, on_finish);
});
auto request = image_replayer::CloseImageRequest<I>::create(
&local_image_ctx, ctx);
request->send();
}
template <typename I>
void StateBuilder<I>::handle_close_local_image(int r, Context* on_finish) {
dout(10) << "r=" << r << dendl;
ceph_assert(local_image_ctx == nullptr);
if (r < 0) {
derr << "failed to close local image for image " << global_image_id << ": "
<< cpp_strerror(r) << dendl;
}
on_finish->complete(r);
}
template <typename I>
void StateBuilder<I>::close_remote_image(Context* on_finish) {
if (remote_image_ctx == nullptr) {
on_finish->complete(0);
return;
}
dout(10) << dendl;
auto ctx = new LambdaContext([this, on_finish](int r) {
handle_close_remote_image(r, on_finish);
});
auto request = image_replayer::CloseImageRequest<I>::create(
&remote_image_ctx, ctx);
request->send();
}
template <typename I>
void StateBuilder<I>::handle_close_remote_image(int r, Context* on_finish) {
dout(10) << "r=" << r << dendl;
ceph_assert(remote_image_ctx == nullptr);
if (r < 0) {
derr << "failed to close remote image for image " << global_image_id << ": "
<< cpp_strerror(r) << dendl;
}
on_finish->complete(r);
}
template <typename I>
void StateBuilder<I>::destroy_sync_point_handler() {
if (m_sync_point_handler == nullptr) {
return;
}
dout(15) << dendl;
m_sync_point_handler->destroy();
m_sync_point_handler = nullptr;
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::StateBuilder<librbd::ImageCtx>;
| 3,716 | 25.741007 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/StateBuilder.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_REPLAYER_STATE_BUILDER_H
#define CEPH_RBD_MIRROR_IMAGE_REPLAYER_STATE_BUILDER_H
#include "include/rados/librados_fwd.hpp"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/mirror/Types.h"
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
struct BaseRequest;
template <typename> class InstanceWatcher;
struct PoolMetaCache;
struct ProgressContext;
template <typename> class Threads;
namespace image_sync { struct SyncPointHandler; }
namespace image_replayer {
struct Replayer;
struct ReplayerListener;
template <typename ImageCtxT>
class StateBuilder {
public:
StateBuilder(const StateBuilder&) = delete;
StateBuilder& operator=(const StateBuilder&) = delete;
virtual ~StateBuilder();
virtual void destroy() {
delete this;
}
virtual void close(Context* on_finish) = 0;
virtual bool is_disconnected() const = 0;
bool is_local_primary() const;
bool is_remote_primary() const;
bool is_linked() const;
virtual cls::rbd::MirrorImageMode get_mirror_image_mode() const = 0;
virtual image_sync::SyncPointHandler* create_sync_point_handler() = 0;
void destroy_sync_point_handler();
virtual bool replay_requires_remote_image() const = 0;
void close_remote_image(Context* on_finish);
virtual BaseRequest* create_local_image_request(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
Context* on_finish) = 0;
virtual BaseRequest* create_prepare_replay_request(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
bool* resync_requested,
bool* syncing,
Context* on_finish) = 0;
virtual Replayer* create_replayer(
Threads<ImageCtxT>* threads,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
ReplayerListener* replayer_listener) = 0;
std::string global_image_id;
std::string local_image_id;
librbd::mirror::PromotionState local_promotion_state =
librbd::mirror::PROMOTION_STATE_UNKNOWN;
ImageCtxT* local_image_ctx = nullptr;
std::string remote_mirror_uuid;
std::string remote_image_id;
librbd::mirror::PromotionState remote_promotion_state =
librbd::mirror::PROMOTION_STATE_UNKNOWN;
ImageCtxT* remote_image_ctx = nullptr;
protected:
image_sync::SyncPointHandler* m_sync_point_handler = nullptr;
StateBuilder(const std::string& global_image_id);
void close_local_image(Context* on_finish);
private:
virtual bool is_linked_impl() const = 0;
void handle_close_local_image(int r, Context* on_finish);
void handle_close_remote_image(int r, Context* on_finish);
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::StateBuilder<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_REPLAYER_STATE_BUILDER_H
| 3,121 | 26.147826 | 82 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/TimeRollingMean.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_replayer/TimeRollingMean.h"
#include "common/Clock.h"
namespace rbd {
namespace mirror {
namespace image_replayer {
void TimeRollingMean::operator()(uint32_t value) {
auto time = ceph_clock_now();
if (m_last_time.is_zero()) {
m_last_time = time;
} else if (m_last_time.sec() < time.sec()) {
auto sec = m_last_time.sec();
while (sec++ < time.sec()) {
m_rolling_mean(m_sum);
m_sum = 0;
}
m_last_time = time;
}
m_sum += value;
}
double TimeRollingMean::get_average() const {
return boost::accumulators::rolling_mean(m_rolling_mean);
}
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
| 785 | 21.457143 | 70 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/TimeRollingMean.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_TIME_ROLLING_MEAN_H
#define RBD_MIRROR_IMAGE_REPLAYER_TIME_ROLLING_MEAN_H
#include "include/utime.h"
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>
namespace rbd {
namespace mirror {
namespace image_replayer {
class TimeRollingMean {
public:
void operator()(uint32_t value);
double get_average() const;
private:
typedef boost::accumulators::accumulator_set<
uint64_t, boost::accumulators::stats<
boost::accumulators::tag::rolling_mean>> RollingMean;
utime_t m_last_time;
uint64_t m_sum = 0;
RollingMean m_rolling_mean{
boost::accumulators::tag::rolling_window::window_size = 30};
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_REPLAYER_TIME_ROLLING_MEAN_H
| 989 | 23.146341 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_REPLAYER_TYPES_H
#define CEPH_RBD_MIRROR_IMAGE_REPLAYER_TYPES_H
namespace rbd {
namespace mirror {
namespace image_replayer {
enum HealthState {
HEALTH_STATE_OK,
HEALTH_STATE_WARNING,
HEALTH_STATE_ERROR
};
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_IMAGE_REPLAYER_TYPES_H
| 465 | 20.181818 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/Utils.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "include/rados/librados.hpp"
#include "common/debug.h"
#include "common/errno.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::util::" \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace util {
std::string compute_image_spec(librados::IoCtx& io_ctx,
const std::string& image_name) {
std::string name = io_ctx.get_namespace();
if (!name.empty()) {
name += "/";
}
return io_ctx.get_pool_name() + "/" + name + image_name;
}
bool decode_client_meta(const cls::journal::Client& client,
librbd::journal::MirrorPeerClientMeta* client_meta) {
dout(15) << dendl;
librbd::journal::ClientData client_data;
auto it = client.data.cbegin();
try {
decode(client_data, it);
} catch (const buffer::error &err) {
derr << "failed to decode client meta data: " << err.what() << dendl;
return false;
}
auto local_client_meta = boost::get<librbd::journal::MirrorPeerClientMeta>(
&client_data.client_meta);
if (local_client_meta == nullptr) {
derr << "unknown peer registration" << dendl;
return false;
}
*client_meta = *local_client_meta;
dout(15) << "client found: client_meta=" << *client_meta << dendl;
return true;
}
} // namespace util
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
| 1,732 | 26.951613 | 77 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/Utils.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_UTILS_H
#define RBD_MIRROR_IMAGE_REPLAYER_UTILS_H
#include "include/rados/librados_fwd.hpp"
#include <string>
namespace cls { namespace journal { struct Client; } }
namespace librbd { namespace journal { struct MirrorPeerClientMeta; } }
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace util {
std::string compute_image_spec(librados::IoCtx& io_ctx,
const std::string& image_name);
bool decode_client_meta(const cls::journal::Client& client,
librbd::journal::MirrorPeerClientMeta* client_meta);
} // namespace util
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_REPLAYER_UTILS_H
| 847 | 27.266667 | 76 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/CreateLocalImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "CreateLocalImageRequest.h"
#include "include/rados/librados.hpp"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/journal/Types.h"
#include "tools/rbd_mirror/PoolMetaCache.h"
#include "tools/rbd_mirror/ProgressContext.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/image_replayer/CreateImageRequest.h"
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "CreateLocalImageRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
using librbd::util::create_async_context_callback;
using librbd::util::create_context_callback;
template <typename I>
void CreateLocalImageRequest<I>::send() {
unregister_client();
}
template <typename I>
void CreateLocalImageRequest<I>::unregister_client() {
dout(10) << dendl;
update_progress("UNREGISTER_CLIENT");
auto ctx = create_context_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_unregister_client>(this);
m_state_builder->remote_journaler->unregister_client(ctx);
}
template <typename I>
void CreateLocalImageRequest<I>::handle_unregister_client(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to unregister with remote journal: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
m_state_builder->local_image_id = "";
m_state_builder->remote_client_meta = {};
register_client();
}
template <typename I>
void CreateLocalImageRequest<I>::register_client() {
ceph_assert(m_state_builder->local_image_id.empty());
m_state_builder->local_image_id =
librbd::util::generate_image_id<I>(m_local_io_ctx);
dout(10) << "local_image_id=" << m_state_builder->local_image_id << dendl;
update_progress("REGISTER_CLIENT");
librbd::journal::MirrorPeerClientMeta client_meta{
m_state_builder->local_image_id};
client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
librbd::journal::ClientData client_data{client_meta};
bufferlist client_data_bl;
encode(client_data, client_data_bl);
auto ctx = create_context_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_register_client>(this);
m_state_builder->remote_journaler->register_client(client_data_bl, ctx);
}
template <typename I>
void CreateLocalImageRequest<I>::handle_register_client(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to register with remote journal: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
m_state_builder->remote_client_state = cls::journal::CLIENT_STATE_CONNECTED;
m_state_builder->remote_client_meta = {m_state_builder->local_image_id};
m_state_builder->remote_client_meta.state =
librbd::journal::MIRROR_PEER_STATE_SYNCING;
create_local_image();
}
template <typename I>
void CreateLocalImageRequest<I>::create_local_image() {
dout(10) << "local_image_id=" << m_state_builder->local_image_id << dendl;
update_progress("CREATE_LOCAL_IMAGE");
m_remote_image_ctx->image_lock.lock_shared();
std::string image_name = m_remote_image_ctx->name;
m_remote_image_ctx->image_lock.unlock_shared();
auto ctx = create_context_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_create_local_image>(this);
auto request = CreateImageRequest<I>::create(
m_threads, m_local_io_ctx, m_global_image_id,
m_state_builder->remote_mirror_uuid, image_name,
m_state_builder->local_image_id, m_remote_image_ctx,
m_pool_meta_cache, cls::rbd::MIRROR_IMAGE_MODE_JOURNAL, ctx);
request->send();
}
template <typename I>
void CreateLocalImageRequest<I>::handle_create_local_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBADF) {
dout(5) << "image id " << m_state_builder->local_image_id << " "
<< "already in-use" << dendl;
unregister_client();
return;
} else if (r < 0) {
if (r == -ENOENT) {
dout(10) << "parent image does not exist" << dendl;
} else {
derr << "failed to create local image: " << cpp_strerror(r) << dendl;
}
finish(r);
return;
}
finish(0);
}
template <typename I>
void CreateLocalImageRequest<I>::update_progress(
const std::string& description) {
dout(15) << description << dendl;
if (m_progress_ctx != nullptr) {
m_progress_ctx->update_progress(description);
}
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::CreateLocalImageRequest<librbd::ImageCtx>;
| 5,096 | 30.269939 | 95 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/CreateLocalImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_CREATE_LOCAL_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_CREATE_LOCAL_IMAGE_REQUEST_H
#include "include/rados/librados_fwd.hpp"
#include "tools/rbd_mirror/BaseRequest.h"
#include <string>
struct Context;
namespace journal { class Journaler; }
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
class PoolMetaCache;
class ProgressContext;
template <typename> struct Threads;
namespace image_replayer {
namespace journal {
template <typename> class StateBuilder;
template <typename ImageCtxT>
class CreateLocalImageRequest : public BaseRequest {
public:
typedef rbd::mirror::ProgressContext ProgressContext;
static CreateLocalImageRequest* create(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
ImageCtxT* remote_image_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
Context* on_finish) {
return new CreateLocalImageRequest(threads, local_io_ctx, remote_image_ctx,
global_image_id, pool_meta_cache,
progress_ctx, state_builder, on_finish);
}
CreateLocalImageRequest(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
ImageCtxT* remote_image_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
Context* on_finish)
: BaseRequest(on_finish),
m_threads(threads),
m_local_io_ctx(local_io_ctx),
m_remote_image_ctx(remote_image_ctx),
m_global_image_id(global_image_id),
m_pool_meta_cache(pool_meta_cache),
m_progress_ctx(progress_ctx),
m_state_builder(state_builder) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* UNREGISTER_CLIENT < * * * * * * * *
* | *
* v *
* REGISTER_CLIENT *
* | *
* v (id exists) *
* CREATE_LOCAL_IMAGE * * * * * * * * *
* |
* v
* <finish>
*
* @endverbatim
*/
Threads<ImageCtxT>* m_threads;
librados::IoCtx& m_local_io_ctx;
ImageCtxT* m_remote_image_ctx;
std::string m_global_image_id;
PoolMetaCache* m_pool_meta_cache;
ProgressContext* m_progress_ctx;
StateBuilder<ImageCtxT>* m_state_builder;
void unregister_client();
void handle_unregister_client(int r);
void register_client();
void handle_register_client(int r);
void create_local_image();
void handle_create_local_image(int r);
void update_progress(const std::string& description);
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::CreateLocalImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_CREATE_LOCAL_IMAGE_REQUEST_H
| 3,223 | 26.555556 | 102 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/EventPreprocessor.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "EventPreprocessor.h"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/Types.h"
#include <boost/variant.hpp>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "EventPreprocessor: " << this << " " << __func__ \
<< ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
using librbd::util::create_context_callback;
template <typename I>
EventPreprocessor<I>::EventPreprocessor(I &local_image_ctx,
Journaler &remote_journaler,
const std::string &local_mirror_uuid,
MirrorPeerClientMeta *client_meta,
librbd::asio::ContextWQ *work_queue)
: m_local_image_ctx(local_image_ctx), m_remote_journaler(remote_journaler),
m_local_mirror_uuid(local_mirror_uuid), m_client_meta(client_meta),
m_work_queue(work_queue) {
}
template <typename I>
EventPreprocessor<I>::~EventPreprocessor() {
ceph_assert(!m_in_progress);
}
template <typename I>
bool EventPreprocessor<I>::is_required(const EventEntry &event_entry) {
SnapSeqs snap_seqs(m_client_meta->snap_seqs);
return (prune_snap_map(&snap_seqs) ||
event_entry.get_event_type() ==
librbd::journal::EVENT_TYPE_SNAP_RENAME);
}
template <typename I>
void EventPreprocessor<I>::preprocess(EventEntry *event_entry,
Context *on_finish) {
ceph_assert(!m_in_progress);
m_in_progress = true;
m_event_entry = event_entry;
m_on_finish = on_finish;
refresh_image();
}
template <typename I>
void EventPreprocessor<I>::refresh_image() {
dout(20) << dendl;
Context *ctx = create_context_callback<
EventPreprocessor<I>, &EventPreprocessor<I>::handle_refresh_image>(this);
m_local_image_ctx.state->refresh(ctx);
}
template <typename I>
void EventPreprocessor<I>::handle_refresh_image(int r) {
dout(20) << "r=" << r << dendl;
if (r < 0) {
derr << "error encountered during image refresh: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
preprocess_event();
}
template <typename I>
void EventPreprocessor<I>::preprocess_event() {
dout(20) << dendl;
m_snap_seqs = m_client_meta->snap_seqs;
m_snap_seqs_updated = prune_snap_map(&m_snap_seqs);
int r = boost::apply_visitor(PreprocessEventVisitor(this),
m_event_entry->event);
if (r < 0) {
finish(r);
return;
}
update_client();
}
template <typename I>
int EventPreprocessor<I>::preprocess_snap_rename(
librbd::journal::SnapRenameEvent &event) {
dout(20) << "remote_snap_id=" << event.snap_id << ", "
<< "src_snap_name=" << event.src_snap_name << ", "
<< "dest_snap_name=" << event.dst_snap_name << dendl;
auto snap_seq_it = m_snap_seqs.find(event.snap_id);
if (snap_seq_it != m_snap_seqs.end()) {
dout(20) << "remapping remote snap id " << snap_seq_it->first << " "
<< "to local snap id " << snap_seq_it->second << dendl;
event.snap_id = snap_seq_it->second;
return 0;
}
auto snap_id_it = m_local_image_ctx.snap_ids.find({cls::rbd::UserSnapshotNamespace(),
event.src_snap_name});
if (snap_id_it == m_local_image_ctx.snap_ids.end()) {
dout(20) << "cannot map remote snapshot '" << event.src_snap_name << "' "
<< "to local snapshot" << dendl;
event.snap_id = CEPH_NOSNAP;
return -ENOENT;
}
dout(20) << "mapping remote snap id " << event.snap_id << " "
<< "to local snap id " << snap_id_it->second << dendl;
m_snap_seqs_updated = true;
m_snap_seqs[event.snap_id] = snap_id_it->second;
event.snap_id = snap_id_it->second;
return 0;
}
template <typename I>
void EventPreprocessor<I>::update_client() {
if (!m_snap_seqs_updated) {
finish(0);
return;
}
dout(20) << dendl;
librbd::journal::MirrorPeerClientMeta client_meta(*m_client_meta);
client_meta.snap_seqs = m_snap_seqs;
librbd::journal::ClientData client_data(client_meta);
bufferlist data_bl;
encode(client_data, data_bl);
Context *ctx = create_context_callback<
EventPreprocessor<I>, &EventPreprocessor<I>::handle_update_client>(
this);
m_remote_journaler.update_client(data_bl, ctx);
}
template <typename I>
void EventPreprocessor<I>::handle_update_client(int r) {
dout(20) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update mirror peer journal client: "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
m_client_meta->snap_seqs = m_snap_seqs;
finish(0);
}
template <typename I>
bool EventPreprocessor<I>::prune_snap_map(SnapSeqs *snap_seqs) {
bool pruned = false;
std::shared_lock image_locker{m_local_image_ctx.image_lock};
for (auto it = snap_seqs->begin(); it != snap_seqs->end(); ) {
auto current_it(it++);
if (m_local_image_ctx.snap_info.count(current_it->second) == 0) {
snap_seqs->erase(current_it);
pruned = true;
}
}
return pruned;
}
template <typename I>
void EventPreprocessor<I>::finish(int r) {
dout(20) << "r=" << r << dendl;
Context *on_finish = m_on_finish;
m_on_finish = nullptr;
m_event_entry = nullptr;
m_in_progress = false;
m_snap_seqs_updated = false;
m_work_queue->queue(on_finish, r);
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::EventPreprocessor<librbd::ImageCtx>;
| 5,959 | 27.792271 | 89 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/EventPreprocessor.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_EVENT_PREPROCESSOR_H
#define RBD_MIRROR_IMAGE_REPLAYER_EVENT_PREPROCESSOR_H
#include "include/int_types.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include <map>
#include <string>
#include <boost/variant/static_visitor.hpp>
struct Context;
namespace journal { class Journaler; }
namespace librbd {
class ImageCtx;
namespace asio { struct ContextWQ; }
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename ImageCtxT = librbd::ImageCtx>
class EventPreprocessor {
public:
using Journaler = typename librbd::journal::TypeTraits<ImageCtxT>::Journaler;
using EventEntry = librbd::journal::EventEntry;
using MirrorPeerClientMeta = librbd::journal::MirrorPeerClientMeta;
static EventPreprocessor *create(ImageCtxT &local_image_ctx,
Journaler &remote_journaler,
const std::string &local_mirror_uuid,
MirrorPeerClientMeta *client_meta,
librbd::asio::ContextWQ *work_queue) {
return new EventPreprocessor(local_image_ctx, remote_journaler,
local_mirror_uuid, client_meta, work_queue);
}
static void destroy(EventPreprocessor* processor) {
delete processor;
}
EventPreprocessor(ImageCtxT &local_image_ctx, Journaler &remote_journaler,
const std::string &local_mirror_uuid,
MirrorPeerClientMeta *client_meta,
librbd::asio::ContextWQ *work_queue);
~EventPreprocessor();
bool is_required(const EventEntry &event_entry);
void preprocess(EventEntry *event_entry, Context *on_finish);
private:
/**
* @verbatim
*
* <start>
* |
* v (skip if not required)
* REFRESH_IMAGE
* |
* v (skip if not required)
* PREPROCESS_EVENT
* |
* v (skip if not required)
* UPDATE_CLIENT
*
* @endverbatim
*/
typedef std::map<uint64_t, uint64_t> SnapSeqs;
class PreprocessEventVisitor : public boost::static_visitor<int> {
public:
EventPreprocessor *event_preprocessor;
PreprocessEventVisitor(EventPreprocessor *event_preprocessor)
: event_preprocessor(event_preprocessor) {
}
template <typename T>
inline int operator()(T&) const {
return 0;
}
inline int operator()(librbd::journal::SnapRenameEvent &event) const {
return event_preprocessor->preprocess_snap_rename(event);
}
};
ImageCtxT &m_local_image_ctx;
Journaler &m_remote_journaler;
std::string m_local_mirror_uuid;
MirrorPeerClientMeta *m_client_meta;
librbd::asio::ContextWQ *m_work_queue;
bool m_in_progress = false;
EventEntry *m_event_entry = nullptr;
Context *m_on_finish = nullptr;
SnapSeqs m_snap_seqs;
bool m_snap_seqs_updated = false;
bool prune_snap_map(SnapSeqs *snap_seqs);
void refresh_image();
void handle_refresh_image(int r);
void preprocess_event();
int preprocess_snap_rename(librbd::journal::SnapRenameEvent &event);
void update_client();
void handle_update_client(int r);
void finish(int r);
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::EventPreprocessor<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_EVENT_PREPROCESSOR_H
| 3,562 | 26.835938 | 96 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/PrepareReplayRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "PrepareReplayRequest.h"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "tools/rbd_mirror/ProgressContext.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "PrepareReplayRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
using librbd::util::create_context_callback;
template <typename I>
void PrepareReplayRequest<I>::send() {
*m_resync_requested = false;
*m_syncing = false;
if (m_state_builder->local_image_id !=
m_state_builder->remote_client_meta.image_id) {
// somehow our local image has a different image id than the image id
// registered in the remote image
derr << "split-brain detected: local_image_id="
<< m_state_builder->local_image_id << ", "
<< "registered local_image_id="
<< m_state_builder->remote_client_meta.image_id << dendl;
finish(-EEXIST);
return;
}
std::shared_lock image_locker(m_state_builder->local_image_ctx->image_lock);
if (m_state_builder->local_image_ctx->journal == nullptr) {
image_locker.unlock();
derr << "local image does not support journaling" << dendl;
finish(-EINVAL);
return;
}
int r = m_state_builder->local_image_ctx->journal->is_resync_requested(
m_resync_requested);
if (r < 0) {
image_locker.unlock();
derr << "failed to check if a resync was requested" << dendl;
finish(r);
return;
}
m_local_tag_tid = m_state_builder->local_image_ctx->journal->get_tag_tid();
m_local_tag_data = m_state_builder->local_image_ctx->journal->get_tag_data();
dout(10) << "local tag=" << m_local_tag_tid << ", "
<< "local tag data=" << m_local_tag_data << dendl;
image_locker.unlock();
if (*m_resync_requested) {
finish(0);
return;
} else if (m_state_builder->remote_client_meta.state ==
librbd::journal::MIRROR_PEER_STATE_SYNCING &&
m_local_tag_data.mirror_uuid ==
m_state_builder->remote_mirror_uuid) {
// if the initial sync hasn't completed, we cannot replay
*m_syncing = true;
finish(0);
return;
}
update_client_state();
}
template <typename I>
void PrepareReplayRequest<I>::update_client_state() {
if (m_state_builder->remote_client_meta.state !=
librbd::journal::MIRROR_PEER_STATE_SYNCING ||
m_local_tag_data.mirror_uuid == m_state_builder->remote_mirror_uuid) {
get_remote_tag_class();
return;
}
// our local image is not primary, is flagged as syncing on the remote side,
// but is no longer tied to the remote -- this implies we were forced
// promoted and then demoted at some point
dout(15) << dendl;
update_progress("UPDATE_CLIENT_STATE");
auto client_meta = m_state_builder->remote_client_meta;
client_meta.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
librbd::journal::ClientData client_data(client_meta);
bufferlist data_bl;
encode(client_data, data_bl);
auto ctx = create_context_callback<
PrepareReplayRequest<I>,
&PrepareReplayRequest<I>::handle_update_client_state>(this);
m_state_builder->remote_journaler->update_client(data_bl, ctx);
}
template <typename I>
void PrepareReplayRequest<I>::handle_update_client_state(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update client: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
m_state_builder->remote_client_meta.state =
librbd::journal::MIRROR_PEER_STATE_REPLAYING;
get_remote_tag_class();
}
template <typename I>
void PrepareReplayRequest<I>::get_remote_tag_class() {
dout(10) << dendl;
update_progress("GET_REMOTE_TAG_CLASS");
auto ctx = create_context_callback<
PrepareReplayRequest<I>,
&PrepareReplayRequest<I>::handle_get_remote_tag_class>(this);
m_state_builder->remote_journaler->get_client(
librbd::Journal<>::IMAGE_CLIENT_ID, &m_client, ctx);
}
template <typename I>
void PrepareReplayRequest<I>::handle_get_remote_tag_class(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to retrieve remote client: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
librbd::journal::ClientData client_data;
auto it = m_client.data.cbegin();
try {
decode(client_data, it);
} catch (const buffer::error &err) {
derr << "failed to decode remote client meta data: " << err.what()
<< dendl;
finish(-EBADMSG);
return;
}
librbd::journal::ImageClientMeta *client_meta =
boost::get<librbd::journal::ImageClientMeta>(&client_data.client_meta);
if (client_meta == nullptr) {
derr << "unknown remote client registration" << dendl;
finish(-EINVAL);
return;
}
m_remote_tag_class = client_meta->tag_class;
dout(10) << "remote tag class=" << m_remote_tag_class << dendl;
get_remote_tags();
}
template <typename I>
void PrepareReplayRequest<I>::get_remote_tags() {
dout(10) << dendl;
update_progress("GET_REMOTE_TAGS");
auto ctx = create_context_callback<
PrepareReplayRequest<I>,
&PrepareReplayRequest<I>::handle_get_remote_tags>(this);
m_state_builder->remote_journaler->get_tags(m_remote_tag_class,
&m_remote_tags, ctx);
}
template <typename I>
void PrepareReplayRequest<I>::handle_get_remote_tags(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to retrieve remote tags: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
// At this point, the local image was existing, non-primary, and replaying;
// and the remote image is primary. Attempt to link the local image's most
// recent tag to the remote image's tag chain.
bool remote_tag_data_valid = false;
librbd::journal::TagData remote_tag_data;
boost::optional<uint64_t> remote_orphan_tag_tid =
boost::make_optional<uint64_t>(false, 0U);
bool reconnect_orphan = false;
// decode the remote tags
for (auto &remote_tag : m_remote_tags) {
if (m_local_tag_data.predecessor.commit_valid &&
m_local_tag_data.predecessor.mirror_uuid ==
m_state_builder->remote_mirror_uuid &&
m_local_tag_data.predecessor.tag_tid > remote_tag.tid) {
dout(10) << "skipping processed predecessor remote tag "
<< remote_tag.tid << dendl;
continue;
}
try {
auto it = remote_tag.data.cbegin();
decode(remote_tag_data, it);
remote_tag_data_valid = true;
} catch (const buffer::error &err) {
derr << "failed to decode remote tag " << remote_tag.tid << ": "
<< err.what() << dendl;
finish(-EBADMSG);
return;
}
dout(10) << "decoded remote tag " << remote_tag.tid << ": "
<< remote_tag_data << dendl;
if (!m_local_tag_data.predecessor.commit_valid) {
// newly synced local image (no predecessor) replays from the first tag
if (remote_tag_data.mirror_uuid != librbd::Journal<>::LOCAL_MIRROR_UUID) {
dout(10) << "skipping non-primary remote tag" << dendl;
continue;
}
dout(10) << "using initial primary remote tag" << dendl;
break;
}
if (m_local_tag_data.mirror_uuid == librbd::Journal<>::ORPHAN_MIRROR_UUID) {
// demotion last available local epoch
if (remote_tag_data.mirror_uuid == m_local_tag_data.mirror_uuid &&
remote_tag_data.predecessor.commit_valid &&
remote_tag_data.predecessor.tag_tid ==
m_local_tag_data.predecessor.tag_tid) {
// demotion matches remote epoch
if (remote_tag_data.predecessor.mirror_uuid == m_local_mirror_uuid &&
m_local_tag_data.predecessor.mirror_uuid ==
librbd::Journal<>::LOCAL_MIRROR_UUID) {
// local demoted and remote has matching event
dout(10) << "found matching local demotion tag" << dendl;
remote_orphan_tag_tid = remote_tag.tid;
continue;
}
if (m_local_tag_data.predecessor.mirror_uuid ==
m_state_builder->remote_mirror_uuid &&
remote_tag_data.predecessor.mirror_uuid ==
librbd::Journal<>::LOCAL_MIRROR_UUID) {
// remote demoted and local has matching event
dout(10) << "found matching remote demotion tag" << dendl;
remote_orphan_tag_tid = remote_tag.tid;
continue;
}
}
if (remote_tag_data.mirror_uuid == librbd::Journal<>::LOCAL_MIRROR_UUID &&
remote_tag_data.predecessor.mirror_uuid ==
librbd::Journal<>::ORPHAN_MIRROR_UUID &&
remote_tag_data.predecessor.commit_valid && remote_orphan_tag_tid &&
remote_tag_data.predecessor.tag_tid == *remote_orphan_tag_tid) {
// remote promotion tag chained to remote/local demotion tag
dout(10) << "found chained remote promotion tag" << dendl;
reconnect_orphan = true;
break;
}
// promotion must follow demotion
remote_orphan_tag_tid = boost::none;
}
}
if (remote_tag_data_valid &&
m_local_tag_data.mirror_uuid == m_state_builder->remote_mirror_uuid) {
dout(10) << "local image is in clean replay state" << dendl;
} else if (reconnect_orphan) {
dout(10) << "remote image was demoted/promoted" << dendl;
} else {
derr << "split-brain detected -- skipping image replay" << dendl;
finish(-EEXIST);
return;
}
finish(0);
}
template <typename I>
void PrepareReplayRequest<I>::update_progress(const std::string &description) {
dout(10) << description << dendl;
if (m_progress_ctx != nullptr) {
m_progress_ctx->update_progress(description);
}
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::PrepareReplayRequest<librbd::ImageCtx>;
| 10,297 | 31.485804 | 92 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/PrepareReplayRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
#include "include/int_types.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/Types.h"
#include "librbd/mirror/Types.h"
#include "tools/rbd_mirror/BaseRequest.h"
#include <list>
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
class ProgressContext;
namespace image_replayer {
namespace journal {
template <typename> class StateBuilder;
template <typename ImageCtxT>
class PrepareReplayRequest : public BaseRequest {
public:
static PrepareReplayRequest* create(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
bool* resync_requested,
bool* syncing,
Context* on_finish) {
return new PrepareReplayRequest(
local_mirror_uuid, progress_ctx, state_builder, resync_requested,
syncing, on_finish);
}
PrepareReplayRequest(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
bool* resync_requested,
bool* syncing,
Context* on_finish)
: BaseRequest(on_finish),
m_local_mirror_uuid(local_mirror_uuid),
m_progress_ctx(progress_ctx),
m_state_builder(state_builder),
m_resync_requested(resync_requested),
m_syncing(syncing) {
}
void send() override;
private:
/**
* @verbatim
*
* <start>
* |
* v
* UPDATE_CLIENT_STATE
* |
* v
* GET_REMOTE_TAG_CLASS
* |
* v
* GET_REMOTE_TAGS
* |
* v
* <finish>
*
* @endverbatim
*/
typedef std::list<cls::journal::Tag> Tags;
std::string m_local_mirror_uuid;
ProgressContext* m_progress_ctx;
StateBuilder<ImageCtxT>* m_state_builder;
bool* m_resync_requested;
bool* m_syncing;
uint64_t m_local_tag_tid = 0;
librbd::journal::TagData m_local_tag_data;
uint64_t m_remote_tag_class = 0;
Tags m_remote_tags;
cls::journal::Client m_client;
void update_client_state();
void handle_update_client_state(int r);
void get_remote_tag_class();
void handle_get_remote_tag_class(int r);
void get_remote_tags();
void handle_get_remote_tags(int r);
void update_progress(const std::string& description);
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::PrepareReplayRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
| 2,768 | 22.87069 | 99 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/ReplayStatusFormatter.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "ReplayStatusFormatter.h"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "json_spirit/json_spirit.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "ReplayStatusFormatter: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
using librbd::util::unique_lock_name;
namespace {
double round_to_two_places(double value) {
return abs(round(value * 100) / 100);
}
json_spirit::mObject to_json_object(
const cls::journal::ObjectPosition& position) {
json_spirit::mObject object;
if (position != cls::journal::ObjectPosition{}) {
object["object_number"] = position.object_number;
object["tag_tid"] = position.tag_tid;
object["entry_tid"] = position.entry_tid;
}
return object;
}
} // anonymous namespace
template <typename I>
ReplayStatusFormatter<I>::ReplayStatusFormatter(Journaler *journaler,
const std::string &mirror_uuid)
: m_journaler(journaler),
m_mirror_uuid(mirror_uuid),
m_lock(ceph::make_mutex(unique_lock_name("ReplayStatusFormatter::m_lock", this))) {
}
template <typename I>
void ReplayStatusFormatter<I>::handle_entry_processed(uint32_t bytes) {
dout(20) << dendl;
m_bytes_per_second(bytes);
m_entries_per_second(1);
}
template <typename I>
bool ReplayStatusFormatter<I>::get_or_send_update(std::string *description,
Context *on_finish) {
dout(20) << dendl;
bool in_progress = false;
{
std::lock_guard locker{m_lock};
if (m_on_finish) {
in_progress = true;
} else {
m_on_finish = on_finish;
}
}
if (in_progress) {
dout(10) << "previous request is still in progress, ignoring" << dendl;
on_finish->complete(-EAGAIN);
return false;
}
m_master_position = cls::journal::ObjectPosition();
m_mirror_position = cls::journal::ObjectPosition();
cls::journal::Client master_client, mirror_client;
int r;
r = m_journaler->get_cached_client(librbd::Journal<>::IMAGE_CLIENT_ID,
&master_client);
if (r < 0) {
derr << "error retrieving registered master client: "
<< cpp_strerror(r) << dendl;
} else {
r = m_journaler->get_cached_client(m_mirror_uuid, &mirror_client);
if (r < 0) {
derr << "error retrieving registered mirror client: "
<< cpp_strerror(r) << dendl;
}
}
if (!master_client.commit_position.object_positions.empty()) {
m_master_position =
*(master_client.commit_position.object_positions.begin());
}
if (!mirror_client.commit_position.object_positions.empty()) {
m_mirror_position =
*(mirror_client.commit_position.object_positions.begin());
}
if (!calculate_behind_master_or_send_update()) {
dout(20) << "need to update tag cache" << dendl;
return false;
}
format(description);
{
std::lock_guard locker{m_lock};
ceph_assert(m_on_finish == on_finish);
m_on_finish = nullptr;
}
on_finish->complete(-EEXIST);
return true;
}
template <typename I>
bool ReplayStatusFormatter<I>::calculate_behind_master_or_send_update() {
dout(20) << "m_master_position=" << m_master_position
<< ", m_mirror_position=" << m_mirror_position << dendl;
m_entries_behind_master = 0;
if (m_master_position == cls::journal::ObjectPosition() ||
m_master_position.tag_tid < m_mirror_position.tag_tid) {
return true;
}
cls::journal::ObjectPosition master = m_master_position;
uint64_t mirror_tag_tid = m_mirror_position.tag_tid;
while (master.tag_tid > mirror_tag_tid) {
auto tag_it = m_tag_cache.find(master.tag_tid);
if (tag_it == m_tag_cache.end()) {
send_update_tag_cache(master.tag_tid, mirror_tag_tid);
return false;
}
librbd::journal::TagData &tag_data = tag_it->second;
m_entries_behind_master += master.entry_tid;
master = {0, tag_data.predecessor.tag_tid, tag_data.predecessor.entry_tid};
}
if (master.tag_tid == mirror_tag_tid &&
master.entry_tid > m_mirror_position.entry_tid) {
m_entries_behind_master += master.entry_tid - m_mirror_position.entry_tid;
}
dout(20) << "clearing tags not needed any more (below mirror position)"
<< dendl;
uint64_t tag_tid = mirror_tag_tid;
size_t old_size = m_tag_cache.size();
while (tag_tid != 0) {
auto tag_it = m_tag_cache.find(tag_tid);
if (tag_it == m_tag_cache.end()) {
break;
}
librbd::journal::TagData &tag_data = tag_it->second;
dout(20) << "erasing tag " << tag_data << "for tag_tid " << tag_tid
<< dendl;
tag_tid = tag_data.predecessor.tag_tid;
m_tag_cache.erase(tag_it);
}
dout(20) << old_size - m_tag_cache.size() << " entries cleared" << dendl;
return true;
}
template <typename I>
void ReplayStatusFormatter<I>::send_update_tag_cache(uint64_t master_tag_tid,
uint64_t mirror_tag_tid) {
if (master_tag_tid <= mirror_tag_tid ||
m_tag_cache.find(master_tag_tid) != m_tag_cache.end()) {
Context *on_finish = nullptr;
{
std::lock_guard locker{m_lock};
std::swap(m_on_finish, on_finish);
}
ceph_assert(on_finish);
on_finish->complete(0);
return;
}
dout(20) << "master_tag_tid=" << master_tag_tid << ", mirror_tag_tid="
<< mirror_tag_tid << dendl;
auto ctx = new LambdaContext(
[this, master_tag_tid, mirror_tag_tid](int r) {
handle_update_tag_cache(master_tag_tid, mirror_tag_tid, r);
});
m_journaler->get_tag(master_tag_tid, &m_tag, ctx);
}
template <typename I>
void ReplayStatusFormatter<I>::handle_update_tag_cache(uint64_t master_tag_tid,
uint64_t mirror_tag_tid,
int r) {
librbd::journal::TagData tag_data;
if (r < 0) {
derr << "error retrieving tag " << master_tag_tid << ": " << cpp_strerror(r)
<< dendl;
} else {
dout(20) << "retrieved tag " << master_tag_tid << ": " << m_tag << dendl;
auto it = m_tag.data.cbegin();
try {
decode(tag_data, it);
} catch (const buffer::error &err) {
derr << "error decoding tag " << master_tag_tid << ": " << err.what()
<< dendl;
}
}
if (tag_data.predecessor.mirror_uuid !=
librbd::Journal<>::LOCAL_MIRROR_UUID &&
tag_data.predecessor.mirror_uuid !=
librbd::Journal<>::ORPHAN_MIRROR_UUID) {
dout(20) << "hit remote image non-primary epoch" << dendl;
tag_data.predecessor = {};
}
dout(20) << "decoded tag " << master_tag_tid << ": " << tag_data << dendl;
m_tag_cache[master_tag_tid] = tag_data;
send_update_tag_cache(tag_data.predecessor.tag_tid, mirror_tag_tid);
}
template <typename I>
void ReplayStatusFormatter<I>::format(std::string *description) {
dout(20) << "m_master_position=" << m_master_position
<< ", m_mirror_position=" << m_mirror_position
<< ", m_entries_behind_master=" << m_entries_behind_master << dendl;
json_spirit::mObject root_obj;
root_obj["primary_position"] = to_json_object(m_master_position);
root_obj["non_primary_position"] = to_json_object(m_mirror_position);
root_obj["entries_behind_primary"] = (
m_entries_behind_master > 0 ? m_entries_behind_master : 0);
m_bytes_per_second(0);
root_obj["bytes_per_second"] = round_to_two_places(
m_bytes_per_second.get_average());
m_entries_per_second(0);
auto entries_per_second = m_entries_per_second.get_average();
root_obj["entries_per_second"] = round_to_two_places(entries_per_second);
if (m_entries_behind_master > 0 && entries_per_second > 0) {
std::uint64_t seconds_until_synced = round_to_two_places(
m_entries_behind_master / entries_per_second);
if (seconds_until_synced >= std::numeric_limits<uint64_t>::max()) {
seconds_until_synced = std::numeric_limits<uint64_t>::max();
}
root_obj["seconds_until_synced"] = seconds_until_synced;
}
*description = json_spirit::write(
root_obj, json_spirit::remove_trailing_zeros);
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::ReplayStatusFormatter<librbd::ImageCtx>;
| 8,484 | 28.77193 | 93 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/ReplayStatusFormatter.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_REPLAY_STATUS_FORMATTER_H
#define RBD_MIRROR_IMAGE_REPLAYER_REPLAY_STATUS_FORMATTER_H
#include "include/Context.h"
#include "common/ceph_mutex.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include "tools/rbd_mirror/image_replayer/TimeRollingMean.h"
namespace journal { class Journaler; }
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename ImageCtxT = librbd::ImageCtx>
class ReplayStatusFormatter {
public:
typedef typename librbd::journal::TypeTraits<ImageCtxT>::Journaler Journaler;
static ReplayStatusFormatter* create(Journaler *journaler,
const std::string &mirror_uuid) {
return new ReplayStatusFormatter(journaler, mirror_uuid);
}
static void destroy(ReplayStatusFormatter* formatter) {
delete formatter;
}
ReplayStatusFormatter(Journaler *journaler, const std::string &mirror_uuid);
void handle_entry_processed(uint32_t bytes);
bool get_or_send_update(std::string *description, Context *on_finish);
private:
Journaler *m_journaler;
std::string m_mirror_uuid;
ceph::mutex m_lock;
Context *m_on_finish = nullptr;
cls::journal::ObjectPosition m_master_position;
cls::journal::ObjectPosition m_mirror_position;
int64_t m_entries_behind_master = 0;
cls::journal::Tag m_tag;
std::map<uint64_t, librbd::journal::TagData> m_tag_cache;
TimeRollingMean m_bytes_per_second;
TimeRollingMean m_entries_per_second;
bool calculate_behind_master_or_send_update();
void send_update_tag_cache(uint64_t master_tag_tid, uint64_t mirror_tag_tid);
void handle_update_tag_cache(uint64_t master_tag_tid, uint64_t mirror_tag_tid,
int r);
void format(std::string *description);
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::ReplayStatusFormatter<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_REPLAY_STATUS_FORMATTER_H
| 2,204 | 30.056338 | 100 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/Replayer.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Replayer.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/perf_counters.h"
#include "common/perf_counters_key.h"
#include "common/Timer.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/Replay.h"
#include "journal/Journaler.h"
#include "journal/JournalMetadataListener.h"
#include "journal/ReplayHandler.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/Types.h"
#include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
#include "tools/rbd_mirror/image_replayer/ReplayerListener.h"
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "tools/rbd_mirror/image_replayer/journal/EventPreprocessor.h"
#include "tools/rbd_mirror/image_replayer/journal/ReplayStatusFormatter.h"
#include "tools/rbd_mirror/image_replayer/journal/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "Replayer: " << this << " " << __func__ << ": "
extern PerfCounters *g_journal_perf_counters;
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
namespace {
uint32_t calculate_replay_delay(const utime_t &event_time,
int mirroring_replay_delay) {
if (mirroring_replay_delay <= 0) {
return 0;
}
utime_t now = ceph_clock_now();
if (event_time + mirroring_replay_delay <= now) {
return 0;
}
// ensure it is rounded up when converting to integer
return (event_time + mirroring_replay_delay - now) + 1;
}
} // anonymous namespace
using librbd::util::create_async_context_callback;
using librbd::util::create_context_callback;
template <typename I>
struct Replayer<I>::C_ReplayCommitted : public Context {
Replayer* replayer;
ReplayEntry replay_entry;
uint64_t replay_bytes;
utime_t replay_start_time;
C_ReplayCommitted(Replayer* replayer, ReplayEntry &&replay_entry,
uint64_t replay_bytes, const utime_t &replay_start_time)
: replayer(replayer), replay_entry(std::move(replay_entry)),
replay_bytes(replay_bytes), replay_start_time(replay_start_time) {
}
void finish(int r) override {
replayer->handle_process_entry_safe(replay_entry, replay_bytes,
replay_start_time, r);
}
};
template <typename I>
struct Replayer<I>::RemoteJournalerListener
: public ::journal::JournalMetadataListener {
Replayer* replayer;
RemoteJournalerListener(Replayer* replayer) : replayer(replayer) {}
void handle_update(::journal::JournalMetadata*) override {
auto ctx = new C_TrackedOp(
replayer->m_in_flight_op_tracker,
new LambdaContext([this](int r) {
replayer->handle_remote_journal_metadata_updated();
}));
replayer->m_threads->work_queue->queue(ctx, 0);
}
};
template <typename I>
struct Replayer<I>::RemoteReplayHandler : public ::journal::ReplayHandler {
Replayer* replayer;
RemoteReplayHandler(Replayer* replayer) : replayer(replayer) {}
~RemoteReplayHandler() override {};
void handle_entries_available() override {
replayer->handle_replay_ready();
}
void handle_complete(int r) override {
std::string error;
if (r == -ENOMEM) {
error = "not enough memory in autotune cache";
} else if (r < 0) {
error = "replay completed with error: " + cpp_strerror(r);
}
replayer->handle_replay_complete(r, error);
}
};
template <typename I>
struct Replayer<I>::LocalJournalListener
: public librbd::journal::Listener {
Replayer* replayer;
LocalJournalListener(Replayer* replayer) : replayer(replayer) {
}
void handle_close() override {
replayer->handle_replay_complete(0, "");
}
void handle_promoted() override {
replayer->handle_replay_complete(0, "force promoted");
}
void handle_resync() override {
replayer->handle_resync_image();
}
};
template <typename I>
Replayer<I>::Replayer(
Threads<I>* threads,
const std::string& local_mirror_uuid,
StateBuilder<I>* state_builder,
ReplayerListener* replayer_listener)
: m_threads(threads),
m_local_mirror_uuid(local_mirror_uuid),
m_state_builder(state_builder),
m_replayer_listener(replayer_listener),
m_lock(ceph::make_mutex(librbd::util::unique_lock_name(
"rbd::mirror::image_replayer::journal::Replayer", this))) {
dout(10) << dendl;
}
template <typename I>
Replayer<I>::~Replayer() {
dout(10) << dendl;
{
std::unique_lock locker{m_lock};
unregister_perf_counters();
}
ceph_assert(m_remote_listener == nullptr);
ceph_assert(m_local_journal_listener == nullptr);
ceph_assert(m_local_journal_replay == nullptr);
ceph_assert(m_remote_replay_handler == nullptr);
ceph_assert(m_event_preprocessor == nullptr);
ceph_assert(m_replay_status_formatter == nullptr);
ceph_assert(m_delayed_preprocess_task == nullptr);
ceph_assert(m_flush_local_replay_task == nullptr);
ceph_assert(m_state_builder->local_image_ctx == nullptr);
}
template <typename I>
void Replayer<I>::init(Context* on_finish) {
dout(10) << dendl;
{
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock image_locker{local_image_ctx->image_lock};
m_image_spec = util::compute_image_spec(local_image_ctx->md_ctx,
local_image_ctx->name);
}
{
std::unique_lock locker{m_lock};
register_perf_counters();
}
ceph_assert(m_on_init_shutdown == nullptr);
m_on_init_shutdown = on_finish;
init_remote_journaler();
}
template <typename I>
void Replayer<I>::shut_down(Context* on_finish) {
dout(10) << dendl;
std::unique_lock locker{m_lock};
ceph_assert(m_on_init_shutdown == nullptr);
m_on_init_shutdown = on_finish;
if (m_state == STATE_INIT) {
// raced with the last piece of the init state machine
return;
} else if (m_state == STATE_REPLAYING) {
m_state = STATE_COMPLETE;
}
// if shutting down due to an error notification, we don't
// need to propagate the same error again
m_error_code = 0;
m_error_description = "";
cancel_delayed_preprocess_task();
cancel_flush_local_replay_task();
wait_for_flush();
}
template <typename I>
void Replayer<I>::flush(Context* on_finish) {
dout(10) << dendl;
flush_local_replay(new C_TrackedOp(m_in_flight_op_tracker, on_finish));
}
template <typename I>
bool Replayer<I>::get_replay_status(std::string* description,
Context* on_finish) {
dout(10) << dendl;
std::unique_lock locker{m_lock};
if (m_replay_status_formatter == nullptr) {
derr << "replay not running" << dendl;
locker.unlock();
on_finish->complete(-EAGAIN);
return false;
}
on_finish = new C_TrackedOp(m_in_flight_op_tracker, on_finish);
return m_replay_status_formatter->get_or_send_update(description,
on_finish);
}
template <typename I>
void Replayer<I>::init_remote_journaler() {
dout(10) << dendl;
Context *ctx = create_context_callback<
Replayer, &Replayer<I>::handle_init_remote_journaler>(this);
m_state_builder->remote_journaler->init(ctx);
}
template <typename I>
void Replayer<I>::handle_init_remote_journaler(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (r < 0) {
derr << "failed to initialize remote journal: " << cpp_strerror(r) << dendl;
handle_replay_complete(locker, r, "error initializing remote journal");
close_local_image();
return;
}
// listen for metadata updates to check for disconnect events
ceph_assert(m_remote_listener == nullptr);
m_remote_listener = new RemoteJournalerListener(this);
m_state_builder->remote_journaler->add_listener(m_remote_listener);
cls::journal::Client remote_client;
r = m_state_builder->remote_journaler->get_cached_client(m_local_mirror_uuid,
&remote_client);
if (r < 0) {
derr << "error retrieving remote journal client: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(locker, r, "error retrieving remote journal client");
close_local_image();
return;
}
std::string error;
r = validate_remote_client_state(remote_client,
&m_state_builder->remote_client_meta,
&m_resync_requested, &error);
if (r < 0) {
handle_replay_complete(locker, r, error);
close_local_image();
return;
}
start_external_replay(locker);
}
template <typename I>
void Replayer<I>::start_external_replay(std::unique_lock<ceph::mutex>& locker) {
dout(10) << dendl;
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock local_image_locker{local_image_ctx->image_lock};
ceph_assert(m_local_journal == nullptr);
m_local_journal = local_image_ctx->journal;
if (m_local_journal == nullptr) {
local_image_locker.unlock();
derr << "local image journal closed" << dendl;
handle_replay_complete(locker, -EINVAL, "error accessing local journal");
close_local_image();
return;
}
// safe to hold pointer to journal after external playback starts
Context *start_ctx = create_context_callback<
Replayer, &Replayer<I>::handle_start_external_replay>(this);
m_local_journal->start_external_replay(&m_local_journal_replay, start_ctx);
}
template <typename I>
void Replayer<I>::handle_start_external_replay(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (r < 0) {
ceph_assert(m_local_journal_replay == nullptr);
derr << "error starting external replay on local image "
<< m_state_builder->local_image_ctx->id << ": "
<< cpp_strerror(r) << dendl;
handle_replay_complete(locker, r, "error starting replay on local image");
close_local_image();
return;
}
if (!notify_init_complete(locker)) {
return;
}
m_state = STATE_REPLAYING;
// check for resync/promotion state after adding listener
if (!add_local_journal_listener(locker)) {
return;
}
// start remote journal replay
m_event_preprocessor = EventPreprocessor<I>::create(
*m_state_builder->local_image_ctx, *m_state_builder->remote_journaler,
m_local_mirror_uuid, &m_state_builder->remote_client_meta,
m_threads->work_queue);
m_replay_status_formatter = ReplayStatusFormatter<I>::create(
m_state_builder->remote_journaler, m_local_mirror_uuid);
auto cct = static_cast<CephContext *>(m_state_builder->local_image_ctx->cct);
double poll_seconds = cct->_conf.get_val<double>(
"rbd_mirror_journal_poll_age");
m_remote_replay_handler = new RemoteReplayHandler(this);
m_state_builder->remote_journaler->start_live_replay(m_remote_replay_handler,
poll_seconds);
notify_status_updated();
}
template <typename I>
bool Replayer<I>::add_local_journal_listener(
std::unique_lock<ceph::mutex>& locker) {
dout(10) << dendl;
// listen for promotion and resync requests against local journal
ceph_assert(m_local_journal_listener == nullptr);
m_local_journal_listener = new LocalJournalListener(this);
m_local_journal->add_listener(m_local_journal_listener);
// verify that the local image wasn't force-promoted and that a resync hasn't
// been requested now that we are listening for events
if (m_local_journal->is_tag_owner()) {
dout(10) << "local image force-promoted" << dendl;
handle_replay_complete(locker, 0, "force promoted");
return false;
}
bool resync_requested = false;
int r = m_local_journal->is_resync_requested(&resync_requested);
if (r < 0) {
dout(10) << "failed to determine resync state: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(locker, r, "error parsing resync state");
return false;
} else if (resync_requested) {
dout(10) << "local image resync requested" << dendl;
handle_replay_complete(locker, 0, "resync requested");
return false;
}
return true;
}
template <typename I>
bool Replayer<I>::notify_init_complete(std::unique_lock<ceph::mutex>& locker) {
dout(10) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
ceph_assert(m_state == STATE_INIT);
// notify that init has completed
Context *on_finish = nullptr;
std::swap(m_on_init_shutdown, on_finish);
locker.unlock();
on_finish->complete(0);
locker.lock();
if (m_on_init_shutdown != nullptr) {
// shut down requested after we notified init complete but before we
// grabbed the lock
close_local_image();
return false;
}
return true;
}
template <typename I>
void Replayer<I>::wait_for_flush() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
// ensure that we don't have two concurrent local journal replay shut downs
dout(10) << dendl;
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_wait_for_flush>(this));
m_flush_tracker.wait_for_ops(ctx);
}
template <typename I>
void Replayer<I>::handle_wait_for_flush(int r) {
dout(10) << "r=" << r << dendl;
shut_down_local_journal_replay();
}
template <typename I>
void Replayer<I>::shut_down_local_journal_replay() {
std::unique_lock locker{m_lock};
if (m_local_journal_replay == nullptr) {
wait_for_event_replay();
return;
}
// It's required to stop the local journal replay state machine prior to
// waiting for the events to complete. This is to ensure that IO is properly
// flushed (it might be batched), wait for any running ops to complete, and
// to cancel any ops waiting for their associated OnFinish events.
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_shut_down_local_journal_replay>(this);
m_local_journal_replay->shut_down(true, ctx);
}
template <typename I>
void Replayer<I>::handle_shut_down_local_journal_replay(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (r < 0) {
derr << "error shutting down journal replay: " << cpp_strerror(r) << dendl;
handle_replay_error(r, "failed to shut down local journal replay");
}
wait_for_event_replay();
}
template <typename I>
void Replayer<I>::wait_for_event_replay() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
dout(10) << dendl;
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_wait_for_event_replay>(this));
m_event_replay_tracker.wait_for_ops(ctx);
}
template <typename I>
void Replayer<I>::handle_wait_for_event_replay(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
close_local_image();
}
template <typename I>
void Replayer<I>::close_local_image() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (m_state_builder->local_image_ctx == nullptr) {
stop_remote_journaler_replay();
return;
}
dout(10) << dendl;
if (m_local_journal_listener != nullptr) {
// blocks if listener notification is in-progress
m_local_journal->remove_listener(m_local_journal_listener);
delete m_local_journal_listener;
m_local_journal_listener = nullptr;
}
if (m_local_journal_replay != nullptr) {
m_local_journal->stop_external_replay();
m_local_journal_replay = nullptr;
}
if (m_event_preprocessor != nullptr) {
image_replayer::journal::EventPreprocessor<I>::destroy(
m_event_preprocessor);
m_event_preprocessor = nullptr;
}
m_local_journal.reset();
// NOTE: it's important to ensure that the local image is fully
// closed before attempting to close the remote journal in
// case the remote cluster is unreachable
ceph_assert(m_state_builder->local_image_ctx != nullptr);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_close_local_image>(this);
auto request = image_replayer::CloseImageRequest<I>::create(
&m_state_builder->local_image_ctx, ctx);
request->send();
}
template <typename I>
void Replayer<I>::handle_close_local_image(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (r < 0) {
derr << "error closing local image: " << cpp_strerror(r) << dendl;
handle_replay_error(r, "failed to close local image");
}
ceph_assert(m_state_builder->local_image_ctx == nullptr);
stop_remote_journaler_replay();
}
template <typename I>
void Replayer<I>::stop_remote_journaler_replay() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (m_state_builder->remote_journaler == nullptr) {
wait_for_in_flight_ops();
return;
} else if (m_remote_replay_handler == nullptr) {
wait_for_in_flight_ops();
return;
}
dout(10) << dendl;
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_stop_remote_journaler_replay>(this));
m_state_builder->remote_journaler->stop_replay(ctx);
}
template <typename I>
void Replayer<I>::handle_stop_remote_journaler_replay(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (r < 0) {
derr << "failed to stop remote journaler replay : " << cpp_strerror(r)
<< dendl;
handle_replay_error(r, "failed to stop remote journaler replay");
}
delete m_remote_replay_handler;
m_remote_replay_handler = nullptr;
wait_for_in_flight_ops();
}
template <typename I>
void Replayer<I>::wait_for_in_flight_ops() {
dout(10) << dendl;
if (m_remote_listener != nullptr) {
m_state_builder->remote_journaler->remove_listener(m_remote_listener);
delete m_remote_listener;
m_remote_listener = nullptr;
}
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_wait_for_in_flight_ops>(this));
m_in_flight_op_tracker.wait_for_ops(ctx);
}
template <typename I>
void Replayer<I>::handle_wait_for_in_flight_ops(int r) {
dout(10) << "r=" << r << dendl;
ReplayStatusFormatter<I>::destroy(m_replay_status_formatter);
m_replay_status_formatter = nullptr;
Context* on_init_shutdown = nullptr;
{
std::unique_lock locker{m_lock};
ceph_assert(m_on_init_shutdown != nullptr);
std::swap(m_on_init_shutdown, on_init_shutdown);
m_state = STATE_COMPLETE;
}
on_init_shutdown->complete(m_error_code);
}
template <typename I>
void Replayer<I>::handle_remote_journal_metadata_updated() {
dout(20) << dendl;
std::unique_lock locker{m_lock};
if (m_state != STATE_REPLAYING) {
return;
}
cls::journal::Client remote_client;
int r = m_state_builder->remote_journaler->get_cached_client(
m_local_mirror_uuid, &remote_client);
if (r < 0) {
derr << "failed to retrieve client: " << cpp_strerror(r) << dendl;
return;
}
librbd::journal::MirrorPeerClientMeta remote_client_meta;
std::string error;
r = validate_remote_client_state(remote_client, &remote_client_meta,
&m_resync_requested, &error);
if (r < 0) {
dout(0) << "client flagged disconnected, stopping image replay" << dendl;
handle_replay_complete(locker, r, error);
}
}
template <typename I>
void Replayer<I>::schedule_flush_local_replay_task() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
std::unique_lock timer_locker{m_threads->timer_lock};
if (m_state != STATE_REPLAYING || m_flush_local_replay_task != nullptr) {
return;
}
dout(15) << dendl;
m_flush_local_replay_task = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_flush_local_replay_task>(this));
m_threads->timer->add_event_after(30, m_flush_local_replay_task);
}
template <typename I>
void Replayer<I>::cancel_flush_local_replay_task() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
std::unique_lock timer_locker{m_threads->timer_lock};
if (m_flush_local_replay_task != nullptr) {
dout(10) << dendl;
m_threads->timer->cancel_event(m_flush_local_replay_task);
m_flush_local_replay_task = nullptr;
}
}
template <typename I>
void Replayer<I>::handle_flush_local_replay_task(int) {
dout(15) << dendl;
m_in_flight_op_tracker.start_op();
auto on_finish = new LambdaContext([this](int) {
std::unique_lock locker{m_lock};
{
std::unique_lock timer_locker{m_threads->timer_lock};
m_flush_local_replay_task = nullptr;
}
notify_status_updated();
m_in_flight_op_tracker.finish_op();
});
flush_local_replay(on_finish);
}
template <typename I>
void Replayer<I>::flush_local_replay(Context* on_flush) {
std::unique_lock locker{m_lock};
if (m_state != STATE_REPLAYING) {
locker.unlock();
on_flush->complete(0);
return;
} else if (m_local_journal_replay == nullptr) {
// raced w/ a tag creation stop/start, which implies that
// the replay is flushed
locker.unlock();
flush_commit_position(on_flush);
return;
}
dout(15) << dendl;
auto ctx = new LambdaContext(
[this, on_flush](int r) {
handle_flush_local_replay(on_flush, r);
});
m_local_journal_replay->flush(ctx);
}
template <typename I>
void Replayer<I>::handle_flush_local_replay(Context* on_flush, int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "error flushing local replay: " << cpp_strerror(r) << dendl;
on_flush->complete(r);
return;
}
flush_commit_position(on_flush);
}
template <typename I>
void Replayer<I>::flush_commit_position(Context* on_flush) {
std::unique_lock locker{m_lock};
if (m_state != STATE_REPLAYING) {
locker.unlock();
on_flush->complete(0);
return;
}
dout(15) << dendl;
auto ctx = new LambdaContext(
[this, on_flush](int r) {
handle_flush_commit_position(on_flush, r);
});
m_state_builder->remote_journaler->flush_commit_position(ctx);
}
template <typename I>
void Replayer<I>::handle_flush_commit_position(Context* on_flush, int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "error flushing remote journal commit position: "
<< cpp_strerror(r) << dendl;
}
on_flush->complete(r);
}
template <typename I>
void Replayer<I>::handle_replay_error(int r, const std::string &error) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (m_error_code == 0) {
m_error_code = r;
m_error_description = error;
}
}
template <typename I>
bool Replayer<I>::is_replay_complete() const {
std::unique_lock locker{m_lock};
return is_replay_complete(locker);
}
template <typename I>
bool Replayer<I>::is_replay_complete(
const std::unique_lock<ceph::mutex>&) const {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
return (m_state == STATE_COMPLETE);
}
template <typename I>
void Replayer<I>::handle_replay_complete(int r, const std::string &error) {
std::unique_lock locker{m_lock};
handle_replay_complete(locker, r, error);
}
template <typename I>
void Replayer<I>::handle_replay_complete(
const std::unique_lock<ceph::mutex>&, int r, const std::string &error) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
dout(10) << "r=" << r << ", error=" << error << dendl;
if (r < 0) {
derr << "replay encountered an error: " << cpp_strerror(r) << dendl;
handle_replay_error(r, error);
}
if (m_state != STATE_REPLAYING) {
return;
}
m_state = STATE_COMPLETE;
notify_status_updated();
}
template <typename I>
void Replayer<I>::handle_replay_ready() {
std::unique_lock locker{m_lock};
handle_replay_ready(locker);
}
template <typename I>
void Replayer<I>::handle_replay_ready(
std::unique_lock<ceph::mutex>& locker) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
dout(20) << dendl;
if (is_replay_complete(locker)) {
return;
}
if (!m_state_builder->remote_journaler->try_pop_front(&m_replay_entry,
&m_replay_tag_tid)) {
dout(20) << "no entries ready for replay" << dendl;
return;
}
// can safely drop lock once the entry is tracked
m_event_replay_tracker.start_op();
locker.unlock();
dout(20) << "entry tid=" << m_replay_entry.get_commit_tid()
<< "tag_tid=" << m_replay_tag_tid << dendl;
if (!m_replay_tag_valid || m_replay_tag.tid != m_replay_tag_tid) {
// must allocate a new local journal tag prior to processing
replay_flush();
return;
}
preprocess_entry();
}
template <typename I>
void Replayer<I>::replay_flush() {
dout(10) << dendl;
m_flush_tracker.start_op();
// shut down the replay to flush all IO and ops and create a new
// replayer to handle the new tag epoch
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_replay_flush_shut_down>(this);
ceph_assert(m_local_journal_replay != nullptr);
m_local_journal_replay->shut_down(false, ctx);
}
template <typename I>
void Replayer<I>::handle_replay_flush_shut_down(int r) {
std::unique_lock locker{m_lock};
dout(10) << "r=" << r << dendl;
ceph_assert(m_local_journal != nullptr);
ceph_assert(m_local_journal_listener != nullptr);
// blocks if listener notification is in-progress
m_local_journal->remove_listener(m_local_journal_listener);
delete m_local_journal_listener;
m_local_journal_listener = nullptr;
m_local_journal->stop_external_replay();
m_local_journal_replay = nullptr;
m_local_journal.reset();
if (r < 0) {
locker.unlock();
handle_replay_flush(r);
return;
}
// journal might have been closed now that we stopped external replay
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock local_image_locker{local_image_ctx->image_lock};
m_local_journal = local_image_ctx->journal;
if (m_local_journal == nullptr) {
local_image_locker.unlock();
locker.unlock();
derr << "local image journal closed" << dendl;
handle_replay_flush(-EINVAL);
return;
}
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_replay_flush>(this);
m_local_journal->start_external_replay(&m_local_journal_replay, ctx);
}
template <typename I>
void Replayer<I>::handle_replay_flush(int r) {
std::unique_lock locker{m_lock};
dout(10) << "r=" << r << dendl;
m_flush_tracker.finish_op();
if (r < 0) {
derr << "replay flush encountered an error: " << cpp_strerror(r) << dendl;
handle_replay_complete(locker, r, "replay flush encountered an error");
m_event_replay_tracker.finish_op();
return;
} else if (is_replay_complete(locker)) {
m_event_replay_tracker.finish_op();
return;
}
// check for resync/promotion state after adding listener
if (!add_local_journal_listener(locker)) {
m_event_replay_tracker.finish_op();
return;
}
locker.unlock();
get_remote_tag();
}
template <typename I>
void Replayer<I>::get_remote_tag() {
dout(15) << "tag_tid: " << m_replay_tag_tid << dendl;
Context *ctx = create_context_callback<
Replayer, &Replayer<I>::handle_get_remote_tag>(this);
m_state_builder->remote_journaler->get_tag(m_replay_tag_tid, &m_replay_tag,
ctx);
}
template <typename I>
void Replayer<I>::handle_get_remote_tag(int r) {
dout(15) << "r=" << r << dendl;
if (r == 0) {
try {
auto it = m_replay_tag.data.cbegin();
decode(m_replay_tag_data, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
}
}
if (r < 0) {
derr << "failed to retrieve remote tag " << m_replay_tag_tid << ": "
<< cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to retrieve remote tag");
m_event_replay_tracker.finish_op();
return;
}
m_replay_tag_valid = true;
dout(15) << "decoded remote tag " << m_replay_tag_tid << ": "
<< m_replay_tag_data << dendl;
allocate_local_tag();
}
template <typename I>
void Replayer<I>::allocate_local_tag() {
dout(15) << dendl;
std::string mirror_uuid = m_replay_tag_data.mirror_uuid;
if (mirror_uuid == librbd::Journal<>::LOCAL_MIRROR_UUID) {
mirror_uuid = m_state_builder->remote_mirror_uuid;
} else if (mirror_uuid == m_local_mirror_uuid) {
mirror_uuid = librbd::Journal<>::LOCAL_MIRROR_UUID;
} else if (mirror_uuid == librbd::Journal<>::ORPHAN_MIRROR_UUID) {
// handle possible edge condition where daemon can failover and
// the local image has already been promoted/demoted
auto local_tag_data = m_local_journal->get_tag_data();
if (local_tag_data.mirror_uuid == librbd::Journal<>::ORPHAN_MIRROR_UUID &&
(local_tag_data.predecessor.commit_valid &&
local_tag_data.predecessor.mirror_uuid ==
librbd::Journal<>::LOCAL_MIRROR_UUID)) {
dout(15) << "skipping stale demotion event" << dendl;
handle_process_entry_safe(m_replay_entry, m_replay_bytes,
m_replay_start_time, 0);
handle_replay_ready();
return;
} else {
dout(5) << "encountered image demotion: stopping" << dendl;
handle_replay_complete(0, "");
}
}
librbd::journal::TagPredecessor predecessor(m_replay_tag_data.predecessor);
if (predecessor.mirror_uuid == librbd::Journal<>::LOCAL_MIRROR_UUID) {
predecessor.mirror_uuid = m_state_builder->remote_mirror_uuid;
} else if (predecessor.mirror_uuid == m_local_mirror_uuid) {
predecessor.mirror_uuid = librbd::Journal<>::LOCAL_MIRROR_UUID;
}
dout(15) << "mirror_uuid=" << mirror_uuid << ", "
<< "predecessor=" << predecessor << ", "
<< "replay_tag_tid=" << m_replay_tag_tid << dendl;
Context *ctx = create_context_callback<
Replayer, &Replayer<I>::handle_allocate_local_tag>(this);
m_local_journal->allocate_tag(mirror_uuid, predecessor, ctx);
}
template <typename I>
void Replayer<I>::handle_allocate_local_tag(int r) {
dout(15) << "r=" << r << ", "
<< "tag_tid=" << m_local_journal->get_tag_tid() << dendl;
if (r < 0) {
derr << "failed to allocate journal tag: " << cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to allocate journal tag");
m_event_replay_tracker.finish_op();
return;
}
preprocess_entry();
}
template <typename I>
void Replayer<I>::preprocess_entry() {
dout(20) << "preprocessing entry tid=" << m_replay_entry.get_commit_tid()
<< dendl;
bufferlist data = m_replay_entry.get_data();
auto it = data.cbegin();
int r = m_local_journal_replay->decode(&it, &m_event_entry);
if (r < 0) {
derr << "failed to decode journal event" << dendl;
handle_replay_complete(r, "failed to decode journal event");
m_event_replay_tracker.finish_op();
return;
}
m_replay_bytes = data.length();
uint32_t delay = calculate_replay_delay(
m_event_entry.timestamp,
m_state_builder->local_image_ctx->mirroring_replay_delay);
if (delay == 0) {
handle_preprocess_entry_ready(0);
return;
}
std::unique_lock locker{m_lock};
if (is_replay_complete(locker)) {
// don't schedule a delayed replay task if a shut-down is in-progress
m_event_replay_tracker.finish_op();
return;
}
dout(20) << "delaying replay by " << delay << " sec" << dendl;
std::unique_lock timer_locker{m_threads->timer_lock};
ceph_assert(m_delayed_preprocess_task == nullptr);
m_delayed_preprocess_task = create_context_callback<
Replayer<I>, &Replayer<I>::handle_delayed_preprocess_task>(this);
m_threads->timer->add_event_after(delay, m_delayed_preprocess_task);
}
template <typename I>
void Replayer<I>::handle_delayed_preprocess_task(int r) {
dout(20) << "r=" << r << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_threads->timer_lock));
m_delayed_preprocess_task = nullptr;
m_threads->work_queue->queue(create_context_callback<
Replayer, &Replayer<I>::handle_preprocess_entry_ready>(this), 0);
}
template <typename I>
void Replayer<I>::handle_preprocess_entry_ready(int r) {
dout(20) << "r=" << r << dendl;
ceph_assert(r == 0);
m_replay_start_time = ceph_clock_now();
if (!m_event_preprocessor->is_required(m_event_entry)) {
process_entry();
return;
}
Context *ctx = create_context_callback<
Replayer, &Replayer<I>::handle_preprocess_entry_safe>(this);
m_event_preprocessor->preprocess(&m_event_entry, ctx);
}
template <typename I>
void Replayer<I>::handle_preprocess_entry_safe(int r) {
dout(20) << "r=" << r << dendl;
if (r < 0) {
if (r == -ECANCELED) {
handle_replay_complete(0, "lost exclusive lock");
} else {
derr << "failed to preprocess journal event" << dendl;
handle_replay_complete(r, "failed to preprocess journal event");
}
m_event_replay_tracker.finish_op();
return;
}
process_entry();
}
template <typename I>
void Replayer<I>::process_entry() {
dout(20) << "processing entry tid=" << m_replay_entry.get_commit_tid()
<< dendl;
Context *on_ready = create_context_callback<
Replayer, &Replayer<I>::handle_process_entry_ready>(this);
Context *on_commit = new C_ReplayCommitted(this, std::move(m_replay_entry),
m_replay_bytes,
m_replay_start_time);
m_local_journal_replay->process(m_event_entry, on_ready, on_commit);
}
template <typename I>
void Replayer<I>::handle_process_entry_ready(int r) {
std::unique_lock locker{m_lock};
dout(20) << dendl;
ceph_assert(r == 0);
bool update_status = false;
{
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock image_locker{local_image_ctx->image_lock};
auto image_spec = util::compute_image_spec(local_image_ctx->md_ctx,
local_image_ctx->name);
if (m_image_spec != image_spec) {
m_image_spec = image_spec;
update_status = true;
}
}
m_replay_status_formatter->handle_entry_processed(m_replay_bytes);
if (update_status) {
unregister_perf_counters();
register_perf_counters();
notify_status_updated();
}
// attempt to process the next event
handle_replay_ready(locker);
}
template <typename I>
void Replayer<I>::handle_process_entry_safe(
const ReplayEntry &replay_entry, uint64_t replay_bytes,
const utime_t &replay_start_time, int r) {
dout(20) << "commit_tid=" << replay_entry.get_commit_tid() << ", r=" << r
<< dendl;
if (r < 0) {
derr << "failed to commit journal event: " << cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to commit journal event");
} else {
ceph_assert(m_state_builder->remote_journaler != nullptr);
m_state_builder->remote_journaler->committed(replay_entry);
}
auto latency = ceph_clock_now() - replay_start_time;
if (g_journal_perf_counters) {
g_journal_perf_counters->inc(l_rbd_mirror_journal_entries);
g_journal_perf_counters->inc(l_rbd_mirror_journal_replay_bytes,
replay_bytes);
g_journal_perf_counters->tinc(l_rbd_mirror_journal_replay_latency,
latency);
}
auto ctx = new LambdaContext(
[this, replay_bytes, latency](int r) {
std::unique_lock locker{m_lock};
schedule_flush_local_replay_task();
if (m_perf_counters) {
m_perf_counters->inc(l_rbd_mirror_journal_entries);
m_perf_counters->inc(l_rbd_mirror_journal_replay_bytes, replay_bytes);
m_perf_counters->tinc(l_rbd_mirror_journal_replay_latency, latency);
}
m_event_replay_tracker.finish_op();
});
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
void Replayer<I>::handle_resync_image() {
dout(10) << dendl;
std::unique_lock locker{m_lock};
m_resync_requested = true;
handle_replay_complete(locker, 0, "resync requested");
}
template <typename I>
void Replayer<I>::notify_status_updated() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
dout(10) << dendl;
auto ctx = new C_TrackedOp(m_in_flight_op_tracker, new LambdaContext(
[this](int) {
m_replayer_listener->handle_notification();
}));
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
void Replayer<I>::cancel_delayed_preprocess_task() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
bool canceled_delayed_preprocess_task = false;
{
std::unique_lock timer_locker{m_threads->timer_lock};
if (m_delayed_preprocess_task != nullptr) {
dout(10) << dendl;
canceled_delayed_preprocess_task = m_threads->timer->cancel_event(
m_delayed_preprocess_task);
ceph_assert(canceled_delayed_preprocess_task);
m_delayed_preprocess_task = nullptr;
}
}
if (canceled_delayed_preprocess_task) {
// wake up sleeping replay
m_event_replay_tracker.finish_op();
}
}
template <typename I>
int Replayer<I>::validate_remote_client_state(
const cls::journal::Client& remote_client,
librbd::journal::MirrorPeerClientMeta* remote_client_meta,
bool* resync_requested, std::string* error) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (!util::decode_client_meta(remote_client, remote_client_meta)) {
// require operator intervention since the data is corrupt
*error = "error retrieving remote journal client";
return -EBADMSG;
}
auto local_image_ctx = m_state_builder->local_image_ctx;
dout(5) << "image_id=" << local_image_ctx->id << ", "
<< "remote_client_meta.image_id="
<< remote_client_meta->image_id << ", "
<< "remote_client.state=" << remote_client.state << dendl;
if (remote_client_meta->image_id == local_image_ctx->id &&
remote_client.state != cls::journal::CLIENT_STATE_CONNECTED) {
dout(5) << "client flagged disconnected, stopping image replay" << dendl;
if (local_image_ctx->config.template get_val<bool>(
"rbd_mirroring_resync_after_disconnect")) {
dout(10) << "disconnected: automatic resync" << dendl;
*resync_requested = true;
*error = "disconnected: automatic resync";
return -ENOTCONN;
} else {
dout(10) << "disconnected" << dendl;
*error = "disconnected";
return -ENOTCONN;
}
}
return 0;
}
template <typename I>
void Replayer<I>::register_perf_counters() {
dout(5) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
ceph_assert(m_perf_counters == nullptr);
auto cct = static_cast<CephContext *>(m_state_builder->local_image_ctx->cct);
auto prio = cct->_conf.get_val<int64_t>("rbd_mirror_image_perf_stats_prio");
auto local_image_ctx = m_state_builder->local_image_ctx;
std::string labels = ceph::perf_counters::key_create(
"rbd_mirror_journal_image",
{{"pool", local_image_ctx->md_ctx.get_pool_name()},
{"namespace", local_image_ctx->md_ctx.get_namespace()},
{"image", local_image_ctx->name}});
PerfCountersBuilder plb(g_ceph_context, labels, l_rbd_mirror_journal_first,
l_rbd_mirror_journal_last);
plb.add_u64_counter(l_rbd_mirror_journal_entries, "entries",
"Number of entries replayed", nullptr, prio);
plb.add_u64_counter(l_rbd_mirror_journal_replay_bytes, "replay_bytes",
"Total bytes replayed", nullptr, prio,
unit_t(UNIT_BYTES));
plb.add_time_avg(l_rbd_mirror_journal_replay_latency, "replay_latency",
"Replay latency", nullptr, prio);
m_perf_counters = plb.create_perf_counters();
g_ceph_context->get_perfcounters_collection()->add(m_perf_counters);
}
template <typename I>
void Replayer<I>::unregister_perf_counters() {
dout(5) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
PerfCounters *perf_counters = nullptr;
std::swap(perf_counters, m_perf_counters);
if (perf_counters != nullptr) {
g_ceph_context->get_perfcounters_collection()->remove(perf_counters);
delete perf_counters;
}
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::Replayer<librbd::ImageCtx>;
| 40,251 | 29.540212 | 80 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/Replayer.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_REPLAYER_H
#define RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_REPLAYER_H
#include "tools/rbd_mirror/image_replayer/Replayer.h"
#include "include/utime.h"
#include "common/AsyncOpTracker.h"
#include "common/ceph_mutex.h"
#include "common/RefCountedObj.h"
#include "cls/journal/cls_journal_types.h"
#include "journal/ReplayEntry.h"
#include "librbd/ImageCtx.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include <string>
#include <type_traits>
namespace journal { class Journaler; }
namespace librbd {
struct ImageCtx;
namespace journal { template <typename I> class Replay; }
} // namespace librbd
namespace rbd {
namespace mirror {
template <typename> struct Threads;
namespace image_replayer {
struct ReplayerListener;
namespace journal {
template <typename> class EventPreprocessor;
template <typename> class ReplayStatusFormatter;
template <typename> class StateBuilder;
template <typename ImageCtxT>
class Replayer : public image_replayer::Replayer {
public:
typedef typename librbd::journal::TypeTraits<ImageCtxT>::Journaler Journaler;
static Replayer* create(
Threads<ImageCtxT>* threads,
const std::string& local_mirror_uuid,
StateBuilder<ImageCtxT>* state_builder,
ReplayerListener* replayer_listener) {
return new Replayer(threads, local_mirror_uuid, state_builder,
replayer_listener);
}
Replayer(
Threads<ImageCtxT>* threads,
const std::string& local_mirror_uuid,
StateBuilder<ImageCtxT>* state_builder,
ReplayerListener* replayer_listener);
~Replayer();
void destroy() override {
delete this;
}
void init(Context* on_finish) override;
void shut_down(Context* on_finish) override;
void flush(Context* on_finish) override;
bool get_replay_status(std::string* description, Context* on_finish) override;
bool is_replaying() const override {
std::unique_lock locker{m_lock};
return (m_state == STATE_REPLAYING);
}
bool is_resync_requested() const override {
std::unique_lock locker(m_lock);
return m_resync_requested;
}
int get_error_code() const override {
std::unique_lock locker(m_lock);
return m_error_code;
}
std::string get_error_description() const override {
std::unique_lock locker(m_lock);
return m_error_description;
}
std::string get_image_spec() const {
std::unique_lock locker(m_lock);
return m_image_spec;
}
private:
/**
* @verbatim
*
* <init>
* |
* v (error)
* INIT_REMOTE_JOURNALER * * * * * * * * * * * * * * * * * * *
* | *
* v (error) *
* START_EXTERNAL_REPLAY * * * * * * * * * * * * * * * * * * *
* | *
* | /--------------------------------------------\ *
* | | | *
* v v (asok flush) | *
* REPLAYING -------------> LOCAL_REPLAY_FLUSH | *
* | \ | | *
* | | v | *
* | | FLUSH_COMMIT_POSITION | *
* | | | | *
* | | \--------------------/| *
* | | | *
* | | (entries available) | *
* | \-----------> REPLAY_READY | *
* | | | *
* | | (skip if not | *
* | v needed) (error) *
* | REPLAY_FLUSH * * * * * * * * * *
* | | | * *
* | | (skip if not | * *
* | v needed) (error) * *
* | GET_REMOTE_TAG * * * * * * * * *
* | | | * *
* | | (skip if not | * *
* | v needed) (error) * *
* | ALLOCATE_LOCAL_TAG * * * * * * *
* | | | * *
* | v (error) * *
* | PREPROCESS_ENTRY * * * * * * * *
* | | | * *
* | v (error) * *
* | PROCESS_ENTRY * * * * * * * * * *
* | | | * *
* | \---------------------/ * *
* v (shutdown) * *
* REPLAY_COMPLETE < * * * * * * * * * * * * * * * * * * * *
* | *
* v *
* WAIT_FOR_FLUSH *
* | *
* v *
* SHUT_DOWN_LOCAL_JOURNAL_REPLAY *
* | *
* v *
* WAIT_FOR_REPLAY *
* | *
* v *
* CLOSE_LOCAL_IMAGE < * * * * * * * * * * * * * * * * * * * *
* |
* v (skip if not started)
* STOP_REMOTE_JOURNALER_REPLAY
* |
* v
* WAIT_FOR_IN_FLIGHT_OPS
* |
* v
* <shutdown>
*
* @endverbatim
*/
typedef typename librbd::journal::TypeTraits<ImageCtxT>::ReplayEntry ReplayEntry;
enum State {
STATE_INIT,
STATE_REPLAYING,
STATE_COMPLETE
};
struct C_ReplayCommitted;
struct RemoteJournalerListener;
struct RemoteReplayHandler;
struct LocalJournalListener;
Threads<ImageCtxT>* m_threads;
std::string m_local_mirror_uuid;
StateBuilder<ImageCtxT>* m_state_builder;
ReplayerListener* m_replayer_listener;
mutable ceph::mutex m_lock;
std::string m_image_spec;
Context* m_on_init_shutdown = nullptr;
State m_state = STATE_INIT;
int m_error_code = 0;
std::string m_error_description;
bool m_resync_requested = false;
ceph::ref_t<typename std::remove_pointer<decltype(ImageCtxT::journal)>::type>
m_local_journal;
RemoteJournalerListener* m_remote_listener = nullptr;
librbd::journal::Replay<ImageCtxT>* m_local_journal_replay = nullptr;
EventPreprocessor<ImageCtxT>* m_event_preprocessor = nullptr;
ReplayStatusFormatter<ImageCtxT>* m_replay_status_formatter = nullptr;
RemoteReplayHandler* m_remote_replay_handler = nullptr;
LocalJournalListener* m_local_journal_listener = nullptr;
PerfCounters *m_perf_counters = nullptr;
ReplayEntry m_replay_entry;
uint64_t m_replay_bytes = 0;
utime_t m_replay_start_time;
bool m_replay_tag_valid = false;
uint64_t m_replay_tag_tid = 0;
cls::journal::Tag m_replay_tag;
librbd::journal::TagData m_replay_tag_data;
librbd::journal::EventEntry m_event_entry;
AsyncOpTracker m_flush_tracker;
AsyncOpTracker m_event_replay_tracker;
Context *m_delayed_preprocess_task = nullptr;
AsyncOpTracker m_in_flight_op_tracker;
Context *m_flush_local_replay_task = nullptr;
void handle_remote_journal_metadata_updated();
void schedule_flush_local_replay_task();
void cancel_flush_local_replay_task();
void handle_flush_local_replay_task(int r);
void flush_local_replay(Context* on_flush);
void handle_flush_local_replay(Context* on_flush, int r);
void flush_commit_position(Context* on_flush);
void handle_flush_commit_position(Context* on_flush, int r);
void init_remote_journaler();
void handle_init_remote_journaler(int r);
void start_external_replay(std::unique_lock<ceph::mutex>& locker);
void handle_start_external_replay(int r);
bool add_local_journal_listener(std::unique_lock<ceph::mutex>& locker);
bool notify_init_complete(std::unique_lock<ceph::mutex>& locker);
void wait_for_flush();
void handle_wait_for_flush(int r);
void shut_down_local_journal_replay();
void handle_shut_down_local_journal_replay(int r);
void wait_for_event_replay();
void handle_wait_for_event_replay(int r);
void close_local_image();
void handle_close_local_image(int r);
void stop_remote_journaler_replay();
void handle_stop_remote_journaler_replay(int r);
void wait_for_in_flight_ops();
void handle_wait_for_in_flight_ops(int r);
void replay_flush();
void handle_replay_flush_shut_down(int r);
void handle_replay_flush(int r);
void get_remote_tag();
void handle_get_remote_tag(int r);
void allocate_local_tag();
void handle_allocate_local_tag(int r);
void handle_replay_error(int r, const std::string &error);
bool is_replay_complete() const;
bool is_replay_complete(const std::unique_lock<ceph::mutex>& locker) const;
void handle_replay_complete(int r, const std::string &error_desc);
void handle_replay_complete(const std::unique_lock<ceph::mutex>&,
int r, const std::string &error_desc);
void handle_replay_ready();
void handle_replay_ready(std::unique_lock<ceph::mutex>& locker);
void preprocess_entry();
void handle_delayed_preprocess_task(int r);
void handle_preprocess_entry_ready(int r);
void handle_preprocess_entry_safe(int r);
void process_entry();
void handle_process_entry_ready(int r);
void handle_process_entry_safe(const ReplayEntry& replay_entry,
uint64_t relay_bytes,
const utime_t &replay_start_time, int r);
void handle_resync_image();
void notify_status_updated();
void cancel_delayed_preprocess_task();
int validate_remote_client_state(
const cls::journal::Client& remote_client,
librbd::journal::MirrorPeerClientMeta* remote_client_meta,
bool* resync_requested, std::string* error);
void register_perf_counters();
void unregister_perf_counters();
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::Replayer<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_REPLAYER_H
| 10,900 | 32.645062 | 87 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/StateBuilder.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "StateBuilder.h"
#include "include/ceph_assert.h"
#include "include/Context.h"
#include "common/debug.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "tools/rbd_mirror/image_replayer/journal/CreateLocalImageRequest.h"
#include "tools/rbd_mirror/image_replayer/journal/PrepareReplayRequest.h"
#include "tools/rbd_mirror/image_replayer/journal/Replayer.h"
#include "tools/rbd_mirror/image_replayer/journal/SyncPointHandler.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "StateBuilder: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename I>
StateBuilder<I>::StateBuilder(const std::string& global_image_id)
: image_replayer::StateBuilder<I>(global_image_id) {
}
template <typename I>
StateBuilder<I>::~StateBuilder() {
ceph_assert(remote_journaler == nullptr);
}
template <typename I>
void StateBuilder<I>::close(Context* on_finish) {
dout(10) << dendl;
// close the remote journaler after closing the local image
// in case we have lost contact w/ the remote cluster and
// will block
on_finish = new LambdaContext([this, on_finish](int) {
shut_down_remote_journaler(on_finish);
});
on_finish = new LambdaContext([this, on_finish](int) {
this->close_local_image(on_finish);
});
this->close_remote_image(on_finish);
}
template <typename I>
bool StateBuilder<I>::is_disconnected() const {
return (remote_client_state == cls::journal::CLIENT_STATE_DISCONNECTED);
}
template <typename I>
bool StateBuilder<I>::is_linked_impl() const {
ceph_assert(!this->remote_mirror_uuid.empty());
return (local_primary_mirror_uuid == this->remote_mirror_uuid);
}
template <typename I>
cls::rbd::MirrorImageMode StateBuilder<I>::get_mirror_image_mode() const {
return cls::rbd::MIRROR_IMAGE_MODE_JOURNAL;
}
template <typename I>
image_sync::SyncPointHandler* StateBuilder<I>::create_sync_point_handler() {
dout(10) << dendl;
this->m_sync_point_handler = SyncPointHandler<I>::create(this);
return this->m_sync_point_handler;
}
template <typename I>
BaseRequest* StateBuilder<I>::create_local_image_request(
Threads<I>* threads,
librados::IoCtx& local_io_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
Context* on_finish) {
return CreateLocalImageRequest<I>::create(
threads, local_io_ctx, this->remote_image_ctx, this->global_image_id,
pool_meta_cache, progress_ctx, this, on_finish);
}
template <typename I>
BaseRequest* StateBuilder<I>::create_prepare_replay_request(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
bool* resync_requested,
bool* syncing,
Context* on_finish) {
return PrepareReplayRequest<I>::create(
local_mirror_uuid, progress_ctx, this, resync_requested, syncing,
on_finish);
}
template <typename I>
image_replayer::Replayer* StateBuilder<I>::create_replayer(
Threads<I>* threads,
InstanceWatcher<I>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
ReplayerListener* replayer_listener) {
return Replayer<I>::create(
threads, local_mirror_uuid, this, replayer_listener);
}
template <typename I>
void StateBuilder<I>::shut_down_remote_journaler(Context* on_finish) {
if (remote_journaler == nullptr) {
on_finish->complete(0);
return;
}
dout(10) << dendl;
auto ctx = new LambdaContext([this, on_finish](int r) {
handle_shut_down_remote_journaler(r, on_finish);
});
remote_journaler->shut_down(ctx);
}
template <typename I>
void StateBuilder<I>::handle_shut_down_remote_journaler(int r,
Context* on_finish) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to shut down remote journaler: " << cpp_strerror(r)
<< dendl;
}
delete remote_journaler;
remote_journaler = nullptr;
on_finish->complete(r);
}
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::StateBuilder<librbd::ImageCtx>;
| 4,535 | 29.24 | 84 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/StateBuilder.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_STATE_BUILDER_H
#define CEPH_RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_STATE_BUILDER_H
#include "tools/rbd_mirror/image_replayer/StateBuilder.h"
#include "cls/journal/cls_journal_types.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename> class SyncPointHandler;
template <typename ImageCtxT>
class StateBuilder : public image_replayer::StateBuilder<ImageCtxT> {
public:
typedef librbd::journal::TypeTraits<ImageCtxT> TypeTraits;
typedef typename TypeTraits::Journaler Journaler;
static StateBuilder* create(const std::string& global_image_id) {
return new StateBuilder(global_image_id);
}
StateBuilder(const std::string& global_image_id);
~StateBuilder() override;
void close(Context* on_finish) override;
bool is_disconnected() const override;
cls::rbd::MirrorImageMode get_mirror_image_mode() const override;
image_sync::SyncPointHandler* create_sync_point_handler() override;
bool replay_requires_remote_image() const override {
return false;
}
BaseRequest* create_local_image_request(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
Context* on_finish) override;
BaseRequest* create_prepare_replay_request(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
bool* resync_requested,
bool* syncing,
Context* on_finish) override;
image_replayer::Replayer* create_replayer(
Threads<ImageCtxT>* threads,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
ReplayerListener* replayer_listener) override;
std::string local_primary_mirror_uuid;
Journaler* remote_journaler = nullptr;
cls::journal::ClientState remote_client_state =
cls::journal::CLIENT_STATE_CONNECTED;
librbd::journal::MirrorPeerClientMeta remote_client_meta;
SyncPointHandler<ImageCtxT>* sync_point_handler = nullptr;
private:
bool is_linked_impl() const override;
void shut_down_remote_journaler(Context* on_finish);
void handle_shut_down_remote_journaler(int r, Context* on_finish);
};
} // namespace journal
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::StateBuilder<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_STATE_BUILDER_H
| 2,810 | 28.589474 | 91 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/SyncPointHandler.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "SyncPointHandler.h"
#include "StateBuilder.h"
#include "include/ceph_assert.h"
#include "include/Context.h"
#include "common/debug.h"
#include "common/errno.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::journal::" \
<< "SyncPointHandler: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename I>
SyncPointHandler<I>::SyncPointHandler(StateBuilder<I>* state_builder)
: m_state_builder(state_builder),
m_client_meta_copy(state_builder->remote_client_meta) {
}
template <typename I>
typename SyncPointHandler<I>::SyncPoints
SyncPointHandler<I>::get_sync_points() const {
SyncPoints sync_points;
for (auto& sync_point : m_client_meta_copy.sync_points) {
sync_points.emplace_back(
sync_point.snap_namespace,
sync_point.snap_name,
sync_point.from_snap_name,
sync_point.object_number);
}
return sync_points;
}
template <typename I>
librbd::SnapSeqs SyncPointHandler<I>::get_snap_seqs() const {
return m_client_meta_copy.snap_seqs;
}
template <typename I>
void SyncPointHandler<I>::update_sync_points(
const librbd::SnapSeqs& snap_seqs, const SyncPoints& sync_points,
bool sync_complete, Context* on_finish) {
dout(10) << dendl;
if (sync_complete && sync_points.empty()) {
m_client_meta_copy.state = librbd::journal::MIRROR_PEER_STATE_REPLAYING;
}
m_client_meta_copy.snap_seqs = snap_seqs;
m_client_meta_copy.sync_points.clear();
for (auto& sync_point : sync_points) {
m_client_meta_copy.sync_points.emplace_back(
sync_point.snap_namespace,
sync_point.snap_name,
sync_point.from_snap_name,
sync_point.object_number);
if (sync_point.object_number) {
m_client_meta_copy.sync_object_count = std::max(
m_client_meta_copy.sync_object_count, *sync_point.object_number + 1);
}
}
dout(20) << "client_meta=" << m_client_meta_copy << dendl;
bufferlist client_data_bl;
librbd::journal::ClientData client_data{m_client_meta_copy};
encode(client_data, client_data_bl);
auto ctx = new LambdaContext([this, on_finish](int r) {
handle_update_sync_points(r, on_finish);
});
m_state_builder->remote_journaler->update_client(client_data_bl, ctx);
}
template <typename I>
void SyncPointHandler<I>::handle_update_sync_points(int r, Context* on_finish) {
dout(10) << "r=" << r << dendl;
if (r >= 0) {
m_state_builder->remote_client_meta.snap_seqs =
m_client_meta_copy.snap_seqs;
m_state_builder->remote_client_meta.sync_points =
m_client_meta_copy.sync_points;
} else {
derr << "failed to update remote journal client meta for image "
<< m_state_builder->global_image_id << ": " << cpp_strerror(r)
<< dendl;
}
on_finish->complete(r);
}
} // namespace journal
} // namespace image_sync
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::journal::SyncPointHandler<librbd::ImageCtx>;
| 3,318 | 29.172727 | 88 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/journal/SyncPointHandler.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_SYNC_POINT_HANDLER_H
#define RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_SYNC_POINT_HANDLER_H
#include "tools/rbd_mirror/image_sync/Types.h"
#include "librbd/journal/Types.h"
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace journal {
template <typename> class StateBuilder;
template <typename ImageCtxT>
class SyncPointHandler : public image_sync::SyncPointHandler {
public:
using SyncPoint = image_sync::SyncPoint;
using SyncPoints = image_sync::SyncPoints;
static SyncPointHandler* create(StateBuilder<ImageCtxT>* state_builder) {
return new SyncPointHandler(state_builder);
}
SyncPointHandler(StateBuilder<ImageCtxT>* state_builder);
SyncPoints get_sync_points() const override;
librbd::SnapSeqs get_snap_seqs() const override;
void update_sync_points(const librbd::SnapSeqs& snap_seqs,
const SyncPoints& sync_points,
bool sync_complete,
Context* on_finish) override;
private:
StateBuilder<ImageCtxT>* m_state_builder;
librbd::journal::MirrorPeerClientMeta m_client_meta_copy;
void handle_update_sync_points(int r, Context* on_finish);
};
} // namespace journal
} // namespace image_sync
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::journal::SyncPointHandler<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_SYNC_POINT_HANDLER_H
| 1,620 | 27.946429 | 95 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/ApplyImageStateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "ApplyImageStateRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#include "librbd/image/GetMetadataRequest.h"
#include "tools/rbd_mirror/image_replayer/snapshot/Utils.h"
#include <boost/algorithm/string/predicate.hpp>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::" \
<< "ApplyImageStateRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
ApplyImageStateRequest<I>::ApplyImageStateRequest(
const std::string& local_mirror_uuid,
const std::string& remote_mirror_uuid,
I* local_image_ctx,
I* remote_image_ctx,
librbd::mirror::snapshot::ImageState image_state,
Context* on_finish)
: m_local_mirror_uuid(local_mirror_uuid),
m_remote_mirror_uuid(remote_mirror_uuid),
m_local_image_ctx(local_image_ctx),
m_remote_image_ctx(remote_image_ctx),
m_image_state(image_state),
m_on_finish(on_finish) {
dout(15) << "image_state=" << m_image_state << dendl;
std::shared_lock image_locker{m_local_image_ctx->image_lock};
m_features = m_local_image_ctx->features & ~RBD_FEATURES_IMPLICIT_ENABLE;
compute_local_to_remote_snap_ids();
}
template <typename I>
void ApplyImageStateRequest<I>::send() {
rename_image();
}
template <typename I>
void ApplyImageStateRequest<I>::rename_image() {
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
std::shared_lock image_locker{m_local_image_ctx->image_lock};
if (m_local_image_ctx->name == m_image_state.name) {
image_locker.unlock();
owner_locker.unlock();
update_features();
return;
}
image_locker.unlock();
dout(15) << "local_image_name=" << m_local_image_ctx->name << ", "
<< "remote_image_name=" << m_image_state.name << dendl;
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_rename_image>(this);
m_local_image_ctx->operations->execute_rename(m_image_state.name, ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_rename_image(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to rename image to '" << m_image_state.name << "': "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
update_features();
}
template <typename I>
void ApplyImageStateRequest<I>::update_features() {
uint64_t feature_updates = 0UL;
bool enabled = false;
auto image_state_features =
m_image_state.features & ~RBD_FEATURES_IMPLICIT_ENABLE;
feature_updates = (m_features & ~image_state_features);
if (feature_updates == 0UL) {
feature_updates = (image_state_features & ~m_features);
enabled = (feature_updates != 0UL);
}
if (feature_updates == 0UL) {
get_image_meta();
return;
}
dout(15) << "image_features=" << m_features << ", "
<< "state_features=" << image_state_features << ", "
<< "feature_updates=" << feature_updates << ", "
<< "enabled=" << enabled << dendl;
if (enabled) {
m_features |= feature_updates;
} else {
m_features &= ~feature_updates;
}
std::shared_lock owner_lock{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_update_features>(this);
m_local_image_ctx->operations->execute_update_features(
feature_updates, enabled, ctx, 0U);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_update_features(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update image features: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
update_features();
}
template <typename I>
void ApplyImageStateRequest<I>::get_image_meta() {
dout(15) << dendl;
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_get_image_meta>(this);
auto req = librbd::image::GetMetadataRequest<I>::create(
m_local_image_ctx->md_ctx, m_local_image_ctx->header_oid, true, "", "", 0U,
&m_metadata, ctx);
req->send();
}
template <typename I>
void ApplyImageStateRequest<I>::handle_get_image_meta(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to fetch local image metadata: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
update_image_meta();
}
template <typename I>
void ApplyImageStateRequest<I>::update_image_meta() {
std::set<std::string> keys_to_remove;
for (const auto& [key, value] : m_metadata) {
if (m_image_state.metadata.count(key) == 0) {
dout(15) << "removing image-meta key '" << key << "'" << dendl;
keys_to_remove.insert(key);
}
}
std::map<std::string, bufferlist> metadata_to_update;
for (const auto& [key, value] : m_image_state.metadata) {
auto it = m_metadata.find(key);
if (it == m_metadata.end() || !it->second.contents_equal(value)) {
dout(15) << "updating image-meta key '" << key << "'" << dendl;
metadata_to_update.insert({key, value});
}
}
if (keys_to_remove.empty() && metadata_to_update.empty()) {
unprotect_snapshot();
return;
}
dout(15) << dendl;
librados::ObjectWriteOperation op;
for (const auto& key : keys_to_remove) {
librbd::cls_client::metadata_remove(&op, key);
}
if (!metadata_to_update.empty()) {
librbd::cls_client::metadata_set(&op, metadata_to_update);
}
auto aio_comp = create_rados_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_update_image_meta>(this);
int r = m_local_image_ctx->md_ctx.aio_operate(m_local_image_ctx->header_oid, aio_comp,
&op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void ApplyImageStateRequest<I>::handle_update_image_meta(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update image metadata: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
m_metadata.clear();
m_prev_snap_id = CEPH_NOSNAP;
unprotect_snapshot();
}
template <typename I>
void ApplyImageStateRequest<I>::unprotect_snapshot() {
std::shared_lock image_locker{m_local_image_ctx->image_lock};
auto snap_it = m_local_image_ctx->snap_info.begin();
if (m_prev_snap_id != CEPH_NOSNAP) {
snap_it = m_local_image_ctx->snap_info.upper_bound(m_prev_snap_id);
}
for (; snap_it != m_local_image_ctx->snap_info.end(); ++snap_it) {
auto snap_id = snap_it->first;
const auto& snap_info = snap_it->second;
auto user_ns = std::get_if<cls::rbd::UserSnapshotNamespace>(
&snap_info.snap_namespace);
if (user_ns == nullptr) {
dout(20) << "snapshot " << snap_id << " is not a user snapshot" << dendl;
continue;
}
if (snap_info.protection_status == RBD_PROTECTION_STATUS_UNPROTECTED) {
dout(20) << "snapshot " << snap_id << " is already unprotected" << dendl;
continue;
}
auto snap_id_map_it = m_local_to_remote_snap_ids.find(snap_id);
if (snap_id_map_it == m_local_to_remote_snap_ids.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image"
<< dendl;
break;
}
auto remote_snap_id = snap_id_map_it->second;
auto snap_state_it = m_image_state.snapshots.find(remote_snap_id);
if (snap_state_it == m_image_state.snapshots.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image "
<< "state" << dendl;
break;
}
const auto& snap_state = snap_state_it->second;
if (snap_state.protection_status == RBD_PROTECTION_STATUS_UNPROTECTED) {
dout(15) << "snapshot " << snap_id << " is unprotected in remote image"
<< dendl;
break;
}
}
if (snap_it == m_local_image_ctx->snap_info.end()) {
image_locker.unlock();
// no local snapshots to unprotect
m_prev_snap_id = CEPH_NOSNAP;
remove_snapshot();
return;
}
m_prev_snap_id = snap_it->first;
m_snap_name = snap_it->second.name;
image_locker.unlock();
dout(15) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_prev_snap_id << dendl;
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_unprotect_snapshot>(this);
m_local_image_ctx->operations->execute_snap_unprotect(
cls::rbd::UserSnapshotNamespace{}, m_snap_name.c_str(), ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_unprotect_snapshot(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to unprotect snapshot " << m_snap_name << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
unprotect_snapshot();
}
template <typename I>
void ApplyImageStateRequest<I>::remove_snapshot() {
std::shared_lock image_locker{m_local_image_ctx->image_lock};
auto snap_it = m_local_image_ctx->snap_info.begin();
if (m_prev_snap_id != CEPH_NOSNAP) {
snap_it = m_local_image_ctx->snap_info.upper_bound(m_prev_snap_id);
}
for (; snap_it != m_local_image_ctx->snap_info.end(); ++snap_it) {
auto snap_id = snap_it->first;
const auto& snap_info = snap_it->second;
auto user_ns = std::get_if<cls::rbd::UserSnapshotNamespace>(
&snap_info.snap_namespace);
if (user_ns == nullptr) {
dout(20) << "snapshot " << snap_id << " is not a user snapshot" << dendl;
continue;
}
auto snap_id_map_it = m_local_to_remote_snap_ids.find(snap_id);
if (snap_id_map_it == m_local_to_remote_snap_ids.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image"
<< dendl;
break;
}
auto remote_snap_id = snap_id_map_it->second;
auto snap_state_it = m_image_state.snapshots.find(remote_snap_id);
if (snap_state_it == m_image_state.snapshots.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image "
<< "state" << dendl;
break;
}
}
if (snap_it == m_local_image_ctx->snap_info.end()) {
image_locker.unlock();
// no local snapshots to remove
m_prev_snap_id = CEPH_NOSNAP;
protect_snapshot();
return;
}
m_prev_snap_id = snap_it->first;
m_snap_name = snap_it->second.name;
image_locker.unlock();
dout(15) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_prev_snap_id << dendl;
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_remove_snapshot>(this);
m_local_image_ctx->operations->execute_snap_remove(
cls::rbd::UserSnapshotNamespace{}, m_snap_name.c_str(), ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_remove_snapshot(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to remove snapshot " << m_snap_name << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
remove_snapshot();
}
template <typename I>
void ApplyImageStateRequest<I>::protect_snapshot() {
std::shared_lock image_locker{m_local_image_ctx->image_lock};
auto snap_it = m_local_image_ctx->snap_info.begin();
if (m_prev_snap_id != CEPH_NOSNAP) {
snap_it = m_local_image_ctx->snap_info.upper_bound(m_prev_snap_id);
}
for (; snap_it != m_local_image_ctx->snap_info.end(); ++snap_it) {
auto snap_id = snap_it->first;
const auto& snap_info = snap_it->second;
auto user_ns = std::get_if<cls::rbd::UserSnapshotNamespace>(
&snap_info.snap_namespace);
if (user_ns == nullptr) {
dout(20) << "snapshot " << snap_id << " is not a user snapshot" << dendl;
continue;
}
if (snap_info.protection_status == RBD_PROTECTION_STATUS_PROTECTED) {
dout(20) << "snapshot " << snap_id << " is already protected" << dendl;
continue;
}
auto snap_id_map_it = m_local_to_remote_snap_ids.find(snap_id);
if (snap_id_map_it == m_local_to_remote_snap_ids.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image"
<< dendl;
continue;
}
auto remote_snap_id = snap_id_map_it->second;
auto snap_state_it = m_image_state.snapshots.find(remote_snap_id);
if (snap_state_it == m_image_state.snapshots.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image "
<< "state" << dendl;
continue;
}
const auto& snap_state = snap_state_it->second;
if (snap_state.protection_status == RBD_PROTECTION_STATUS_PROTECTED) {
dout(15) << "snapshot " << snap_id << " is protected in remote image"
<< dendl;
break;
}
}
if (snap_it == m_local_image_ctx->snap_info.end()) {
image_locker.unlock();
// no local snapshots to protect
m_prev_snap_id = CEPH_NOSNAP;
rename_snapshot();
return;
}
m_prev_snap_id = snap_it->first;
m_snap_name = snap_it->second.name;
image_locker.unlock();
dout(15) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_prev_snap_id << dendl;
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_protect_snapshot>(this);
m_local_image_ctx->operations->execute_snap_protect(
cls::rbd::UserSnapshotNamespace{}, m_snap_name.c_str(), ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_protect_snapshot(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to protect snapshot " << m_snap_name << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
protect_snapshot();
}
template <typename I>
void ApplyImageStateRequest<I>::rename_snapshot() {
std::shared_lock image_locker{m_local_image_ctx->image_lock};
auto snap_it = m_local_image_ctx->snap_info.begin();
if (m_prev_snap_id != CEPH_NOSNAP) {
snap_it = m_local_image_ctx->snap_info.upper_bound(m_prev_snap_id);
}
for (; snap_it != m_local_image_ctx->snap_info.end(); ++snap_it) {
auto snap_id = snap_it->first;
const auto& snap_info = snap_it->second;
auto user_ns = std::get_if<cls::rbd::UserSnapshotNamespace>(
&snap_info.snap_namespace);
if (user_ns == nullptr) {
dout(20) << "snapshot " << snap_id << " is not a user snapshot" << dendl;
continue;
}
auto snap_id_map_it = m_local_to_remote_snap_ids.find(snap_id);
if (snap_id_map_it == m_local_to_remote_snap_ids.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image"
<< dendl;
continue;
}
auto remote_snap_id = snap_id_map_it->second;
auto snap_state_it = m_image_state.snapshots.find(remote_snap_id);
if (snap_state_it == m_image_state.snapshots.end()) {
dout(15) << "snapshot " << snap_id << " does not exist in remote image "
<< "state" << dendl;
continue;
}
const auto& snap_state = snap_state_it->second;
if (snap_info.name != snap_state.name) {
dout(15) << "snapshot " << snap_id << " has been renamed from '"
<< snap_info.name << "' to '" << snap_state.name << "'"
<< dendl;
m_snap_name = snap_state.name;
break;
}
}
if (snap_it == m_local_image_ctx->snap_info.end()) {
image_locker.unlock();
// no local snapshots to protect
m_prev_snap_id = CEPH_NOSNAP;
set_snapshot_limit();
return;
}
m_prev_snap_id = snap_it->first;
image_locker.unlock();
dout(15) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_prev_snap_id << dendl;
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_rename_snapshot>(this);
m_local_image_ctx->operations->execute_snap_rename(
m_prev_snap_id, m_snap_name.c_str(), ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_rename_snapshot(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to protect snapshot " << m_snap_name << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
rename_snapshot();
}
template <typename I>
void ApplyImageStateRequest<I>::set_snapshot_limit() {
dout(15) << "snap_limit=" << m_image_state.snap_limit << dendl;
// no need to even check the current limit -- just set it
std::shared_lock owner_locker{m_local_image_ctx->owner_lock};
auto ctx = create_context_callback<
ApplyImageStateRequest<I>,
&ApplyImageStateRequest<I>::handle_set_snapshot_limit>(this);
m_local_image_ctx->operations->execute_snap_set_limit(
m_image_state.snap_limit, ctx);
}
template <typename I>
void ApplyImageStateRequest<I>::handle_set_snapshot_limit(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update snapshot limit: " << cpp_strerror(r)
<< dendl;
}
finish(r);
}
template <typename I>
void ApplyImageStateRequest<I>::finish(int r) {
dout(15) << "r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
template <typename I>
uint64_t ApplyImageStateRequest<I>::compute_remote_snap_id(
uint64_t local_snap_id) {
ceph_assert(ceph_mutex_is_locked(m_local_image_ctx->image_lock));
ceph_assert(ceph_mutex_is_locked(m_remote_image_ctx->image_lock));
// Search our local non-primary snapshots for a mapping to the remote
// snapshot. The non-primary mirror snapshot with the mappings will always
// come at or after the snapshot we are searching against
auto remote_snap_id = util::compute_remote_snap_id(
m_local_image_ctx->image_lock, m_local_image_ctx->snap_info,
local_snap_id, m_remote_mirror_uuid);
if (remote_snap_id != CEPH_NOSNAP) {
return remote_snap_id;
}
// if we failed to find a match to a remote snapshot in our local non-primary
// snapshots, check the remote image for non-primary snapshot mappings back
// to our snapshot
for (auto snap_it = m_remote_image_ctx->snap_info.begin();
snap_it != m_remote_image_ctx->snap_info.end(); ++snap_it) {
auto snap_id = snap_it->first;
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&snap_it->second.snap_namespace);
if (mirror_ns == nullptr || !mirror_ns->is_non_primary()) {
continue;
}
if (mirror_ns->primary_mirror_uuid != m_local_mirror_uuid) {
dout(20) << "remote snapshot " << snap_id << " not tied to local"
<< dendl;
continue;
} else if (mirror_ns->primary_snap_id == local_snap_id) {
dout(15) << "local snapshot " << local_snap_id << " maps to "
<< "remote snapshot " << snap_id << dendl;
return snap_id;
}
const auto& snap_seqs = mirror_ns->snap_seqs;
for (auto [local_snap_id_seq, remote_snap_id_seq] : snap_seqs) {
if (local_snap_id_seq == local_snap_id) {
dout(15) << "local snapshot " << local_snap_id << " maps to "
<< "remote snapshot " << remote_snap_id_seq << dendl;
return remote_snap_id_seq;
}
}
}
return CEPH_NOSNAP;
}
template <typename I>
void ApplyImageStateRequest<I>::compute_local_to_remote_snap_ids() {
ceph_assert(ceph_mutex_is_locked(m_local_image_ctx->image_lock));
std::shared_lock remote_image_locker{m_remote_image_ctx->image_lock};
for (const auto& [snap_id, snap_info] : m_local_image_ctx->snap_info) {
m_local_to_remote_snap_ids[snap_id] = compute_remote_snap_id(snap_id);
}
dout(15) << "local_to_remote_snap_ids=" << m_local_to_remote_snap_ids
<< dendl;
}
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::snapshot::ApplyImageStateRequest<librbd::ImageCtx>;
| 20,398 | 29.954476 | 95 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/ApplyImageStateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_APPLY_IMAGE_STATE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_APPLY_IMAGE_STATE_REQUEST_H
#include "common/ceph_mutex.h"
#include "librbd/mirror/snapshot/Types.h"
#include <map>
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
template <typename> class EventPreprocessor;
template <typename> class ReplayStatusFormatter;
template <typename> class StateBuilder;
template <typename ImageCtxT>
class ApplyImageStateRequest {
public:
static ApplyImageStateRequest* create(
const std::string& local_mirror_uuid,
const std::string& remote_mirror_uuid,
ImageCtxT* local_image_ctx,
ImageCtxT* remote_image_ctx,
librbd::mirror::snapshot::ImageState image_state,
Context* on_finish) {
return new ApplyImageStateRequest(local_mirror_uuid, remote_mirror_uuid,
local_image_ctx, remote_image_ctx,
image_state, on_finish);
}
ApplyImageStateRequest(
const std::string& local_mirror_uuid,
const std::string& remote_mirror_uuid,
ImageCtxT* local_image_ctx,
ImageCtxT* remote_image_ctx,
librbd::mirror::snapshot::ImageState image_state,
Context* on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* RENAME_IMAGE
* |
* | /---------\
* | | |
* v v |
* UPDATE_FEATURES -----/
* |
* v
* GET_IMAGE_META
* |
* | /---------\
* | | |
* v v |
* UPDATE_IMAGE_META ---/
* |
* | /---------\
* | | |
* v v |
* UNPROTECT_SNAPSHOT |
* | |
* v |
* REMOVE_SNAPSHOT |
* | |
* v |
* PROTECT_SNAPSHOT |
* | |
* v |
* RENAME_SNAPSHOT -----/
* |
* v
* SET_SNAPSHOT_LIMIT
* |
* v
* <finish>
*
* @endverbatim
*/
std::string m_local_mirror_uuid;
std::string m_remote_mirror_uuid;
ImageCtxT* m_local_image_ctx;
ImageCtxT* m_remote_image_ctx;
librbd::mirror::snapshot::ImageState m_image_state;
Context* m_on_finish;
std::map<uint64_t, uint64_t> m_local_to_remote_snap_ids;
uint64_t m_features = 0;
std::map<std::string, bufferlist> m_metadata;
uint64_t m_prev_snap_id = 0;
std::string m_snap_name;
void rename_image();
void handle_rename_image(int r);
void update_features();
void handle_update_features(int r);
void get_image_meta();
void handle_get_image_meta(int r);
void update_image_meta();
void handle_update_image_meta(int r);
void unprotect_snapshot();
void handle_unprotect_snapshot(int r);
void remove_snapshot();
void handle_remove_snapshot(int r);
void protect_snapshot();
void handle_protect_snapshot(int r);
void rename_snapshot();
void handle_rename_snapshot(int r);
void set_snapshot_limit();
void handle_set_snapshot_limit(int r);
void finish(int r);
uint64_t compute_remote_snap_id(uint64_t snap_id);
void compute_local_to_remote_snap_ids();
};
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::snapshot::ApplyImageStateRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_APPLY_IMAGE_STATE_REQUEST_H
| 3,754 | 23.070513 | 102 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/CreateLocalImageRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "CreateLocalImageRequest.h"
#include "include/rados/librados.hpp"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "tools/rbd_mirror/ProgressContext.h"
#include "tools/rbd_mirror/image_replayer/CreateImageRequest.h"
#include "tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::" \
<< "CreateLocalImageRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
void CreateLocalImageRequest<I>::send() {
disable_mirror_image();
}
template <typename I>
void CreateLocalImageRequest<I>::disable_mirror_image() {
if (m_state_builder->local_image_id.empty()) {
add_mirror_image();
return;
}
dout(10) << dendl;
update_progress("DISABLE_MIRROR_IMAGE");
// need to send 'disabling' since the cls methods will fail if we aren't
// in that state
cls::rbd::MirrorImage mirror_image{
cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT, m_global_image_id,
cls::rbd::MIRROR_IMAGE_STATE_DISABLING};
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_set(&op, m_state_builder->local_image_id,
mirror_image);
auto aio_comp = create_rados_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_disable_mirror_image>(this);
int r = m_local_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void CreateLocalImageRequest<I>::handle_disable_mirror_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to disable mirror image " << m_global_image_id << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
remove_mirror_image();
}
template <typename I>
void CreateLocalImageRequest<I>::remove_mirror_image() {
dout(10) << dendl;
update_progress("REMOVE_MIRROR_IMAGE");
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_remove(&op, m_state_builder->local_image_id);
auto aio_comp = create_rados_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_remove_mirror_image>(this);
int r = m_local_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void CreateLocalImageRequest<I>::handle_remove_mirror_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to remove mirror image " << m_global_image_id << ": "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
m_state_builder->local_image_id = "";
add_mirror_image();
}
template <typename I>
void CreateLocalImageRequest<I>::add_mirror_image() {
ceph_assert(m_state_builder->local_image_id.empty());
m_state_builder->local_image_id =
librbd::util::generate_image_id<I>(m_local_io_ctx);
dout(10) << "local_image_id=" << m_state_builder->local_image_id << dendl;
update_progress("ADD_MIRROR_IMAGE");
// use 'creating' to track a partially constructed image. it will
// be switched to 'enabled' once the image is fully created
cls::rbd::MirrorImage mirror_image{
cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT, m_global_image_id,
cls::rbd::MIRROR_IMAGE_STATE_CREATING};
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_set(&op, m_state_builder->local_image_id,
mirror_image);
auto aio_comp = create_rados_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_add_mirror_image>(this);
int r = m_local_io_ctx.aio_operate(RBD_MIRRORING, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void CreateLocalImageRequest<I>::handle_add_mirror_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to register mirror image " << m_global_image_id << ": "
<< cpp_strerror(r) << dendl;
this->finish(r);
return;
}
create_local_image();
}
template <typename I>
void CreateLocalImageRequest<I>::create_local_image() {
dout(10) << "local_image_id=" << m_state_builder->local_image_id << dendl;
update_progress("CREATE_LOCAL_IMAGE");
m_remote_image_ctx->image_lock.lock_shared();
std::string image_name = m_remote_image_ctx->name;
m_remote_image_ctx->image_lock.unlock_shared();
auto ctx = create_context_callback<
CreateLocalImageRequest<I>,
&CreateLocalImageRequest<I>::handle_create_local_image>(this);
auto request = CreateImageRequest<I>::create(
m_threads, m_local_io_ctx, m_global_image_id,
m_state_builder->remote_mirror_uuid, image_name,
m_state_builder->local_image_id, m_remote_image_ctx,
m_pool_meta_cache, cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT, ctx);
request->send();
}
template <typename I>
void CreateLocalImageRequest<I>::handle_create_local_image(int r) {
dout(10) << "r=" << r << dendl;
if (r == -EBADF) {
dout(5) << "image id " << m_state_builder->local_image_id << " "
<< "already in-use" << dendl;
disable_mirror_image();
return;
} else if (r < 0) {
if (r == -ENOENT) {
dout(10) << "parent image does not exist" << dendl;
} else {
derr << "failed to create local image: " << cpp_strerror(r) << dendl;
}
finish(r);
return;
}
finish(0);
}
template <typename I>
void CreateLocalImageRequest<I>::update_progress(
const std::string& description) {
dout(15) << description << dendl;
if (m_progress_ctx != nullptr) {
m_progress_ctx->update_progress(description);
}
}
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::snapshot::CreateLocalImageRequest<librbd::ImageCtx>;
| 6,315 | 29.809756 | 96 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/CreateLocalImageRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_CREATE_LOCAL_IMAGE_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_CREATE_LOCAL_IMAGE_REQUEST_H
#include "include/rados/librados_fwd.hpp"
#include "tools/rbd_mirror/BaseRequest.h"
#include <string>
struct Context;
namespace librbd { class ImageCtx; }
namespace rbd {
namespace mirror {
class PoolMetaCache;
class ProgressContext;
template <typename> struct Threads;
namespace image_replayer {
namespace snapshot {
template <typename> class StateBuilder;
template <typename ImageCtxT>
class CreateLocalImageRequest : public BaseRequest {
public:
typedef rbd::mirror::ProgressContext ProgressContext;
static CreateLocalImageRequest* create(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
ImageCtxT* remote_image_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
Context* on_finish) {
return new CreateLocalImageRequest(threads, local_io_ctx, remote_image_ctx,
global_image_id, pool_meta_cache,
progress_ctx, state_builder, on_finish);
}
CreateLocalImageRequest(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
ImageCtxT* remote_image_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
Context* on_finish)
: BaseRequest(on_finish),
m_threads(threads),
m_local_io_ctx(local_io_ctx),
m_remote_image_ctx(remote_image_ctx),
m_global_image_id(global_image_id),
m_pool_meta_cache(pool_meta_cache),
m_progress_ctx(progress_ctx),
m_state_builder(state_builder) {
}
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* DISABLE_MIRROR_IMAGE < * * * * * *
* | *
* v *
* REMOVE_MIRROR_IMAGE *
* | *
* v *
* ADD_MIRROR_IMAGE *
* | *
* v (id exists) *
* CREATE_LOCAL_IMAGE * * * * * * * *
* |
* v
* <finish>
*
* @endverbatim
*/
Threads<ImageCtxT>* m_threads;
librados::IoCtx& m_local_io_ctx;
ImageCtxT* m_remote_image_ctx;
std::string m_global_image_id;
PoolMetaCache* m_pool_meta_cache;
ProgressContext* m_progress_ctx;
StateBuilder<ImageCtxT>* m_state_builder;
void disable_mirror_image();
void handle_disable_mirror_image(int r);
void remove_mirror_image();
void handle_remove_mirror_image(int r);
void add_mirror_image();
void handle_add_mirror_image(int r);
void create_local_image();
void handle_create_local_image(int r);
void update_progress(const std::string& description);
};
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::snapshot::CreateLocalImageRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_CREATE_LOCAL_IMAGE_REQUEST_H
| 3,377 | 26.688525 | 103 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/PrepareReplayRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "PrepareReplayRequest.h"
#include "common/debug.h"
#include "common/dout.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/mirror/snapshot/ImageMeta.h"
#include "tools/rbd_mirror/ProgressContext.h"
#include "tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::" \
<< "PrepareReplayRequest: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
using librbd::util::create_context_callback;
template <typename I>
void PrepareReplayRequest<I>::send() {
*m_resync_requested = false;
*m_syncing = false;
load_local_image_meta();
}
template <typename I>
void PrepareReplayRequest<I>::load_local_image_meta() {
dout(15) << dendl;
ceph_assert(m_state_builder->local_image_meta == nullptr);
m_state_builder->local_image_meta =
librbd::mirror::snapshot::ImageMeta<I>::create(
m_state_builder->local_image_ctx, m_local_mirror_uuid);
auto ctx = create_context_callback<
PrepareReplayRequest<I>,
&PrepareReplayRequest<I>::handle_load_local_image_meta>(this);
m_state_builder->local_image_meta->load(ctx);
}
template <typename I>
void PrepareReplayRequest<I>::handle_load_local_image_meta(int r) {
dout(15) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to load local image-meta: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
*m_resync_requested = m_state_builder->local_image_meta->resync_requested;
finish(0);
}
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::snapshot::PrepareReplayRequest<librbd::ImageCtx>;
| 2,039 | 27.732394 | 93 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/PrepareReplayRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
#define RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
#include "include/int_types.h"
#include "librbd/mirror/Types.h"
#include "tools/rbd_mirror/BaseRequest.h"
#include <list>
#include <string>
struct Context;
namespace librbd { struct ImageCtx; }
namespace rbd {
namespace mirror {
class ProgressContext;
namespace image_replayer {
namespace snapshot {
template <typename> class StateBuilder;
template <typename ImageCtxT>
class PrepareReplayRequest : public BaseRequest {
public:
static PrepareReplayRequest* create(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
bool* resync_requested,
bool* syncing,
Context* on_finish) {
return new PrepareReplayRequest(
local_mirror_uuid, progress_ctx, state_builder, resync_requested,
syncing, on_finish);
}
PrepareReplayRequest(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
StateBuilder<ImageCtxT>* state_builder,
bool* resync_requested,
bool* syncing,
Context* on_finish)
: BaseRequest(on_finish),
m_local_mirror_uuid(local_mirror_uuid),
m_progress_ctx(progress_ctx),
m_state_builder(state_builder),
m_resync_requested(resync_requested),
m_syncing(syncing) {
}
void send() override;
private:
// TODO
/**
* @verbatim
*
* <start>
* |
* v
* LOAD_LOCAL_IMAGE_META
* |
* v
* <finish>
*
* @endverbatim
*/
std::string m_local_mirror_uuid;
ProgressContext* m_progress_ctx;
StateBuilder<ImageCtxT>* m_state_builder;
bool* m_resync_requested;
bool* m_syncing;
void load_local_image_meta();
void handle_load_local_image_meta(int r);
};
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::snapshot::PrepareReplayRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_JOURNAL_PREPARE_REPLAY_REQUEST_H
| 2,212 | 22.795699 | 100 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Replayer.h"
#include "common/debug.h"
#include "common/errno.h"
#include "common/perf_counters.h"
#include "common/perf_counters_key.h"
#include "include/stringify.h"
#include "common/Timer.h"
#include "cls/rbd/cls_rbd_client.h"
#include "json_spirit/json_spirit.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#include "librbd/asio/ContextWQ.h"
#include "librbd/deep_copy/Handler.h"
#include "librbd/deep_copy/ImageCopyRequest.h"
#include "librbd/deep_copy/SnapshotCopyRequest.h"
#include "librbd/mirror/ImageStateUpdateRequest.h"
#include "librbd/mirror/snapshot/CreateNonPrimaryRequest.h"
#include "librbd/mirror/snapshot/GetImageStateRequest.h"
#include "librbd/mirror/snapshot/ImageMeta.h"
#include "librbd/mirror/snapshot/UnlinkPeerRequest.h"
#include "tools/rbd_mirror/InstanceWatcher.h"
#include "tools/rbd_mirror/PoolMetaCache.h"
#include "tools/rbd_mirror/Threads.h"
#include "tools/rbd_mirror/Types.h"
#include "tools/rbd_mirror/image_replayer/CloseImageRequest.h"
#include "tools/rbd_mirror/image_replayer/ReplayerListener.h"
#include "tools/rbd_mirror/image_replayer/Utils.h"
#include "tools/rbd_mirror/image_replayer/snapshot/ApplyImageStateRequest.h"
#include "tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h"
#include "tools/rbd_mirror/image_replayer/snapshot/Utils.h"
#include <set>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::" \
<< "Replayer: " << this << " " << __func__ << ": "
extern PerfCounters *g_snapshot_perf_counters;
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
namespace {
double round_to_two_places(double value) {
return abs(round(value * 100) / 100);
}
template<typename I>
std::pair<uint64_t, librbd::SnapInfo*> get_newest_mirror_snapshot(
I* image_ctx) {
for (auto snap_info_it = image_ctx->snap_info.rbegin();
snap_info_it != image_ctx->snap_info.rend(); ++snap_info_it) {
const auto& snap_ns = snap_info_it->second.snap_namespace;
auto mirror_ns = std::get_if<
cls::rbd::MirrorSnapshotNamespace>(&snap_ns);
if (mirror_ns == nullptr || !mirror_ns->complete) {
continue;
}
return {snap_info_it->first, &snap_info_it->second};
}
return {CEPH_NOSNAP, nullptr};
}
} // anonymous namespace
using librbd::util::create_async_context_callback;
using librbd::util::create_context_callback;
using librbd::util::create_rados_callback;
template <typename I>
struct Replayer<I>::C_UpdateWatchCtx : public librbd::UpdateWatchCtx {
Replayer<I>* replayer;
C_UpdateWatchCtx(Replayer<I>* replayer) : replayer(replayer) {
}
void handle_notify() override {
replayer->handle_image_update_notify();
}
};
template <typename I>
struct Replayer<I>::DeepCopyHandler : public librbd::deep_copy::Handler {
Replayer *replayer;
DeepCopyHandler(Replayer* replayer) : replayer(replayer) {
}
void handle_read(uint64_t bytes_read) override {
replayer->handle_copy_image_read(bytes_read);
}
int update_progress(uint64_t object_number, uint64_t object_count) override {
replayer->handle_copy_image_progress(object_number, object_count);
return 0;
}
};
template <typename I>
Replayer<I>::Replayer(
Threads<I>* threads,
InstanceWatcher<I>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
StateBuilder<I>* state_builder,
ReplayerListener* replayer_listener)
: m_threads(threads),
m_instance_watcher(instance_watcher),
m_local_mirror_uuid(local_mirror_uuid),
m_pool_meta_cache(pool_meta_cache),
m_state_builder(state_builder),
m_replayer_listener(replayer_listener),
m_lock(ceph::make_mutex(librbd::util::unique_lock_name(
"rbd::mirror::image_replayer::snapshot::Replayer", this))) {
dout(10) << dendl;
}
template <typename I>
Replayer<I>::~Replayer() {
dout(10) << dendl;
{
std::unique_lock locker{m_lock};
unregister_perf_counters();
}
ceph_assert(m_state == STATE_COMPLETE);
ceph_assert(m_update_watch_ctx == nullptr);
ceph_assert(m_deep_copy_handler == nullptr);
}
template <typename I>
void Replayer<I>::init(Context* on_finish) {
dout(10) << dendl;
ceph_assert(m_state == STATE_INIT);
RemotePoolMeta remote_pool_meta;
int r = m_pool_meta_cache->get_remote_pool_meta(
m_state_builder->remote_image_ctx->md_ctx.get_id(), &remote_pool_meta);
if (r < 0 || remote_pool_meta.mirror_peer_uuid.empty()) {
derr << "failed to retrieve mirror peer uuid from remote pool" << dendl;
m_state = STATE_COMPLETE;
m_threads->work_queue->queue(on_finish, r);
return;
}
m_remote_mirror_peer_uuid = remote_pool_meta.mirror_peer_uuid;
dout(10) << "remote_mirror_peer_uuid=" << m_remote_mirror_peer_uuid << dendl;
{
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock image_locker{local_image_ctx->image_lock};
m_image_spec = image_replayer::util::compute_image_spec(
local_image_ctx->md_ctx, local_image_ctx->name);
}
{
std::unique_lock locker{m_lock};
register_perf_counters();
}
ceph_assert(m_on_init_shutdown == nullptr);
m_on_init_shutdown = on_finish;
register_local_update_watcher();
}
template <typename I>
void Replayer<I>::shut_down(Context* on_finish) {
dout(10) << dendl;
std::unique_lock locker{m_lock};
ceph_assert(m_on_init_shutdown == nullptr);
m_on_init_shutdown = on_finish;
m_error_code = 0;
m_error_description = "";
ceph_assert(m_state != STATE_INIT);
auto state = STATE_COMPLETE;
std::swap(m_state, state);
if (state == STATE_REPLAYING) {
// if a sync request was pending, request a cancelation
m_instance_watcher->cancel_sync_request(
m_state_builder->local_image_ctx->id);
// TODO interrupt snapshot copy and image copy state machines even if remote
// cluster is unreachable
dout(10) << "shut down pending on completion of snapshot replay" << dendl;
return;
}
locker.unlock();
unregister_remote_update_watcher();
}
template <typename I>
void Replayer<I>::flush(Context* on_finish) {
dout(10) << dendl;
// TODO
m_threads->work_queue->queue(on_finish, 0);
}
template <typename I>
bool Replayer<I>::get_replay_status(std::string* description,
Context* on_finish) {
dout(10) << dendl;
std::unique_lock locker{m_lock};
if (m_state != STATE_REPLAYING && m_state != STATE_IDLE) {
locker.unlock();
derr << "replay not running" << dendl;
on_finish->complete(-EAGAIN);
return false;
}
std::shared_lock local_image_locker{
m_state_builder->local_image_ctx->image_lock};
auto [local_snap_id, local_snap_info] = get_newest_mirror_snapshot(
m_state_builder->local_image_ctx);
std::shared_lock remote_image_locker{
m_state_builder->remote_image_ctx->image_lock};
auto [remote_snap_id, remote_snap_info] = get_newest_mirror_snapshot(
m_state_builder->remote_image_ctx);
if (remote_snap_info == nullptr) {
remote_image_locker.unlock();
local_image_locker.unlock();
locker.unlock();
derr << "remote image does not contain mirror snapshots" << dendl;
on_finish->complete(-EAGAIN);
return false;
}
std::string replay_state = "idle";
if (m_remote_snap_id_end != CEPH_NOSNAP) {
replay_state = "syncing";
}
json_spirit::mObject root_obj;
root_obj["replay_state"] = replay_state;
root_obj["remote_snapshot_timestamp"] = remote_snap_info->timestamp.sec();
if (m_perf_counters) {
m_perf_counters->tset(l_rbd_mirror_snapshot_remote_timestamp,
remote_snap_info->timestamp);
}
auto matching_remote_snap_id = util::compute_remote_snap_id(
m_state_builder->local_image_ctx->image_lock,
m_state_builder->local_image_ctx->snap_info,
local_snap_id, m_state_builder->remote_mirror_uuid);
auto matching_remote_snap_it =
m_state_builder->remote_image_ctx->snap_info.find(matching_remote_snap_id);
if (matching_remote_snap_id != CEPH_NOSNAP &&
matching_remote_snap_it !=
m_state_builder->remote_image_ctx->snap_info.end()) {
// use the timestamp from the matching remote image since
// the local snapshot would just be the time the snapshot was
// synced and not the consistency point in time.
root_obj["local_snapshot_timestamp"] =
matching_remote_snap_it->second.timestamp.sec();
if (m_perf_counters) {
m_perf_counters->tset(l_rbd_mirror_snapshot_local_timestamp,
matching_remote_snap_it->second.timestamp);
}
}
matching_remote_snap_it = m_state_builder->remote_image_ctx->snap_info.find(
m_remote_snap_id_end);
if (m_remote_snap_id_end != CEPH_NOSNAP &&
matching_remote_snap_it !=
m_state_builder->remote_image_ctx->snap_info.end()) {
root_obj["syncing_snapshot_timestamp"] = remote_snap_info->timestamp.sec();
if (m_local_object_count > 0) {
root_obj["syncing_percent"] =
100 * m_local_mirror_snap_ns.last_copied_object_number /
m_local_object_count;
} else {
// Set syncing_percent to 0 if m_local_object_count has
// not yet been set (last_copied_object_number may be > 0
// if the sync is being resumed).
root_obj["syncing_percent"] = 0;
}
}
m_bytes_per_second(0);
auto bytes_per_second = m_bytes_per_second.get_average();
root_obj["bytes_per_second"] = round_to_two_places(bytes_per_second);
auto bytes_per_snapshot = boost::accumulators::rolling_mean(
m_bytes_per_snapshot);
root_obj["bytes_per_snapshot"] = round_to_two_places(bytes_per_snapshot);
root_obj["last_snapshot_sync_seconds"] = m_last_snapshot_sync_seconds;
root_obj["last_snapshot_bytes"] = m_last_snapshot_bytes;
auto pending_bytes = bytes_per_snapshot * m_pending_snapshots;
if (bytes_per_second > 0 && m_pending_snapshots > 0) {
std::uint64_t seconds_until_synced = round_to_two_places(
pending_bytes / bytes_per_second);
if (seconds_until_synced >= std::numeric_limits<uint64_t>::max()) {
seconds_until_synced = std::numeric_limits<uint64_t>::max();
}
root_obj["seconds_until_synced"] = seconds_until_synced;
}
*description = json_spirit::write(
root_obj, json_spirit::remove_trailing_zeros);
local_image_locker.unlock();
remote_image_locker.unlock();
locker.unlock();
on_finish->complete(-EEXIST);
return true;
}
template <typename I>
void Replayer<I>::load_local_image_meta() {
dout(10) << dendl;
{
// reset state in case new snapshot is added while we are scanning
std::unique_lock locker{m_lock};
m_image_updated = false;
}
bool update_status = false;
{
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock image_locker{local_image_ctx->image_lock};
auto image_spec = image_replayer::util::compute_image_spec(
local_image_ctx->md_ctx, local_image_ctx->name);
if (m_image_spec != image_spec) {
m_image_spec = image_spec;
update_status = true;
}
}
if (update_status) {
std::unique_lock locker{m_lock};
unregister_perf_counters();
register_perf_counters();
notify_status_updated();
}
ceph_assert(m_state_builder->local_image_meta != nullptr);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_load_local_image_meta>(this);
m_state_builder->local_image_meta->load(ctx);
}
template <typename I>
void Replayer<I>::handle_load_local_image_meta(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to load local image-meta: " << cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to load local image-meta");
return;
}
if (r >= 0 && m_state_builder->local_image_meta->resync_requested) {
m_resync_requested = true;
dout(10) << "local image resync requested" << dendl;
handle_replay_complete(0, "resync requested");
return;
}
refresh_local_image();
}
template <typename I>
void Replayer<I>::refresh_local_image() {
if (!m_state_builder->local_image_ctx->state->is_refresh_required()) {
refresh_remote_image();
return;
}
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_refresh_local_image>(this);
m_state_builder->local_image_ctx->state->refresh(ctx);
}
template <typename I>
void Replayer<I>::handle_refresh_local_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to refresh local image: " << cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to refresh local image");
return;
}
refresh_remote_image();
}
template <typename I>
void Replayer<I>::refresh_remote_image() {
if (!m_state_builder->remote_image_ctx->state->is_refresh_required()) {
std::unique_lock locker{m_lock};
scan_local_mirror_snapshots(&locker);
return;
}
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_refresh_remote_image>(this);
m_state_builder->remote_image_ctx->state->refresh(ctx);
}
template <typename I>
void Replayer<I>::handle_refresh_remote_image(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to refresh remote image: " << cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to refresh remote image");
return;
}
std::unique_lock locker{m_lock};
scan_local_mirror_snapshots(&locker);
}
template <typename I>
void Replayer<I>::scan_local_mirror_snapshots(
std::unique_lock<ceph::mutex>* locker) {
if (is_replay_interrupted(locker)) {
return;
}
dout(10) << dendl;
m_local_snap_id_start = 0;
m_local_snap_id_end = CEPH_NOSNAP;
m_local_mirror_snap_ns = {};
m_local_object_count = 0;
m_remote_snap_id_start = 0;
m_remote_snap_id_end = CEPH_NOSNAP;
m_remote_mirror_snap_ns = {};
std::set<uint64_t> prune_snap_ids;
auto local_image_ctx = m_state_builder->local_image_ctx;
std::shared_lock image_locker{local_image_ctx->image_lock};
for (auto snap_info_it = local_image_ctx->snap_info.begin();
snap_info_it != local_image_ctx->snap_info.end(); ++snap_info_it) {
const auto& snap_ns = snap_info_it->second.snap_namespace;
auto mirror_ns = std::get_if<
cls::rbd::MirrorSnapshotNamespace>(&snap_ns);
if (mirror_ns == nullptr) {
continue;
}
dout(15) << "local mirror snapshot: id=" << snap_info_it->first << ", "
<< "mirror_ns=" << *mirror_ns << dendl;
m_local_mirror_snap_ns = *mirror_ns;
auto local_snap_id = snap_info_it->first;
if (mirror_ns->is_non_primary()) {
if (mirror_ns->complete) {
// if remote has new snapshots, we would sync from here
m_local_snap_id_start = local_snap_id;
ceph_assert(m_local_snap_id_end == CEPH_NOSNAP);
if (mirror_ns->mirror_peer_uuids.empty()) {
// no other peer will attempt to sync to this snapshot so store as
// a candidate for removal
prune_snap_ids.insert(local_snap_id);
}
} else if (mirror_ns->last_copied_object_number == 0 &&
m_local_snap_id_start > 0) {
// snapshot might be missing image state, object-map, etc, so just
// delete and re-create it if we haven't started copying data
// objects. Also only prune this snapshot since we will need the
// previous mirror snapshot for syncing. Special case exception for
// the first non-primary snapshot since we know its snapshot is
// well-formed because otherwise the mirror-image-state would have
// forced an image deletion.
prune_snap_ids.clear();
prune_snap_ids.insert(local_snap_id);
break;
} else {
// start snap will be last complete mirror snapshot or initial
// image revision
m_local_snap_id_end = local_snap_id;
break;
}
} else if (mirror_ns->is_primary()) {
if (mirror_ns->complete) {
m_local_snap_id_start = local_snap_id;
ceph_assert(m_local_snap_id_end == CEPH_NOSNAP);
} else {
derr << "incomplete local primary snapshot" << dendl;
handle_replay_complete(locker, -EINVAL,
"incomplete local primary snapshot");
return;
}
} else {
derr << "unknown local mirror snapshot state" << dendl;
handle_replay_complete(locker, -EINVAL,
"invalid local mirror snapshot state");
return;
}
}
image_locker.unlock();
if (m_local_snap_id_start > 0) {
// remove candidate that is required for delta snapshot sync
prune_snap_ids.erase(m_local_snap_id_start);
}
if (!prune_snap_ids.empty()) {
locker->unlock();
auto prune_snap_id = *prune_snap_ids.begin();
dout(5) << "pruning unused non-primary snapshot " << prune_snap_id << dendl;
prune_non_primary_snapshot(prune_snap_id);
return;
}
if (m_local_snap_id_start > 0 || m_local_snap_id_end != CEPH_NOSNAP) {
if (m_local_mirror_snap_ns.is_non_primary() &&
m_local_mirror_snap_ns.primary_mirror_uuid !=
m_state_builder->remote_mirror_uuid) {
if (m_local_mirror_snap_ns.is_orphan()) {
dout(5) << "local image being force promoted" << dendl;
handle_replay_complete(locker, 0, "orphan (force promoting)");
return;
}
// TODO support multiple peers
derr << "local image linked to unknown peer: "
<< m_local_mirror_snap_ns.primary_mirror_uuid << dendl;
handle_replay_complete(locker, -EEXIST,
"local image linked to unknown peer");
return;
} else if (m_local_mirror_snap_ns.state ==
cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY) {
dout(5) << "local image promoted" << dendl;
handle_replay_complete(locker, 0, "force promoted");
return;
}
dout(10) << "found local mirror snapshot: "
<< "local_snap_id_start=" << m_local_snap_id_start << ", "
<< "local_snap_id_end=" << m_local_snap_id_end << ", "
<< "local_snap_ns=" << m_local_mirror_snap_ns << dendl;
if (!m_local_mirror_snap_ns.is_primary() &&
m_local_mirror_snap_ns.complete) {
// our remote sync should start after this completed snapshot
m_remote_snap_id_start = m_local_mirror_snap_ns.primary_snap_id;
}
}
// we don't have any mirror snapshots or only completed non-primary
// mirror snapshots
scan_remote_mirror_snapshots(locker);
}
template <typename I>
void Replayer<I>::scan_remote_mirror_snapshots(
std::unique_lock<ceph::mutex>* locker) {
dout(10) << dendl;
m_pending_snapshots = 0;
std::set<uint64_t> unlink_snap_ids;
bool split_brain = false;
bool remote_demoted = false;
auto remote_image_ctx = m_state_builder->remote_image_ctx;
std::shared_lock image_locker{remote_image_ctx->image_lock};
for (auto snap_info_it = remote_image_ctx->snap_info.begin();
snap_info_it != remote_image_ctx->snap_info.end(); ++snap_info_it) {
const auto& snap_ns = snap_info_it->second.snap_namespace;
auto mirror_ns = std::get_if<
cls::rbd::MirrorSnapshotNamespace>(&snap_ns);
if (mirror_ns == nullptr) {
continue;
}
dout(15) << "remote mirror snapshot: id=" << snap_info_it->first << ", "
<< "mirror_ns=" << *mirror_ns << dendl;
remote_demoted = mirror_ns->is_demoted();
if (!mirror_ns->is_primary() && !mirror_ns->is_non_primary()) {
derr << "unknown remote mirror snapshot state" << dendl;
handle_replay_complete(locker, -EINVAL,
"invalid remote mirror snapshot state");
return;
} else if (mirror_ns->mirror_peer_uuids.count(m_remote_mirror_peer_uuid) ==
0) {
dout(15) << "skipping remote snapshot due to missing mirror peer"
<< dendl;
continue;
}
auto remote_snap_id = snap_info_it->first;
if (m_local_snap_id_start > 0 || m_local_snap_id_end != CEPH_NOSNAP) {
// we have a local mirror snapshot
if (m_local_mirror_snap_ns.is_non_primary()) {
// previously validated that it was linked to remote
ceph_assert(m_local_mirror_snap_ns.primary_mirror_uuid ==
m_state_builder->remote_mirror_uuid);
if (m_remote_snap_id_end == CEPH_NOSNAP) {
// haven't found the end snap so treat this as a candidate for unlink
unlink_snap_ids.insert(remote_snap_id);
}
if (m_local_mirror_snap_ns.complete &&
m_local_mirror_snap_ns.primary_snap_id >= remote_snap_id) {
// skip past completed remote snapshot
m_remote_snap_id_start = remote_snap_id;
m_remote_mirror_snap_ns = *mirror_ns;
dout(15) << "skipping synced remote snapshot " << remote_snap_id
<< dendl;
continue;
} else if (!m_local_mirror_snap_ns.complete &&
m_local_mirror_snap_ns.primary_snap_id > remote_snap_id) {
// skip until we get to the in-progress remote snapshot
dout(15) << "skipping synced remote snapshot " << remote_snap_id
<< " while search for in-progress sync" << dendl;
m_remote_snap_id_start = remote_snap_id;
m_remote_mirror_snap_ns = *mirror_ns;
continue;
}
} else if (m_local_mirror_snap_ns.state ==
cls::rbd::MIRROR_SNAPSHOT_STATE_PRIMARY_DEMOTED) {
// find the matching demotion snapshot in remote image
ceph_assert(m_local_snap_id_start > 0);
if (mirror_ns->state ==
cls::rbd::MIRROR_SNAPSHOT_STATE_NON_PRIMARY_DEMOTED &&
mirror_ns->primary_mirror_uuid == m_local_mirror_uuid &&
mirror_ns->primary_snap_id == m_local_snap_id_start) {
dout(10) << "located matching demotion snapshot: "
<< "remote_snap_id=" << remote_snap_id << ", "
<< "local_snap_id=" << m_local_snap_id_start << dendl;
m_remote_snap_id_start = remote_snap_id;
split_brain = false;
continue;
} else if (m_remote_snap_id_start == 0) {
// still looking for our matching demotion snapshot
dout(15) << "skipping remote snapshot " << remote_snap_id << " "
<< "while searching for demotion" << dendl;
split_brain = true;
continue;
}
} else {
// should not have been able to reach this
ceph_assert(false);
}
} else if (!mirror_ns->is_primary()) {
dout(15) << "skipping non-primary remote snapshot" << dendl;
continue;
}
// found candidate snapshot to sync
++m_pending_snapshots;
if (m_remote_snap_id_end != CEPH_NOSNAP) {
continue;
}
// first primary snapshot where were are listed as a peer
m_remote_snap_id_end = remote_snap_id;
m_remote_mirror_snap_ns = *mirror_ns;
}
if (m_remote_snap_id_start != 0 &&
remote_image_ctx->snap_info.count(m_remote_snap_id_start) == 0) {
// the remote start snapshot was deleted out from under us
derr << "failed to locate remote start snapshot: "
<< "snap_id=" << m_remote_snap_id_start << dendl;
split_brain = true;
}
image_locker.unlock();
if (!split_brain) {
unlink_snap_ids.erase(m_remote_snap_id_start);
unlink_snap_ids.erase(m_remote_snap_id_end);
if (!unlink_snap_ids.empty()) {
locker->unlock();
// retry the unlinking process for a remote snapshot that we do not
// need anymore
auto remote_snap_id = *unlink_snap_ids.begin();
dout(10) << "unlinking from remote snapshot " << remote_snap_id << dendl;
unlink_peer(remote_snap_id);
return;
}
if (m_remote_snap_id_end != CEPH_NOSNAP) {
dout(10) << "found remote mirror snapshot: "
<< "remote_snap_id_start=" << m_remote_snap_id_start << ", "
<< "remote_snap_id_end=" << m_remote_snap_id_end << ", "
<< "remote_snap_ns=" << m_remote_mirror_snap_ns << dendl;
if (m_remote_mirror_snap_ns.complete) {
locker->unlock();
if (m_local_snap_id_end != CEPH_NOSNAP &&
!m_local_mirror_snap_ns.complete) {
// attempt to resume image-sync
dout(10) << "local image contains in-progress mirror snapshot"
<< dendl;
get_local_image_state();
} else {
copy_snapshots();
}
return;
} else {
// might have raced with the creation of a remote mirror snapshot
// so we will need to refresh and rescan once it completes
dout(15) << "remote mirror snapshot not complete" << dendl;
}
}
}
if (m_image_updated) {
// received update notification while scanning image, restart ...
m_image_updated = false;
locker->unlock();
dout(10) << "restarting snapshot scan due to remote update notification"
<< dendl;
load_local_image_meta();
return;
}
if (is_replay_interrupted(locker)) {
return;
} else if (split_brain) {
derr << "split-brain detected: failed to find matching non-primary "
<< "snapshot in remote image: "
<< "local_snap_id_start=" << m_local_snap_id_start << ", "
<< "local_snap_ns=" << m_local_mirror_snap_ns << dendl;
handle_replay_complete(locker, -EEXIST, "split-brain");
return;
} else if (remote_demoted) {
dout(10) << "remote image demoted" << dendl;
handle_replay_complete(locker, -EREMOTEIO, "remote image demoted");
return;
}
dout(10) << "all remote snapshots synced: idling waiting for new snapshot"
<< dendl;
ceph_assert(m_state == STATE_REPLAYING);
m_state = STATE_IDLE;
notify_status_updated();
}
template <typename I>
void Replayer<I>::prune_non_primary_snapshot(uint64_t snap_id) {
dout(10) << "snap_id=" << snap_id << dendl;
auto local_image_ctx = m_state_builder->local_image_ctx;
bool snap_valid = false;
cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
{
std::shared_lock image_locker{local_image_ctx->image_lock};
auto snap_info = local_image_ctx->get_snap_info(snap_id);
if (snap_info != nullptr) {
snap_valid = true;
snap_namespace = snap_info->snap_namespace;
snap_name = snap_info->name;
ceph_assert(std::holds_alternative<cls::rbd::MirrorSnapshotNamespace>(
snap_namespace));
}
}
if (!snap_valid) {
load_local_image_meta();
return;
}
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_prune_non_primary_snapshot>(this);
local_image_ctx->operations->snap_remove(snap_namespace, snap_name, ctx);
}
template <typename I>
void Replayer<I>::handle_prune_non_primary_snapshot(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to prune non-primary snapshot: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to prune non-primary snapshot");
return;
}
if (is_replay_interrupted()) {
return;
}
load_local_image_meta();
}
template <typename I>
void Replayer<I>::copy_snapshots() {
dout(10) << "remote_snap_id_start=" << m_remote_snap_id_start << ", "
<< "remote_snap_id_end=" << m_remote_snap_id_end << ", "
<< "local_snap_id_start=" << m_local_snap_id_start << dendl;
ceph_assert(m_remote_snap_id_start != CEPH_NOSNAP);
ceph_assert(m_remote_snap_id_end > 0 &&
m_remote_snap_id_end != CEPH_NOSNAP);
ceph_assert(m_local_snap_id_start != CEPH_NOSNAP);
m_local_mirror_snap_ns = {};
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_copy_snapshots>(this);
auto req = librbd::deep_copy::SnapshotCopyRequest<I>::create(
m_state_builder->remote_image_ctx, m_state_builder->local_image_ctx,
m_remote_snap_id_start, m_remote_snap_id_end, m_local_snap_id_start,
false, m_threads->work_queue, &m_local_mirror_snap_ns.snap_seqs,
ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_copy_snapshots(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to copy snapshots from remote to local image: "
<< cpp_strerror(r) << dendl;
handle_replay_complete(
r, "failed to copy snapshots from remote to local image");
return;
}
dout(10) << "remote_snap_id_start=" << m_remote_snap_id_start << ", "
<< "remote_snap_id_end=" << m_remote_snap_id_end << ", "
<< "local_snap_id_start=" << m_local_snap_id_start << ", "
<< "snap_seqs=" << m_local_mirror_snap_ns.snap_seqs << dendl;
get_remote_image_state();
}
template <typename I>
void Replayer<I>::get_remote_image_state() {
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_get_remote_image_state>(this);
auto req = librbd::mirror::snapshot::GetImageStateRequest<I>::create(
m_state_builder->remote_image_ctx, m_remote_snap_id_end,
&m_image_state, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_get_remote_image_state(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to retrieve remote snapshot image state: "
<< cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to retrieve remote snapshot image state");
return;
}
create_non_primary_snapshot();
}
template <typename I>
void Replayer<I>::get_local_image_state() {
dout(10) << dendl;
ceph_assert(m_local_snap_id_end != CEPH_NOSNAP);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_get_local_image_state>(this);
auto req = librbd::mirror::snapshot::GetImageStateRequest<I>::create(
m_state_builder->local_image_ctx, m_local_snap_id_end,
&m_image_state, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_get_local_image_state(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to retrieve local snapshot image state: "
<< cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to retrieve local snapshot image state");
return;
}
request_sync();
}
template <typename I>
void Replayer<I>::create_non_primary_snapshot() {
auto local_image_ctx = m_state_builder->local_image_ctx;
if (m_local_snap_id_start > 0) {
std::shared_lock local_image_locker{local_image_ctx->image_lock};
auto local_snap_info_it = local_image_ctx->snap_info.find(
m_local_snap_id_start);
if (local_snap_info_it == local_image_ctx->snap_info.end()) {
local_image_locker.unlock();
derr << "failed to locate local snapshot " << m_local_snap_id_start
<< dendl;
handle_replay_complete(-ENOENT, "failed to locate local start snapshot");
return;
}
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&local_snap_info_it->second.snap_namespace);
ceph_assert(mirror_ns != nullptr);
auto remote_image_ctx = m_state_builder->remote_image_ctx;
std::shared_lock remote_image_locker{remote_image_ctx->image_lock};
// (re)build a full mapping from remote to local snap ids for all user
// snapshots to support applying image state in the future
for (auto& [remote_snap_id, remote_snap_info] :
remote_image_ctx->snap_info) {
if (remote_snap_id >= m_remote_snap_id_end) {
break;
}
// we can ignore all non-user snapshots since image state only includes
// user snapshots
if (!std::holds_alternative<cls::rbd::UserSnapshotNamespace>(
remote_snap_info.snap_namespace)) {
continue;
}
uint64_t local_snap_id = CEPH_NOSNAP;
if (mirror_ns->is_demoted() && !m_remote_mirror_snap_ns.is_demoted()) {
// if we are creating a non-primary snapshot following a demotion,
// re-build the full snapshot sequence since we don't have a valid
// snapshot mapping
auto local_snap_id_it = local_image_ctx->snap_ids.find(
{remote_snap_info.snap_namespace, remote_snap_info.name});
if (local_snap_id_it != local_image_ctx->snap_ids.end()) {
local_snap_id = local_snap_id_it->second;
}
} else {
auto snap_seq_it = mirror_ns->snap_seqs.find(remote_snap_id);
if (snap_seq_it != mirror_ns->snap_seqs.end()) {
local_snap_id = snap_seq_it->second;
}
}
if (m_local_mirror_snap_ns.snap_seqs.count(remote_snap_id) == 0 &&
local_snap_id != CEPH_NOSNAP) {
dout(15) << "mapping remote snapshot " << remote_snap_id << " to "
<< "local snapshot " << local_snap_id << dendl;
m_local_mirror_snap_ns.snap_seqs[remote_snap_id] = local_snap_id;
}
}
}
dout(10) << "demoted=" << m_remote_mirror_snap_ns.is_demoted() << ", "
<< "primary_mirror_uuid="
<< m_state_builder->remote_mirror_uuid << ", "
<< "primary_snap_id=" << m_remote_snap_id_end << ", "
<< "snap_seqs=" << m_local_mirror_snap_ns.snap_seqs << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_create_non_primary_snapshot>(this);
auto req = librbd::mirror::snapshot::CreateNonPrimaryRequest<I>::create(
local_image_ctx, m_remote_mirror_snap_ns.is_demoted(),
m_state_builder->remote_mirror_uuid, m_remote_snap_id_end,
m_local_mirror_snap_ns.snap_seqs, m_image_state, &m_local_snap_id_end, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_create_non_primary_snapshot(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to create local mirror snapshot: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to create local mirror snapshot");
return;
}
dout(15) << "local_snap_id_end=" << m_local_snap_id_end << dendl;
update_mirror_image_state();
}
template <typename I>
void Replayer<I>::update_mirror_image_state() {
if (m_local_snap_id_start > 0) {
request_sync();
return;
}
// a newly created non-primary image has a local mirror state of CREATING
// until this point so that we could avoid preserving the image until
// the first non-primary snapshot linked the two images together.
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_update_mirror_image_state>(this);
auto req = librbd::mirror::ImageStateUpdateRequest<I>::create(
m_state_builder->local_image_ctx->md_ctx,
m_state_builder->local_image_ctx->id,
cls::rbd::MIRROR_IMAGE_STATE_ENABLED, {}, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_update_mirror_image_state(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update local mirror image state: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to update local mirror image state");
return;
}
request_sync();
}
template <typename I>
void Replayer<I>::request_sync() {
if (m_remote_mirror_snap_ns.clean_since_snap_id == m_remote_snap_id_start) {
dout(10) << "skipping unnecessary image copy: "
<< "remote_snap_id_start=" << m_remote_snap_id_start << ", "
<< "remote_mirror_snap_ns=" << m_remote_mirror_snap_ns << dendl;
apply_image_state();
return;
}
dout(10) << dendl;
std::unique_lock locker{m_lock};
if (is_replay_interrupted(&locker)) {
return;
}
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_request_sync>(this));
m_instance_watcher->notify_sync_request(m_state_builder->local_image_ctx->id,
ctx);
}
template <typename I>
void Replayer<I>::handle_request_sync(int r) {
dout(10) << "r=" << r << dendl;
std::unique_lock locker{m_lock};
if (is_replay_interrupted(&locker)) {
return;
} else if (r == -ECANCELED) {
dout(5) << "image-sync canceled" << dendl;
handle_replay_complete(&locker, r, "image-sync canceled");
return;
} else if (r < 0) {
derr << "failed to request image-sync: " << cpp_strerror(r) << dendl;
handle_replay_complete(&locker, r, "failed to request image-sync");
return;
}
m_sync_in_progress = true;
locker.unlock();
copy_image();
}
template <typename I>
void Replayer<I>::copy_image() {
dout(10) << "remote_snap_id_start=" << m_remote_snap_id_start << ", "
<< "remote_snap_id_end=" << m_remote_snap_id_end << ", "
<< "local_snap_id_start=" << m_local_snap_id_start << ", "
<< "last_copied_object_number="
<< m_local_mirror_snap_ns.last_copied_object_number << ", "
<< "snap_seqs=" << m_local_mirror_snap_ns.snap_seqs << dendl;
m_snapshot_bytes = 0;
m_snapshot_replay_start = ceph_clock_now();
m_deep_copy_handler = new DeepCopyHandler(this);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_copy_image>(this);
auto req = librbd::deep_copy::ImageCopyRequest<I>::create(
m_state_builder->remote_image_ctx, m_state_builder->local_image_ctx,
m_remote_snap_id_start, m_remote_snap_id_end, m_local_snap_id_start, false,
(m_local_mirror_snap_ns.last_copied_object_number > 0 ?
librbd::deep_copy::ObjectNumber{
m_local_mirror_snap_ns.last_copied_object_number} :
librbd::deep_copy::ObjectNumber{}),
m_local_mirror_snap_ns.snap_seqs, m_deep_copy_handler, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_copy_image(int r) {
dout(10) << "r=" << r << dendl;
delete m_deep_copy_handler;
m_deep_copy_handler = nullptr;
if (r < 0) {
derr << "failed to copy remote image to local image: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to copy remote image");
return;
}
{
std::unique_lock locker{m_lock};
m_last_snapshot_bytes = m_snapshot_bytes;
m_bytes_per_snapshot(m_snapshot_bytes);
utime_t duration = ceph_clock_now() - m_snapshot_replay_start;
m_last_snapshot_sync_seconds = duration.sec();
if (g_snapshot_perf_counters) {
g_snapshot_perf_counters->inc(l_rbd_mirror_snapshot_sync_bytes,
m_snapshot_bytes);
g_snapshot_perf_counters->inc(l_rbd_mirror_snapshot_snapshots);
g_snapshot_perf_counters->tinc(l_rbd_mirror_snapshot_sync_time,
duration);
}
if (m_perf_counters) {
m_perf_counters->inc(l_rbd_mirror_snapshot_sync_bytes, m_snapshot_bytes);
m_perf_counters->inc(l_rbd_mirror_snapshot_snapshots);
m_perf_counters->tinc(l_rbd_mirror_snapshot_sync_time, duration);
m_perf_counters->tset(l_rbd_mirror_snapshot_last_sync_time, duration);
m_perf_counters->set(l_rbd_mirror_snapshot_last_sync_bytes,
m_snapshot_bytes);
}
}
apply_image_state();
}
template <typename I>
void Replayer<I>::handle_copy_image_progress(uint64_t object_number,
uint64_t object_count) {
dout(10) << "object_number=" << object_number << ", "
<< "object_count=" << object_count << dendl;
std::unique_lock locker{m_lock};
m_local_mirror_snap_ns.last_copied_object_number = std::min(
object_number, object_count);
m_local_object_count = object_count;
update_non_primary_snapshot(false);
}
template <typename I>
void Replayer<I>::handle_copy_image_read(uint64_t bytes_read) {
dout(20) << "bytes_read=" << bytes_read << dendl;
std::unique_lock locker{m_lock};
m_bytes_per_second(bytes_read);
m_snapshot_bytes += bytes_read;
}
template <typename I>
void Replayer<I>::apply_image_state() {
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_apply_image_state>(this);
auto req = ApplyImageStateRequest<I>::create(
m_local_mirror_uuid,
m_state_builder->remote_mirror_uuid,
m_state_builder->local_image_ctx,
m_state_builder->remote_image_ctx,
m_image_state, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_apply_image_state(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to apply remote image state to local image: "
<< cpp_strerror(r) << dendl;
handle_replay_complete(r, "failed to apply remote image state");
return;
}
std::unique_lock locker{m_lock};
update_non_primary_snapshot(true);
}
template <typename I>
void Replayer<I>::update_non_primary_snapshot(bool complete) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (!complete) {
// disallow two in-flight updates if this isn't the completion of the sync
if (m_updating_sync_point) {
return;
}
m_updating_sync_point = true;
} else {
m_local_mirror_snap_ns.complete = true;
}
dout(10) << dendl;
librados::ObjectWriteOperation op;
librbd::cls_client::mirror_image_snapshot_set_copy_progress(
&op, m_local_snap_id_end, m_local_mirror_snap_ns.complete,
m_local_mirror_snap_ns.last_copied_object_number);
auto ctx = new C_TrackedOp(
m_in_flight_op_tracker, new LambdaContext([this, complete](int r) {
handle_update_non_primary_snapshot(complete, r);
}));
auto aio_comp = create_rados_callback(ctx);
int r = m_state_builder->local_image_ctx->md_ctx.aio_operate(
m_state_builder->local_image_ctx->header_oid, aio_comp, &op);
ceph_assert(r == 0);
aio_comp->release();
}
template <typename I>
void Replayer<I>::handle_update_non_primary_snapshot(bool complete, int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to update local snapshot progress: " << cpp_strerror(r)
<< dendl;
if (complete) {
// only fail if this was the final update
handle_replay_complete(r, "failed to update local snapshot progress");
return;
}
}
if (!complete) {
// periodic sync-point update -- do not advance state machine
std::unique_lock locker{m_lock};
ceph_assert(m_updating_sync_point);
m_updating_sync_point = false;
return;
}
notify_image_update();
}
template <typename I>
void Replayer<I>::notify_image_update() {
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_notify_image_update>(this);
m_state_builder->local_image_ctx->notify_update(ctx);
}
template <typename I>
void Replayer<I>::handle_notify_image_update(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to notify local image update: " << cpp_strerror(r) << dendl;
}
unlink_peer(m_remote_snap_id_start);
}
template <typename I>
void Replayer<I>::unlink_peer(uint64_t remote_snap_id) {
if (remote_snap_id == 0) {
finish_sync();
return;
}
// local snapshot fully synced -- we no longer depend on the sync
// start snapshot in the remote image
dout(10) << "remote_snap_id=" << remote_snap_id << dendl;
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_unlink_peer>(this);
auto req = librbd::mirror::snapshot::UnlinkPeerRequest<I>::create(
m_state_builder->remote_image_ctx, remote_snap_id,
m_remote_mirror_peer_uuid, false, ctx);
req->send();
}
template <typename I>
void Replayer<I>::handle_unlink_peer(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0 && r != -ENOENT) {
derr << "failed to unlink local peer from remote image: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to unlink local peer from remote image");
return;
}
finish_sync();
}
template <typename I>
void Replayer<I>::finish_sync() {
dout(10) << dendl;
{
std::unique_lock locker{m_lock};
notify_status_updated();
if (m_sync_in_progress) {
m_sync_in_progress = false;
m_instance_watcher->notify_sync_complete(
m_state_builder->local_image_ctx->id);
}
}
if (is_replay_interrupted()) {
return;
}
load_local_image_meta();
}
template <typename I>
void Replayer<I>::register_local_update_watcher() {
dout(10) << dendl;
m_update_watch_ctx = new C_UpdateWatchCtx(this);
int r = m_state_builder->local_image_ctx->state->register_update_watcher(
m_update_watch_ctx, &m_local_update_watcher_handle);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_register_local_update_watcher>(this);
m_threads->work_queue->queue(ctx, r);
}
template <typename I>
void Replayer<I>::handle_register_local_update_watcher(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to register local update watcher: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to register local image update watcher");
m_state = STATE_COMPLETE;
delete m_update_watch_ctx;
m_update_watch_ctx = nullptr;
Context* on_init = nullptr;
std::swap(on_init, m_on_init_shutdown);
on_init->complete(r);
return;
}
register_remote_update_watcher();
}
template <typename I>
void Replayer<I>::register_remote_update_watcher() {
dout(10) << dendl;
int r = m_state_builder->remote_image_ctx->state->register_update_watcher(
m_update_watch_ctx, &m_remote_update_watcher_handle);
auto ctx = create_context_callback<
Replayer<I>, &Replayer<I>::handle_register_remote_update_watcher>(this);
m_threads->work_queue->queue(ctx, r);
}
template <typename I>
void Replayer<I>::handle_register_remote_update_watcher(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to register remote update watcher: " << cpp_strerror(r)
<< dendl;
handle_replay_complete(r, "failed to register remote image update watcher");
m_state = STATE_COMPLETE;
unregister_local_update_watcher();
return;
}
m_state = STATE_REPLAYING;
Context* on_init = nullptr;
std::swap(on_init, m_on_init_shutdown);
on_init->complete(0);
// delay initial snapshot scan until after we have alerted
// image replayer that we have initialized in case an error
// occurs
{
std::unique_lock locker{m_lock};
notify_status_updated();
}
load_local_image_meta();
}
template <typename I>
void Replayer<I>::unregister_remote_update_watcher() {
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>,
&Replayer<I>::handle_unregister_remote_update_watcher>(this);
m_state_builder->remote_image_ctx->state->unregister_update_watcher(
m_remote_update_watcher_handle, ctx);
}
template <typename I>
void Replayer<I>::handle_unregister_remote_update_watcher(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to unregister remote update watcher: " << cpp_strerror(r)
<< dendl;
}
unregister_local_update_watcher();
}
template <typename I>
void Replayer<I>::unregister_local_update_watcher() {
dout(10) << dendl;
auto ctx = create_context_callback<
Replayer<I>,
&Replayer<I>::handle_unregister_local_update_watcher>(this);
m_state_builder->local_image_ctx->state->unregister_update_watcher(
m_local_update_watcher_handle, ctx);
}
template <typename I>
void Replayer<I>::handle_unregister_local_update_watcher(int r) {
dout(10) << "r=" << r << dendl;
if (r < 0) {
derr << "failed to unregister local update watcher: " << cpp_strerror(r)
<< dendl;
}
delete m_update_watch_ctx;
m_update_watch_ctx = nullptr;
wait_for_in_flight_ops();
}
template <typename I>
void Replayer<I>::wait_for_in_flight_ops() {
dout(10) << dendl;
auto ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
Replayer<I>, &Replayer<I>::handle_wait_for_in_flight_ops>(this));
m_in_flight_op_tracker.wait_for_ops(ctx);
}
template <typename I>
void Replayer<I>::handle_wait_for_in_flight_ops(int r) {
dout(10) << "r=" << r << dendl;
Context* on_shutdown = nullptr;
{
std::unique_lock locker{m_lock};
ceph_assert(m_on_init_shutdown != nullptr);
std::swap(on_shutdown, m_on_init_shutdown);
}
on_shutdown->complete(m_error_code);
}
template <typename I>
void Replayer<I>::handle_image_update_notify() {
dout(10) << dendl;
std::unique_lock locker{m_lock};
if (m_state == STATE_REPLAYING) {
dout(15) << "flagging snapshot rescan required" << dendl;
m_image_updated = true;
} else if (m_state == STATE_IDLE) {
m_state = STATE_REPLAYING;
locker.unlock();
dout(15) << "restarting idle replayer" << dendl;
load_local_image_meta();
}
}
template <typename I>
void Replayer<I>::handle_replay_complete(int r,
const std::string& description) {
std::unique_lock locker{m_lock};
handle_replay_complete(&locker, r, description);
}
template <typename I>
void Replayer<I>::handle_replay_complete(std::unique_lock<ceph::mutex>* locker,
int r,
const std::string& description) {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
if (m_sync_in_progress) {
m_sync_in_progress = false;
m_instance_watcher->notify_sync_complete(
m_state_builder->local_image_ctx->id);
}
// don't set error code and description if resuming a pending
// shutdown
if (is_replay_interrupted(locker)) {
return;
}
if (m_error_code == 0) {
m_error_code = r;
m_error_description = description;
}
if (m_state != STATE_REPLAYING && m_state != STATE_IDLE) {
return;
}
m_state = STATE_COMPLETE;
notify_status_updated();
}
template <typename I>
void Replayer<I>::notify_status_updated() {
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
dout(10) << dendl;
auto ctx = new C_TrackedOp(m_in_flight_op_tracker, new LambdaContext(
[this](int) {
m_replayer_listener->handle_notification();
}));
m_threads->work_queue->queue(ctx, 0);
}
template <typename I>
bool Replayer<I>::is_replay_interrupted() {
std::unique_lock locker{m_lock};
return is_replay_interrupted(&locker);
}
template <typename I>
bool Replayer<I>::is_replay_interrupted(std::unique_lock<ceph::mutex>* locker) {
if (m_state == STATE_COMPLETE) {
locker->unlock();
dout(10) << "resuming pending shut down" << dendl;
unregister_remote_update_watcher();
return true;
}
return false;
}
template <typename I>
void Replayer<I>::register_perf_counters() {
dout(5) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
ceph_assert(m_perf_counters == nullptr);
auto cct = static_cast<CephContext *>(m_state_builder->local_image_ctx->cct);
auto prio = cct->_conf.get_val<int64_t>("rbd_mirror_image_perf_stats_prio");
auto local_image_ctx = m_state_builder->local_image_ctx;
std::string labels = ceph::perf_counters::key_create(
"rbd_mirror_snapshot_image",
{{"pool", local_image_ctx->md_ctx.get_pool_name()},
{"namespace", local_image_ctx->md_ctx.get_namespace()},
{"image", local_image_ctx->name}});
PerfCountersBuilder plb(g_ceph_context, labels, l_rbd_mirror_snapshot_first,
l_rbd_mirror_snapshot_last);
plb.add_u64_counter(l_rbd_mirror_snapshot_snapshots, "snapshots",
"Number of snapshots synced", nullptr, prio);
plb.add_time_avg(l_rbd_mirror_snapshot_sync_time, "sync_time",
"Average sync time", nullptr, prio);
plb.add_u64_counter(l_rbd_mirror_snapshot_sync_bytes, "sync_bytes",
"Total bytes synced", nullptr, prio, unit_t(UNIT_BYTES));
plb.add_time(l_rbd_mirror_snapshot_remote_timestamp, "remote_timestamp",
"Timestamp of the remote snapshot", nullptr, prio);
plb.add_time(l_rbd_mirror_snapshot_local_timestamp, "local_timestamp",
"Timestamp of the local snapshot", nullptr, prio);
plb.add_time(l_rbd_mirror_snapshot_last_sync_time, "last_sync_time",
"Time taken to sync the last snapshot", nullptr, prio);
plb.add_u64(l_rbd_mirror_snapshot_last_sync_bytes, "last_sync_bytes",
"Bytes synced for the last snapshot", nullptr, prio,
unit_t(UNIT_BYTES));
m_perf_counters = plb.create_perf_counters();
g_ceph_context->get_perfcounters_collection()->add(m_perf_counters);
}
template <typename I>
void Replayer<I>::unregister_perf_counters() {
dout(5) << dendl;
ceph_assert(ceph_mutex_is_locked_by_me(m_lock));
PerfCounters *perf_counters = nullptr;
std::swap(perf_counters, m_perf_counters);
if (perf_counters != nullptr) {
g_ceph_context->get_perfcounters_collection()->remove(perf_counters);
delete perf_counters;
}
}
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::snapshot::Replayer<librbd::ImageCtx>;
| 53,099 | 31.49694 | 81 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/Replayer.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_REPLAYER_H
#define RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_REPLAYER_H
#include "tools/rbd_mirror/image_replayer/Replayer.h"
#include "common/ceph_mutex.h"
#include "common/AsyncOpTracker.h"
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/mirror/snapshot/Types.h"
#include "tools/rbd_mirror/image_replayer/TimeRollingMean.h"
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>
#include <string>
#include <type_traits>
namespace librbd {
struct ImageCtx;
namespace snapshot { template <typename I> class Replay; }
} // namespace librbd
namespace rbd {
namespace mirror {
template <typename> struct InstanceWatcher;
class PoolMetaCache;
template <typename> struct Threads;
namespace image_replayer {
struct ReplayerListener;
namespace snapshot {
template <typename> class EventPreprocessor;
template <typename> class ReplayStatusFormatter;
template <typename> class StateBuilder;
template <typename ImageCtxT>
class Replayer : public image_replayer::Replayer {
public:
static Replayer* create(
Threads<ImageCtxT>* threads,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
StateBuilder<ImageCtxT>* state_builder,
ReplayerListener* replayer_listener) {
return new Replayer(threads, instance_watcher, local_mirror_uuid,
pool_meta_cache, state_builder, replayer_listener);
}
Replayer(
Threads<ImageCtxT>* threads,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
StateBuilder<ImageCtxT>* state_builder,
ReplayerListener* replayer_listener);
~Replayer();
void destroy() override {
delete this;
}
void init(Context* on_finish) override;
void shut_down(Context* on_finish) override;
void flush(Context* on_finish) override;
bool get_replay_status(std::string* description, Context* on_finish) override;
bool is_replaying() const override {
std::unique_lock locker{m_lock};
return (m_state == STATE_REPLAYING || m_state == STATE_IDLE);
}
bool is_resync_requested() const override {
std::unique_lock locker{m_lock};
return m_resync_requested;
}
int get_error_code() const override {
std::unique_lock locker(m_lock);
return m_error_code;
}
std::string get_error_description() const override {
std::unique_lock locker(m_lock);
return m_error_description;
}
std::string get_image_spec() const {
std::unique_lock locker(m_lock);
return m_image_spec;
}
private:
/**
* @verbatim
*
* <init>
* |
* v
* REGISTER_LOCAL_UPDATE_WATCHER
* |
* v
* REGISTER_REMOTE_UPDATE_WATCHER
* |
* v
* LOAD_LOCAL_IMAGE_META <----------------------------\
* | |
* v (skip if not needed) |
* REFRESH_LOCAL_IMAGE |
* | |
* v (skip if not needed) |
* REFRESH_REMOTE_IMAGE |
* | |
* | (unused non-primary snapshot) |
* |\--------------> PRUNE_NON_PRIMARY_SNAPSHOT---/|
* | |
* | (interrupted sync) |
* |\--------------> GET_LOCAL_IMAGE_STATE ------\ |
* | | |
* | (new snapshot) | |
* |\--------------> COPY_SNAPSHOTS | |
* | | | |
* | v | |
* | GET_REMOTE_IMAGE_STATE | |
* | | | |
* | v | |
* | CREATE_NON_PRIMARY_SNAPSHOT | |
* | | | |
* | v (skip if not needed)| |
* | UPDATE_MIRROR_IMAGE_STATE | |
* | | | |
* | |/--------------------/ |
* | | |
* | v |
* | REQUEST_SYNC |
* | | |
* | v |
* | COPY_IMAGE |
* | | |
* | v |
* | APPLY_IMAGE_STATE |
* | | |
* | v |
* | UPDATE_NON_PRIMARY_SNAPSHOT |
* | | |
* | v |
* | NOTIFY_IMAGE_UPDATE |
* | | |
* | (interrupted unlink) v |
* |\--------------> UNLINK_PEER |
* | | |
* | v |
* | NOTIFY_LISTENER |
* | | |
* | \----------------------/|
* | |
* | (remote demoted) |
* \---------------> NOTIFY_LISTENER |
* | | |
* |/--------------------/ |
* | |
* | (update notification) |
* <idle> --------------------------------------------/
* |
* v
* <shut down>
* |
* v
* UNREGISTER_REMOTE_UPDATE_WATCHER
* |
* v
* UNREGISTER_LOCAL_UPDATE_WATCHER
* |
* v
* WAIT_FOR_IN_FLIGHT_OPS
* |
* v
* <finish>
*
* @endverbatim
*/
enum State {
STATE_INIT,
STATE_REPLAYING,
STATE_IDLE,
STATE_COMPLETE
};
struct C_UpdateWatchCtx;
struct DeepCopyHandler;
Threads<ImageCtxT>* m_threads;
InstanceWatcher<ImageCtxT>* m_instance_watcher;
std::string m_local_mirror_uuid;
PoolMetaCache* m_pool_meta_cache;
StateBuilder<ImageCtxT>* m_state_builder;
ReplayerListener* m_replayer_listener;
mutable ceph::mutex m_lock;
State m_state = STATE_INIT;
std::string m_image_spec;
Context* m_on_init_shutdown = nullptr;
bool m_resync_requested = false;
int m_error_code = 0;
std::string m_error_description;
C_UpdateWatchCtx* m_update_watch_ctx = nullptr;
uint64_t m_local_update_watcher_handle = 0;
uint64_t m_remote_update_watcher_handle = 0;
bool m_image_updated = false;
AsyncOpTracker m_in_flight_op_tracker;
uint64_t m_local_snap_id_start = 0;
uint64_t m_local_snap_id_end = CEPH_NOSNAP;
cls::rbd::MirrorSnapshotNamespace m_local_mirror_snap_ns;
uint64_t m_local_object_count = 0;
std::string m_remote_mirror_peer_uuid;
uint64_t m_remote_snap_id_start = 0;
uint64_t m_remote_snap_id_end = CEPH_NOSNAP;
cls::rbd::MirrorSnapshotNamespace m_remote_mirror_snap_ns;
librbd::mirror::snapshot::ImageState m_image_state;
DeepCopyHandler* m_deep_copy_handler = nullptr;
TimeRollingMean m_bytes_per_second;
uint64_t m_last_snapshot_sync_seconds = 0;
uint64_t m_snapshot_bytes = 0;
uint64_t m_last_snapshot_bytes = 0;
boost::accumulators::accumulator_set<
uint64_t, boost::accumulators::stats<
boost::accumulators::tag::rolling_mean>> m_bytes_per_snapshot{
boost::accumulators::tag::rolling_window::window_size = 2};
utime_t m_snapshot_replay_start;
uint32_t m_pending_snapshots = 0;
bool m_remote_image_updated = false;
bool m_updating_sync_point = false;
bool m_sync_in_progress = false;
PerfCounters *m_perf_counters = nullptr;
void load_local_image_meta();
void handle_load_local_image_meta(int r);
void refresh_local_image();
void handle_refresh_local_image(int r);
void refresh_remote_image();
void handle_refresh_remote_image(int r);
void scan_local_mirror_snapshots(std::unique_lock<ceph::mutex>* locker);
void scan_remote_mirror_snapshots(std::unique_lock<ceph::mutex>* locker);
void prune_non_primary_snapshot(uint64_t snap_id);
void handle_prune_non_primary_snapshot(int r);
void copy_snapshots();
void handle_copy_snapshots(int r);
void get_remote_image_state();
void handle_get_remote_image_state(int r);
void get_local_image_state();
void handle_get_local_image_state(int r);
void create_non_primary_snapshot();
void handle_create_non_primary_snapshot(int r);
void update_mirror_image_state();
void handle_update_mirror_image_state(int r);
void request_sync();
void handle_request_sync(int r);
void copy_image();
void handle_copy_image(int r);
void handle_copy_image_progress(uint64_t object_number,
uint64_t object_count);
void handle_copy_image_read(uint64_t bytes_read);
void apply_image_state();
void handle_apply_image_state(int r);
void update_non_primary_snapshot(bool complete);
void handle_update_non_primary_snapshot(bool complete, int r);
void notify_image_update();
void handle_notify_image_update(int r);
void unlink_peer(uint64_t remote_snap_id);
void handle_unlink_peer(int r);
void finish_sync();
void register_local_update_watcher();
void handle_register_local_update_watcher(int r);
void register_remote_update_watcher();
void handle_register_remote_update_watcher(int r);
void unregister_remote_update_watcher();
void handle_unregister_remote_update_watcher(int r);
void unregister_local_update_watcher();
void handle_unregister_local_update_watcher(int r);
void wait_for_in_flight_ops();
void handle_wait_for_in_flight_ops(int r);
void handle_image_update_notify();
void handle_replay_complete(int r, const std::string& description);
void handle_replay_complete(std::unique_lock<ceph::mutex>* locker,
int r, const std::string& description);
void notify_status_updated();
bool is_replay_interrupted();
bool is_replay_interrupted(std::unique_lock<ceph::mutex>* lock);
void register_perf_counters();
void unregister_perf_counters();
};
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::snapshot::Replayer<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_REPLAYER_H
| 11,210 | 31.031429 | 88 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/StateBuilder.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "StateBuilder.h"
#include "include/ceph_assert.h"
#include "include/Context.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/mirror/snapshot/ImageMeta.h"
#include "tools/rbd_mirror/image_replayer/snapshot/CreateLocalImageRequest.h"
#include "tools/rbd_mirror/image_replayer/snapshot/PrepareReplayRequest.h"
#include "tools/rbd_mirror/image_replayer/snapshot/Replayer.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::" \
<< "StateBuilder: " << this << " " \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
template <typename I>
StateBuilder<I>::StateBuilder(const std::string& global_image_id)
: image_replayer::StateBuilder<I>(global_image_id) {
}
template <typename I>
StateBuilder<I>::~StateBuilder() {
ceph_assert(local_image_meta == nullptr);
}
template <typename I>
void StateBuilder<I>::close(Context* on_finish) {
dout(10) << dendl;
delete local_image_meta;
local_image_meta = nullptr;
// close the remote image after closing the local
// image in case the remote cluster is unreachable and
// we cannot close it.
on_finish = new LambdaContext([this, on_finish](int) {
this->close_remote_image(on_finish);
});
this->close_local_image(on_finish);
}
template <typename I>
bool StateBuilder<I>::is_disconnected() const {
return false;
}
template <typename I>
bool StateBuilder<I>::is_linked_impl() const {
// the remote has to have us registered as a peer
return !remote_mirror_peer_uuid.empty();
}
template <typename I>
cls::rbd::MirrorImageMode StateBuilder<I>::get_mirror_image_mode() const {
return cls::rbd::MIRROR_IMAGE_MODE_SNAPSHOT;
}
template <typename I>
image_sync::SyncPointHandler* StateBuilder<I>::create_sync_point_handler() {
dout(10) << dendl;
// TODO
ceph_assert(false);
return nullptr;
}
template <typename I>
BaseRequest* StateBuilder<I>::create_local_image_request(
Threads<I>* threads,
librados::IoCtx& local_io_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
Context* on_finish) {
return CreateLocalImageRequest<I>::create(
threads, local_io_ctx, this->remote_image_ctx, global_image_id,
pool_meta_cache, progress_ctx, this, on_finish);
}
template <typename I>
BaseRequest* StateBuilder<I>::create_prepare_replay_request(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
bool* resync_requested,
bool* syncing,
Context* on_finish) {
return PrepareReplayRequest<I>::create(
local_mirror_uuid, progress_ctx, this, resync_requested, syncing,
on_finish);
}
template <typename I>
image_replayer::Replayer* StateBuilder<I>::create_replayer(
Threads<I>* threads,
InstanceWatcher<I>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
ReplayerListener* replayer_listener) {
return Replayer<I>::create(
threads, instance_watcher, local_mirror_uuid, pool_meta_cache, this,
replayer_listener);
}
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_replayer::snapshot::StateBuilder<librbd::ImageCtx>;
| 3,553 | 28.371901 | 85 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/StateBuilder.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_STATE_BUILDER_H
#define CEPH_RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_STATE_BUILDER_H
#include "tools/rbd_mirror/image_replayer/StateBuilder.h"
#include <string>
struct Context;
namespace librbd {
struct ImageCtx;
namespace mirror {
namespace snapshot {
template <typename> class ImageMeta;
} // namespace snapshot
} // namespace mirror
} // namespace librbd
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
template <typename> class SyncPointHandler;
template <typename ImageCtxT>
class StateBuilder : public image_replayer::StateBuilder<ImageCtxT> {
public:
static StateBuilder* create(const std::string& global_image_id) {
return new StateBuilder(global_image_id);
}
StateBuilder(const std::string& global_image_id);
~StateBuilder() override;
void close(Context* on_finish) override;
bool is_disconnected() const override;
cls::rbd::MirrorImageMode get_mirror_image_mode() const override;
image_sync::SyncPointHandler* create_sync_point_handler() override;
bool replay_requires_remote_image() const override {
return true;
}
BaseRequest* create_local_image_request(
Threads<ImageCtxT>* threads,
librados::IoCtx& local_io_ctx,
const std::string& global_image_id,
PoolMetaCache* pool_meta_cache,
ProgressContext* progress_ctx,
Context* on_finish) override;
BaseRequest* create_prepare_replay_request(
const std::string& local_mirror_uuid,
ProgressContext* progress_ctx,
bool* resync_requested,
bool* syncing,
Context* on_finish) override;
image_replayer::Replayer* create_replayer(
Threads<ImageCtxT>* threads,
InstanceWatcher<ImageCtxT>* instance_watcher,
const std::string& local_mirror_uuid,
PoolMetaCache* pool_meta_cache,
ReplayerListener* replayer_listener) override;
SyncPointHandler<ImageCtxT>* sync_point_handler = nullptr;
std::string remote_mirror_peer_uuid;
librbd::mirror::snapshot::ImageMeta<ImageCtxT>* local_image_meta = nullptr;
private:
bool is_linked_impl() const override;
};
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_replayer::snapshot::StateBuilder<librbd::ImageCtx>;
#endif // CEPH_RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_STATE_BUILDER_H
| 2,490 | 25.5 | 92 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/Utils.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Utils.h"
#include "common/debug.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_replayer::snapshot::util::" \
<< __func__ << ": "
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
namespace util {
uint64_t compute_remote_snap_id(
const ceph::shared_mutex& local_image_lock,
const std::map<librados::snap_t, librbd::SnapInfo>& local_snap_infos,
uint64_t local_snap_id, const std::string& remote_mirror_uuid) {
ceph_assert(ceph_mutex_is_locked(local_image_lock));
// Search our local non-primary snapshots for a mapping to the remote
// snapshot. The non-primary mirror snapshot with the mappings will always
// come at or after the snapshot we are searching against
for (auto snap_it = local_snap_infos.lower_bound(local_snap_id);
snap_it != local_snap_infos.end(); ++snap_it) {
auto mirror_ns = std::get_if<cls::rbd::MirrorSnapshotNamespace>(
&snap_it->second.snap_namespace);
if (mirror_ns == nullptr || !mirror_ns->is_non_primary()) {
continue;
}
if (mirror_ns->primary_mirror_uuid != remote_mirror_uuid) {
dout(20) << "local snapshot " << snap_it->first << " not tied to remote"
<< dendl;
continue;
} else if (local_snap_id == snap_it->first) {
dout(15) << "local snapshot " << local_snap_id << " maps to "
<< "remote snapshot " << mirror_ns->primary_snap_id << dendl;
return mirror_ns->primary_snap_id;
}
const auto& snap_seqs = mirror_ns->snap_seqs;
for (auto [remote_snap_id_seq, local_snap_id_seq] : snap_seqs) {
if (local_snap_id_seq == local_snap_id) {
dout(15) << "local snapshot " << local_snap_id << " maps to "
<< "remote snapshot " << remote_snap_id_seq << dendl;
return remote_snap_id_seq;
}
}
}
return CEPH_NOSNAP;
}
} // namespace util
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
| 2,269 | 33.393939 | 79 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_replayer/snapshot/Utils.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_UTILS_H
#define RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_UTILS_H
#include "include/int_types.h"
#include "include/rados/librados.hpp"
#include "common/ceph_mutex.h"
#include "librbd/Types.h"
#include <map>
namespace rbd {
namespace mirror {
namespace image_replayer {
namespace snapshot {
namespace util {
uint64_t compute_remote_snap_id(
const ceph::shared_mutex& local_image_lock,
const std::map<librados::snap_t, librbd::SnapInfo>& local_snap_infos,
uint64_t local_snap_id, const std::string& remote_mirror_uuid);
} // namespace util
} // namespace snapshot
} // namespace image_replayer
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_REPLAYER_SNAPSHOT_UTILS_H
| 838 | 26.064516 | 73 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "SyncPointCreateRequest.h"
#include "include/uuid.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#include "tools/rbd_mirror/image_sync/Types.h"
#include "tools/rbd_mirror/image_sync/Utils.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_sync::SyncPointCreateRequest: " \
<< this << " " << __func__
namespace rbd {
namespace mirror {
namespace image_sync {
using librbd::util::create_context_callback;
template <typename I>
SyncPointCreateRequest<I>::SyncPointCreateRequest(
I *remote_image_ctx,
const std::string &local_mirror_uuid,
SyncPointHandler* sync_point_handler,
Context *on_finish)
: m_remote_image_ctx(remote_image_ctx),
m_local_mirror_uuid(local_mirror_uuid),
m_sync_point_handler(sync_point_handler),
m_on_finish(on_finish) {
m_sync_points_copy = m_sync_point_handler->get_sync_points();
ceph_assert(m_sync_points_copy.size() < 2);
// initialize the updated client meta with the new sync point
m_sync_points_copy.emplace_back();
if (m_sync_points_copy.size() > 1) {
m_sync_points_copy.back().from_snap_name =
m_sync_points_copy.front().snap_name;
}
}
template <typename I>
void SyncPointCreateRequest<I>::send() {
send_update_sync_points();
}
template <typename I>
void SyncPointCreateRequest<I>::send_update_sync_points() {
uuid_d uuid_gen;
uuid_gen.generate_random();
auto& sync_point = m_sync_points_copy.back();
sync_point.snap_name = util::get_snapshot_name_prefix(m_local_mirror_uuid) +
uuid_gen.to_string();
auto ctx = create_context_callback<
SyncPointCreateRequest<I>,
&SyncPointCreateRequest<I>::handle_update_sync_points>(this);
m_sync_point_handler->update_sync_points(
m_sync_point_handler->get_snap_seqs(), m_sync_points_copy, false, ctx);
}
template <typename I>
void SyncPointCreateRequest<I>::handle_update_sync_points(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to update client data: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
send_refresh_image();
}
template <typename I>
void SyncPointCreateRequest<I>::send_refresh_image() {
dout(20) << dendl;
Context *ctx = create_context_callback<
SyncPointCreateRequest<I>, &SyncPointCreateRequest<I>::handle_refresh_image>(
this);
m_remote_image_ctx->state->refresh(ctx);
}
template <typename I>
void SyncPointCreateRequest<I>::handle_refresh_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": remote image refresh failed: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
send_create_snap();
}
template <typename I>
void SyncPointCreateRequest<I>::send_create_snap() {
dout(20) << dendl;
auto& sync_point = m_sync_points_copy.back();
Context *ctx = create_context_callback<
SyncPointCreateRequest<I>, &SyncPointCreateRequest<I>::handle_create_snap>(
this);
m_remote_image_ctx->operations->snap_create(
cls::rbd::UserSnapshotNamespace(), sync_point.snap_name.c_str(),
librbd::SNAP_CREATE_FLAG_SKIP_NOTIFY_QUIESCE, m_prog_ctx, ctx);
}
template <typename I>
void SyncPointCreateRequest<I>::handle_create_snap(int r) {
dout(20) << ": r=" << r << dendl;
if (r == -EEXIST) {
send_update_sync_points();
return;
} else if (r < 0) {
derr << ": failed to create snapshot: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
send_final_refresh_image();
}
template <typename I>
void SyncPointCreateRequest<I>::send_final_refresh_image() {
dout(20) << dendl;
Context *ctx = create_context_callback<
SyncPointCreateRequest<I>,
&SyncPointCreateRequest<I>::handle_final_refresh_image>(this);
m_remote_image_ctx->state->refresh(ctx);
}
template <typename I>
void SyncPointCreateRequest<I>::handle_final_refresh_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to refresh image for snapshot: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void SyncPointCreateRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_sync
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_sync::SyncPointCreateRequest<librbd::ImageCtx>;
| 4,667 | 25.982659 | 83 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_CREATE_REQUEST_H
#define RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_CREATE_REQUEST_H
#include "librbd/internal.h"
#include "Types.h"
#include <string>
class Context;
namespace journal { class Journaler; }
namespace librbd { class ImageCtx; }
namespace librbd { namespace journal { struct MirrorPeerClientMeta; } }
namespace rbd {
namespace mirror {
namespace image_sync {
template <typename ImageCtxT = librbd::ImageCtx>
class SyncPointCreateRequest {
public:
static SyncPointCreateRequest* create(
ImageCtxT *remote_image_ctx,
const std::string &local_mirror_uuid,
SyncPointHandler* sync_point_handler,
Context *on_finish) {
return new SyncPointCreateRequest(remote_image_ctx, local_mirror_uuid,
sync_point_handler, on_finish);
}
SyncPointCreateRequest(
ImageCtxT *remote_image_ctx,
const std::string &local_mirror_uuid,
SyncPointHandler* sync_point_handler,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* v
* UPDATE_SYNC_POINTS < . .
* | .
* v .
* REFRESH_IMAGE .
* | . (repeat on EEXIST)
* v .
* CREATE_SNAP . . . . . .
* |
* v
* REFRESH_IMAGE
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_remote_image_ctx;
std::string m_local_mirror_uuid;
SyncPointHandler* m_sync_point_handler;
Context *m_on_finish;
SyncPoints m_sync_points_copy;
librbd::NoOpProgressContext m_prog_ctx;
void send_update_sync_points();
void handle_update_sync_points(int r);
void send_refresh_image();
void handle_refresh_image(int r);
void send_create_snap();
void handle_create_snap(int r);
void send_final_refresh_image();
void handle_final_refresh_image(int r);
void finish(int r);
};
} // namespace image_sync
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_sync::SyncPointCreateRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_CREATE_REQUEST_H
| 2,266 | 23.117021 | 88 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "SyncPointPruneRequest.h"
#include "common/debug.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
#include <set>
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rbd_mirror
#undef dout_prefix
#define dout_prefix *_dout << "rbd::mirror::image_sync::SyncPointPruneRequest: " \
<< this << " " << __func__
namespace rbd {
namespace mirror {
namespace image_sync {
using librbd::util::create_context_callback;
template <typename I>
SyncPointPruneRequest<I>::SyncPointPruneRequest(
I *remote_image_ctx,
bool sync_complete,
SyncPointHandler* sync_point_handler,
Context *on_finish)
: m_remote_image_ctx(remote_image_ctx),
m_sync_complete(sync_complete),
m_sync_point_handler(sync_point_handler),
m_on_finish(on_finish) {
m_sync_points_copy = m_sync_point_handler->get_sync_points();
}
template <typename I>
void SyncPointPruneRequest<I>::send() {
if (m_sync_points_copy.empty()) {
send_remove_snap();
return;
}
if (m_sync_complete) {
// if sync is complete, we can remove the master sync point
auto it = m_sync_points_copy.begin();
auto& sync_point = *it;
++it;
if (it == m_sync_points_copy.end() ||
it->from_snap_name != sync_point.snap_name) {
m_snap_names.push_back(sync_point.snap_name);
}
if (!sync_point.from_snap_name.empty()) {
m_snap_names.push_back(sync_point.from_snap_name);
}
} else {
// if we have more than one sync point or invalid sync points,
// trim them off
std::shared_lock image_locker{m_remote_image_ctx->image_lock};
std::set<std::string> snap_names;
for (auto it = m_sync_points_copy.rbegin();
it != m_sync_points_copy.rend(); ++it) {
auto& sync_point = *it;
if (&sync_point == &m_sync_points_copy.front()) {
if (m_remote_image_ctx->get_snap_id(
cls::rbd::UserSnapshotNamespace(), sync_point.snap_name) ==
CEPH_NOSNAP) {
derr << ": failed to locate sync point snapshot: "
<< sync_point.snap_name << dendl;
} else if (!sync_point.from_snap_name.empty()) {
derr << ": unexpected from_snap_name in primary sync point: "
<< sync_point.from_snap_name << dendl;
} else {
// first sync point is OK -- keep it
break;
}
m_invalid_master_sync_point = true;
}
if (snap_names.count(sync_point.snap_name) == 0) {
snap_names.insert(sync_point.snap_name);
m_snap_names.push_back(sync_point.snap_name);
}
auto& front_sync_point = m_sync_points_copy.front();
if (!sync_point.from_snap_name.empty() &&
snap_names.count(sync_point.from_snap_name) == 0 &&
sync_point.from_snap_name != front_sync_point.snap_name) {
snap_names.insert(sync_point.from_snap_name);
m_snap_names.push_back(sync_point.from_snap_name);
}
}
}
send_remove_snap();
}
template <typename I>
void SyncPointPruneRequest<I>::send_remove_snap() {
if (m_snap_names.empty()) {
send_refresh_image();
return;
}
const std::string &snap_name = m_snap_names.front();
dout(20) << ": snap_name=" << snap_name << dendl;
Context *ctx = create_context_callback<
SyncPointPruneRequest<I>, &SyncPointPruneRequest<I>::handle_remove_snap>(
this);
m_remote_image_ctx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(),
snap_name.c_str(),
ctx);
}
template <typename I>
void SyncPointPruneRequest<I>::handle_remove_snap(int r) {
dout(20) << ": r=" << r << dendl;
ceph_assert(!m_snap_names.empty());
std::string snap_name = m_snap_names.front();
m_snap_names.pop_front();
if (r == -ENOENT) {
r = 0;
}
if (r < 0) {
derr << ": failed to remove snapshot '" << snap_name << "': "
<< cpp_strerror(r) << dendl;
finish(r);
return;
}
send_remove_snap();
}
template <typename I>
void SyncPointPruneRequest<I>::send_refresh_image() {
dout(20) << dendl;
Context *ctx = create_context_callback<
SyncPointPruneRequest<I>, &SyncPointPruneRequest<I>::handle_refresh_image>(
this);
m_remote_image_ctx->state->refresh(ctx);
}
template <typename I>
void SyncPointPruneRequest<I>::handle_refresh_image(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": remote image refresh failed: " << cpp_strerror(r) << dendl;
finish(r);
return;
}
send_update_sync_points();
}
template <typename I>
void SyncPointPruneRequest<I>::send_update_sync_points() {
dout(20) << dendl;
if (m_sync_complete) {
m_sync_points_copy.pop_front();
} else {
while (m_sync_points_copy.size() > 1) {
m_sync_points_copy.pop_back();
}
if (m_invalid_master_sync_point) {
// all subsequent sync points would have been pruned
m_sync_points_copy.clear();
}
}
auto ctx = create_context_callback<
SyncPointPruneRequest<I>,
&SyncPointPruneRequest<I>::handle_update_sync_points>(this);
m_sync_point_handler->update_sync_points(
m_sync_point_handler->get_snap_seqs(), m_sync_points_copy,
m_sync_complete, ctx);
}
template <typename I>
void SyncPointPruneRequest<I>::handle_update_sync_points(int r) {
dout(20) << ": r=" << r << dendl;
if (r < 0) {
derr << ": failed to update client data: " << cpp_strerror(r)
<< dendl;
finish(r);
return;
}
finish(0);
}
template <typename I>
void SyncPointPruneRequest<I>::finish(int r) {
dout(20) << ": r=" << r << dendl;
m_on_finish->complete(r);
delete this;
}
} // namespace image_sync
} // namespace mirror
} // namespace rbd
template class rbd::mirror::image_sync::SyncPointPruneRequest<librbd::ImageCtx>;
| 5,936 | 26.742991 | 82 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_PRUNE_REQUEST_H
#define RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_PRUNE_REQUEST_H
#include "tools/rbd_mirror/image_sync/Types.h"
#include <list>
#include <string>
class Context;
namespace journal { class Journaler; }
namespace librbd { class ImageCtx; }
namespace librbd { namespace journal { struct MirrorPeerClientMeta; } }
namespace rbd {
namespace mirror {
namespace image_sync {
template <typename ImageCtxT = librbd::ImageCtx>
class SyncPointPruneRequest {
public:
static SyncPointPruneRequest* create(
ImageCtxT *remote_image_ctx,
bool sync_complete,
SyncPointHandler* sync_point_handler,
Context *on_finish) {
return new SyncPointPruneRequest(remote_image_ctx, sync_complete,
sync_point_handler, on_finish);
}
SyncPointPruneRequest(
ImageCtxT *remote_image_ctx,
bool sync_complete,
SyncPointHandler* sync_point_handler,
Context *on_finish);
void send();
private:
/**
* @verbatim
*
* <start>
* |
* | . . . . .
* | . .
* v v . (repeat if from snap
* REMOVE_SNAP . . . unused by other sync)
* |
* v
* REFRESH_IMAGE
* |
* v
* UPDATE_CLIENT
* |
* v
* <finish>
*
* @endverbatim
*/
ImageCtxT *m_remote_image_ctx;
bool m_sync_complete;
SyncPointHandler* m_sync_point_handler;
Context *m_on_finish;
SyncPoints m_sync_points_copy;
std::list<std::string> m_snap_names;
bool m_invalid_master_sync_point = false;
void send_remove_snap();
void handle_remove_snap(int r);
void send_refresh_image();
void handle_refresh_image(int r);
void send_update_sync_points();
void handle_update_sync_points(int r);
void finish(int r);
};
} // namespace image_sync
} // namespace mirror
} // namespace rbd
extern template class rbd::mirror::image_sync::SyncPointPruneRequest<librbd::ImageCtx>;
#endif // RBD_MIRROR_IMAGE_SYNC_SYNC_POINT_PRUNE_REQUEST_H
| 2,121 | 22.065217 | 87 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_IMAGE_SYNC_TYPES_H
#define RBD_MIRROR_IMAGE_SYNC_TYPES_H
#include "cls/rbd/cls_rbd_types.h"
#include "librbd/Types.h"
#include <list>
#include <string>
#include <boost/optional.hpp>
struct Context;
namespace rbd {
namespace mirror {
namespace image_sync {
struct SyncPoint {
typedef boost::optional<uint64_t> ObjectNumber;
SyncPoint() {
}
SyncPoint(const cls::rbd::SnapshotNamespace& snap_namespace,
const std::string& snap_name,
const std::string& from_snap_name,
const ObjectNumber& object_number)
: snap_namespace(snap_namespace), snap_name(snap_name),
from_snap_name(from_snap_name), object_number(object_number) {
}
cls::rbd::SnapshotNamespace snap_namespace =
{cls::rbd::UserSnapshotNamespace{}};
std::string snap_name;
std::string from_snap_name;
ObjectNumber object_number = boost::none;
bool operator==(const SyncPoint& rhs) const {
return (snap_namespace == rhs.snap_namespace &&
snap_name == rhs.snap_name &&
from_snap_name == rhs.from_snap_name &&
object_number == rhs.object_number);
}
};
typedef std::list<SyncPoint> SyncPoints;
struct SyncPointHandler {
public:
SyncPointHandler(const SyncPointHandler&) = delete;
SyncPointHandler& operator=(const SyncPointHandler&) = delete;
virtual ~SyncPointHandler() {}
virtual void destroy() {
delete this;
}
virtual SyncPoints get_sync_points() const = 0;
virtual librbd::SnapSeqs get_snap_seqs() const = 0;
virtual void update_sync_points(const librbd::SnapSeqs& snap_seq,
const SyncPoints& sync_points,
bool sync_complete,
Context* on_finish) = 0;
protected:
SyncPointHandler() {}
};
} // namespace image_sync
} // namespace mirror
} // namespace rbd
#endif // RBD_MIRROR_IMAGE_SYNC_TYPES_H
| 2,017 | 25.906667 | 70 |
h
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/Utils.cc
|
// -*- mode:c++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Utils.h"
namespace rbd {
namespace mirror {
namespace image_sync {
namespace util {
namespace {
static const std::string SNAP_NAME_PREFIX(".rbd-mirror");
} // anonymous namespace
std::string get_snapshot_name_prefix(const std::string& local_mirror_uuid) {
return SNAP_NAME_PREFIX + "." + local_mirror_uuid + ".";
}
} // namespace util
} // namespace image_sync
} // namespace mirror
} // namespace rbd
| 519 | 19.8 | 76 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/image_sync/Utils.h
|
// -*- mode:c++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <string>
namespace rbd {
namespace mirror {
namespace image_sync {
namespace util {
std::string get_snapshot_name_prefix(const std::string& local_mirror_uuid);
} // namespace util
} // namespace image_sync
} // namespace mirror
} // namespace rbd
| 358 | 20.117647 | 75 |
h
|
null |
ceph-main/src/tools/rbd_mirror/instance_watcher/Types.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "Types.h"
#include "include/ceph_assert.h"
#include "include/stringify.h"
#include "common/Formatter.h"
namespace rbd {
namespace mirror {
namespace instance_watcher {
namespace {
class EncodePayloadVisitor : public boost::static_visitor<void> {
public:
explicit EncodePayloadVisitor(bufferlist &bl) : m_bl(bl) {}
template <typename Payload>
inline void operator()(const Payload &payload) const {
using ceph::encode;
encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
payload.encode(m_bl);
}
private:
bufferlist &m_bl;
};
class DecodePayloadVisitor : public boost::static_visitor<void> {
public:
DecodePayloadVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {}
template <typename Payload>
inline void operator()(Payload &payload) const {
payload.decode(m_version, m_iter);
}
private:
__u8 m_version;
bufferlist::const_iterator &m_iter;
};
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 PayloadBase::encode(bufferlist &bl) const {
using ceph::encode;
encode(request_id, bl);
}
void PayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(request_id, iter);
}
void PayloadBase::dump(Formatter *f) const {
f->dump_unsigned("request_id", request_id);
}
void ImagePayloadBase::encode(bufferlist &bl) const {
using ceph::encode;
PayloadBase::encode(bl);
encode(global_image_id, bl);
}
void ImagePayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(global_image_id, iter);
}
void ImagePayloadBase::dump(Formatter *f) const {
PayloadBase::dump(f);
f->dump_string("global_image_id", global_image_id);
}
void PeerImageRemovedPayload::encode(bufferlist &bl) const {
using ceph::encode;
PayloadBase::encode(bl);
encode(global_image_id, bl);
encode(peer_mirror_uuid, bl);
}
void PeerImageRemovedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(global_image_id, iter);
decode(peer_mirror_uuid, iter);
}
void PeerImageRemovedPayload::dump(Formatter *f) const {
PayloadBase::dump(f);
f->dump_string("global_image_id", global_image_id);
f->dump_string("peer_mirror_uuid", peer_mirror_uuid);
}
void SyncPayloadBase::encode(bufferlist &bl) const {
using ceph::encode;
PayloadBase::encode(bl);
encode(sync_id, bl);
}
void SyncPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(sync_id, iter);
}
void SyncPayloadBase::dump(Formatter *f) const {
PayloadBase::dump(f);
f->dump_string("sync_id", sync_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(2, 2, bl);
boost::apply_visitor(EncodePayloadVisitor(bl), payload);
ENCODE_FINISH(bl);
}
void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(2, 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_ACQUIRE:
payload = ImageAcquirePayload();
break;
case NOTIFY_OP_IMAGE_RELEASE:
payload = ImageReleasePayload();
break;
case NOTIFY_OP_PEER_IMAGE_REMOVED:
payload = PeerImageRemovedPayload();
break;
case NOTIFY_OP_SYNC_REQUEST:
payload = SyncRequestPayload();
break;
case NOTIFY_OP_SYNC_START:
payload = SyncStartPayload();
break;
default:
payload = UnknownPayload();
break;
}
apply_visitor(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(ImageAcquirePayload()));
o.push_back(new NotifyMessage(ImageAcquirePayload(1, "gid")));
o.push_back(new NotifyMessage(ImageReleasePayload()));
o.push_back(new NotifyMessage(ImageReleasePayload(1, "gid")));
o.push_back(new NotifyMessage(PeerImageRemovedPayload()));
o.push_back(new NotifyMessage(PeerImageRemovedPayload(1, "gid", "uuid")));
o.push_back(new NotifyMessage(SyncRequestPayload()));
o.push_back(new NotifyMessage(SyncRequestPayload(1, "sync_id")));
o.push_back(new NotifyMessage(SyncStartPayload()));
o.push_back(new NotifyMessage(SyncStartPayload(1, "sync_id")));
}
std::ostream &operator<<(std::ostream &out, const NotifyOp &op) {
switch (op) {
case NOTIFY_OP_IMAGE_ACQUIRE:
out << "ImageAcquire";
break;
case NOTIFY_OP_IMAGE_RELEASE:
out << "ImageRelease";
break;
case NOTIFY_OP_PEER_IMAGE_REMOVED:
out << "PeerImageRemoved";
break;
case NOTIFY_OP_SYNC_REQUEST:
out << "SyncRequest";
break;
case NOTIFY_OP_SYNC_START:
out << "SyncStart";
break;
default:
out << "Unknown (" << static_cast<uint32_t>(op) << ")";
break;
}
return out;
}
void NotifyAckPayload::encode(bufferlist &bl) const {
using ceph::encode;
encode(instance_id, bl);
encode(request_id, bl);
encode(ret_val, bl);
}
void NotifyAckPayload::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
decode(instance_id, iter);
decode(request_id, iter);
decode(ret_val, iter);
}
void NotifyAckPayload::dump(Formatter *f) const {
f->dump_string("instance_id", instance_id);
f->dump_unsigned("request_id", request_id);
f->dump_int("request_id", ret_val);
}
} // namespace instance_watcher
} // namespace mirror
} // namespace rbd
| 6,335 | 24.756098 | 86 |
cc
|
null |
ceph-main/src/tools/rbd_mirror/instance_watcher/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
#define RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
#include <string>
#include <set>
#include <boost/variant.hpp>
#include "include/buffer_fwd.h"
#include "include/encoding.h"
#include "include/int_types.h"
namespace ceph { class Formatter; }
namespace rbd {
namespace mirror {
namespace instance_watcher {
enum NotifyOp {
NOTIFY_OP_IMAGE_ACQUIRE = 0,
NOTIFY_OP_IMAGE_RELEASE = 1,
NOTIFY_OP_PEER_IMAGE_REMOVED = 2,
NOTIFY_OP_SYNC_REQUEST = 3,
NOTIFY_OP_SYNC_START = 4
};
struct PayloadBase {
uint64_t request_id;
PayloadBase() : request_id(0) {
}
PayloadBase(uint64_t request_id) : request_id(request_id) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct ImagePayloadBase : public PayloadBase {
std::string global_image_id;
ImagePayloadBase() : PayloadBase() {
}
ImagePayloadBase(uint64_t request_id, const std::string &global_image_id)
: PayloadBase(request_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 ImageAcquirePayload : public ImagePayloadBase {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_ACQUIRE;
ImageAcquirePayload() {
}
ImageAcquirePayload(uint64_t request_id, const std::string &global_image_id)
: ImagePayloadBase(request_id, global_image_id) {
}
};
struct ImageReleasePayload : public ImagePayloadBase {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_IMAGE_RELEASE;
ImageReleasePayload() {
}
ImageReleasePayload(uint64_t request_id, const std::string &global_image_id)
: ImagePayloadBase(request_id, global_image_id) {
}
};
struct PeerImageRemovedPayload : public PayloadBase {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_PEER_IMAGE_REMOVED;
std::string global_image_id;
std::string peer_mirror_uuid;
PeerImageRemovedPayload() {
}
PeerImageRemovedPayload(uint64_t request_id,
const std::string& global_image_id,
const std::string& peer_mirror_uuid)
: PayloadBase(request_id),
global_image_id(global_image_id), peer_mirror_uuid(peer_mirror_uuid) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct SyncPayloadBase : public PayloadBase {
std::string sync_id;
SyncPayloadBase() : PayloadBase() {
}
SyncPayloadBase(uint64_t request_id, const std::string &sync_id)
: PayloadBase(request_id), sync_id(sync_id) {
}
void encode(bufferlist &bl) const;
void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
struct SyncRequestPayload : public SyncPayloadBase {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_SYNC_REQUEST;
SyncRequestPayload() : SyncPayloadBase() {
}
SyncRequestPayload(uint64_t request_id, const std::string &sync_id)
: SyncPayloadBase(request_id, sync_id) {
}
};
struct SyncStartPayload : public SyncPayloadBase {
static const NotifyOp NOTIFY_OP = NOTIFY_OP_SYNC_START;
SyncStartPayload() : SyncPayloadBase() {
}
SyncStartPayload(uint64_t request_id, const std::string &sync_id)
: SyncPayloadBase(request_id, sync_id) {
}
};
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<ImageAcquirePayload,
ImageReleasePayload,
PeerImageRemovedPayload,
SyncRequestPayload,
SyncStartPayload,
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);
struct NotifyAckPayload {
std::string instance_id;
uint64_t request_id;
int ret_val;
NotifyAckPayload() : request_id(0), ret_val(0) {
}
NotifyAckPayload(const std::string &instance_id, uint64_t request_id,
int ret_val)
: instance_id(instance_id), request_id(request_id), ret_val(ret_val) {
}
void encode(bufferlist &bl) const;
void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
WRITE_CLASS_ENCODER(NotifyAckPayload);
} // namespace instance_watcher
} // namespace mirror
} // namespace librbd
using rbd::mirror::instance_watcher::encode;
using rbd::mirror::instance_watcher::decode;
#endif // RBD_MIRROR_INSTANCE_WATCHER_TYPES_H
| 5,146 | 24.994949 | 79 |
h
|
null |
ceph-main/src/tools/rbd_mirror/instances/Types.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_RBD_MIRROR_INSTANCES_TYPES_H
#define CEPH_RBD_MIRROR_INSTANCES_TYPES_H
#include <string>
#include <vector>
namespace rbd {
namespace mirror {
namespace instances {
struct Listener {
typedef std::vector<std::string> InstanceIds;
virtual ~Listener() {
}
virtual void handle_added(const InstanceIds& instance_ids) = 0;
virtual void handle_removed(const InstanceIds& instance_ids) = 0;
};
} // namespace instances
} // namespace mirror
} // namespace rbd
#endif // CEPH_RBD_MIRROR_INSTANCES_TYPES_H
| 624 | 20.551724 | 70 |
h
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.