// vim: ts=8 sw=2 smarttab
#include "librbd/AsyncObjectThrottle.h"
#include "common/RWLock.h"
-#include "common/WorkQueue.h"
#include "librbd/AsyncRequest.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
namespace librbd
{
#include "librbd/AsyncRequest.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
-#include "common/WorkQueue.h"
+#include "librbd/asio/ContextWQ.h"
namespace librbd
{
librados::snap_t dst_snap_id_start,
bool flatten,
const ObjectNumber &object_number,
- ContextWQ *work_queue, SnapSeqs *snap_seqs,
+ asio::ContextWQ *work_queue,
+ SnapSeqs *snap_seqs,
deep_copy::Handler *handler,
Context *on_finish)
: RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
namespace librbd {
class ImageCtx;
+namespace asio { struct ContextWQ; }
namespace deep_copy {
librados::snap_t dst_snap_id_start,
bool flatten,
const deep_copy::ObjectNumber &object_number,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
SnapSeqs *snap_seqs,
deep_copy::Handler *handler,
Context *on_finish) {
librados::snap_t src_snap_id_end,
librados::snap_t dst_snap_id_start,
bool flatten, const deep_copy::ObjectNumber &object_number,
- ContextWQ *work_queue, SnapSeqs *snap_seqs,
+ asio::ContextWQ *work_queue, SnapSeqs *snap_seqs,
deep_copy::Handler *handler, Context *on_finish);
~DeepCopyRequest();
librados::snap_t m_dst_snap_id_start;
bool m_flatten;
deep_copy::ObjectNumber m_object_number;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
SnapSeqs *m_snap_seqs;
deep_copy::Handler *m_handler;
Context *m_on_finish;
#include "librbd/exclusive_lock/PreReleaseRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "common/ceph_mutex.h"
#include "common/dout.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/perf_counters.h"
-#include "common/WorkQueue.h"
#include "common/Timer.h"
#include "librbd/AsioEngine.h"
#include "librbd/PluginRegistry.h"
#include "librbd/Types.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/exclusive_lock/AutomaticPolicy.h"
#include "librbd/exclusive_lock/StandardPolicy.h"
#include "librbd/io/AioCompletion.h"
namespace {
-class ThreadPoolSingleton : public ThreadPool {
-public:
- ContextWQ *op_work_queue;
-
- explicit ThreadPoolSingleton(CephContext *cct)
- : ThreadPool(cct, "librbd::thread_pool", "tp_librbd", 1,
- "rbd_op_threads"),
- op_work_queue(new ContextWQ("librbd::op_work_queue",
- cct->_conf.get_val<uint64_t>("rbd_op_thread_timeout"),
- this)) {
- start();
- }
- ~ThreadPoolSingleton() override {
- op_work_queue->drain();
- delete op_work_queue;
-
- stop();
- }
-};
-
class SafeTimerSingleton : public SafeTimer {
public:
ceph::mutex lock = ceph::make_mutex("librbd::SafeTimerSingleton::lock");
return asio_engine_singleton->get_io_context();
}
-void get_thread_pool_instance(CephContext *cct, ThreadPool **thread_pool,
- ContextWQ **op_work_queue) {
- auto thread_pool_singleton =
- &cct->lookup_or_create_singleton_object<ThreadPoolSingleton>(
- "librbd::thread_pool", false, cct);
- *thread_pool = thread_pool_singleton;
- *op_work_queue = thread_pool_singleton->op_work_queue;
-}
-
} // anonymous namespace
const string ImageCtx::METADATA_CONF_PREFIX = "conf_";
// FIPS zeroization audit 20191117: this memset is not security related.
memset(&header, 0, sizeof(header));
- ThreadPool *thread_pool;
- get_thread_pool_instance(cct, &thread_pool, &op_work_queue);
+ get_work_queue(cct, &op_work_queue);
io_image_dispatcher = new io::ImageDispatcher<ImageCtx>(this);
io_object_dispatcher = new io::ObjectDispatcher<ImageCtx>(this);
}
void ImageCtx::get_work_queue(CephContext *cct,
- ContextWQ **op_work_queue) {
-
- ThreadPool* thread_pool;
- get_thread_pool_instance(cct, &thread_pool, op_work_queue);
+ asio::ContextWQ **op_work_queue) {
+ *op_work_queue = get_asio_engine(cct)->get_work_queue();
}
void ImageCtx::get_timer_instance(CephContext *cct, SafeTimer **timer,
#include <boost/lockfree/policies.hpp>
#include <boost/lockfree/queue.hpp>
-class ContextWQ;
class Finisher;
class ThreadPool;
class SafeTimer;
template <typename> class Operations;
template <typename> class PluginRegistry;
- namespace cache {
- template <typename> class ImageCache;
- }
+ namespace asio { struct ContextWQ; }
+ namespace cache { template <typename> class ImageCache; }
namespace exclusive_lock { struct Policy; }
namespace io {
class AioCompletion;
io::ImageDispatcherInterface *io_image_dispatcher = nullptr;
io::ObjectDispatcherInterface *io_object_dispatcher = nullptr;
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
PluginRegistry<ImageCtx>* plugin_registry;
void set_journal_policy(journal::Policy *policy);
static AsioEngine* get_asio_engine(CephContext* cct);
- static void get_work_queue(CephContext *cct, ContextWQ **op_work_queue);
+ static void get_work_queue(CephContext *cct,
+ asio::ContextWQ **op_work_queue);
static void get_timer_instance(CephContext *cct, SafeTimer **timer,
ceph::mutex **timer_lock);
};
#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/image/CloseRequest.h"
#include "librbd/image/OpenRequest.h"
#include "librbd/image/RefreshRequest.h"
auto& thread_pool = m_cct->lookup_or_create_singleton_object<
ThreadPoolSingleton>("librbd::ImageUpdateWatchers::thread_pool",
false, m_cct);
- m_work_queue = new ContextWQ("librbd::ImageUpdateWatchers::op_work_queue",
+ m_work_queue = new ContextWQ("librbd::ImageUpdateWatchers::work_queue",
m_cct->_conf.get_val<uint64_t>("rbd_op_thread_timeout"),
&thread_pool);
}
enum EventType {QUIESCE, UNQUIESCE};
CephContext *m_cct;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
ceph::mutex m_lock;
std::map<uint64_t, QuiesceWatchCtx*> m_watchers;
#include "librbd/TaskFinisher.h"
#include "librbd/Types.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/exclusive_lock/Policy.h"
#include "librbd/image_watcher/NotifyLockOwner.h"
#include "librbd/io/AioCompletion.h"
#include "include/encoding.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include <boost/bind.hpp>
#define dout_subsys ceph_subsys_rbd
#include "journal/Settings.h"
#include "journal/Utils.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/journal/CreateRequest.h"
namespace {
-// TODO: once journaler is 100% async, remove separate threads and
-// reuse ImageCtx's thread pool
+// TODO: once journaler is 100% async and converted to ASIO, remove separate
+// threads and reuse librbd's AsioEngine
class ThreadPoolSingleton : public ThreadPool {
public:
+ ContextWQ *work_queue;
+
explicit ThreadPoolSingleton(CephContext *cct)
- : ThreadPool(cct, "librbd::Journal", "tp_librbd_journ", 1) {
+ : ThreadPool(cct, "librbd::Journal", "tp_librbd_journ", 1),
+ work_queue(new ContextWQ("librbd::journal::work_queue",
+ cct->_conf.get_val<uint64_t>("rbd_op_thread_timeout"),
+ this)) {
start();
}
~ThreadPoolSingleton() override {
+ work_queue->drain();
+ delete work_queue;
+
stop();
}
};
librados::IoCtx &io_ctx;
std::string image_id;
bool *is_tag_owner;
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
Context *on_finish;
CephContext *cct = nullptr;
journal::TagData tag_data;
C_IsTagOwner(librados::IoCtx &io_ctx, const std::string &image_id,
- bool *is_tag_owner, ContextWQ *op_work_queue, Context *on_finish)
+ bool *is_tag_owner, asio::ContextWQ *op_work_queue,
+ Context *on_finish)
: io_ctx(io_ctx), image_id(image_id), is_tag_owner(is_tag_owner),
op_work_queue(op_work_queue), on_finish(on_finish),
cct(reinterpret_cast<CephContext*>(io_ctx.cct())),
return os;
}
+
+template <typename I>
+void Journal<I>::MetadataListener::handle_update(::journal::JournalMetadata *) {
+ auto ctx = new LambdaContext([this](int r) {
+ journal->handle_metadata_updated();
+ });
+ journal->m_work_queue->queue(ctx, 0);
+}
+
+
+template <typename I>
+void Journal<I>::get_work_queue(CephContext *cct, ContextWQ **work_queue) {
+ auto thread_pool_singleton =
+ &cct->lookup_or_create_singleton_object<ThreadPoolSingleton>(
+ "librbd::journal::thread_pool", false, cct);
+ *work_queue = thread_pool_singleton->work_queue;
+}
+
template <typename I>
Journal<I>::Journal(I &image_ctx)
: RefCountedObject(image_ctx.cct),
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << ": ictx=" << &m_image_ctx << dendl;
- auto thread_pool_singleton =
- &cct->lookup_or_create_singleton_object<ThreadPoolSingleton>(
- "librbd::journal::thread_pool", false, cct);
- m_work_queue = new ContextWQ("librbd::journal::work_queue",
- cct->_conf.get_val<uint64_t>("rbd_op_thread_timeout"),
- thread_pool_singleton);
+ get_work_queue(cct, &m_work_queue);
ImageCtx::get_timer_instance(cct, &m_timer, &m_timer_lock);
}
Journal<I>::~Journal() {
if (m_work_queue != nullptr) {
m_work_queue->drain();
- delete m_work_queue;
}
std::lock_guard locker{m_lock};
CephContext *cct = reinterpret_cast<CephContext *>(io_ctx.cct());
ldout(cct, 5) << __func__ << ": image=" << image_id << dendl;
- ContextWQ *op_work_queue;
- ImageCtx::get_work_queue(cct, &op_work_queue);
+ ContextWQ *work_queue;
+ get_work_queue(cct, &work_queue);
C_SaferCond cond;
journal::TagData tag_data(LOCAL_MIRROR_UUID);
journal::CreateRequest<I> *req = journal::CreateRequest<I>::create(
io_ctx, image_id, order, splay_width, object_pool, cls::journal::Tag::TAG_CLASS_NEW,
- tag_data, IMAGE_CLIENT_ID, op_work_queue, &cond);
+ tag_data, IMAGE_CLIENT_ID, work_queue, &cond);
req->send();
return cond.wait();
CephContext *cct = reinterpret_cast<CephContext *>(io_ctx.cct());
ldout(cct, 5) << __func__ << ": image=" << image_id << dendl;
- ContextWQ *op_work_queue;
- ImageCtx::get_work_queue(cct, &op_work_queue);
+ ContextWQ *work_queue;
+ get_work_queue(cct, &work_queue);
C_SaferCond cond;
journal::RemoveRequest<I> *req = journal::RemoveRequest<I>::create(
- io_ctx, image_id, IMAGE_CLIENT_ID, op_work_queue, &cond);
+ io_ctx, image_id, IMAGE_CLIENT_ID, work_queue, &cond);
req->send();
return cond.wait();
CephContext *cct = reinterpret_cast<CephContext *>(io_ctx.cct());
ldout(cct, 5) << __func__ << ": image=" << image_id << dendl;
- ContextWQ *op_work_queue;
- ImageCtx::get_work_queue(cct, &op_work_queue);
+ ContextWQ *work_queue;
+ get_work_queue(cct, &work_queue);
C_SaferCond cond;
auto req = journal::ResetRequest<I>::create(io_ctx, image_id, IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- op_work_queue, &cond);
+ work_queue, &cond);
req->send();
return cond.wait();
template <typename I>
void Journal<I>::is_tag_owner(librados::IoCtx& io_ctx, std::string& image_id,
- bool *is_tag_owner, ContextWQ *op_work_queue,
+ bool *is_tag_owner,
+ asio::ContextWQ *op_work_queue,
Context *on_finish) {
CephContext *cct = reinterpret_cast<CephContext*>(io_ctx.cct());
ldout(cct, 20) << __func__ << dendl;
template <typename I>
void Journal<I>::get_tag_owner(IoCtx& io_ctx, std::string& image_id,
std::string *mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish) {
+ asio::ContextWQ *op_work_queue,
+ Context *on_finish) {
CephContext *cct = static_cast<CephContext *>(io_ctx.cct());
ldout(cct, 20) << __func__ << dendl;
#include "common/AsyncOpTracker.h"
#include "common/Cond.h"
#include "common/RefCountedObj.h"
-#include "common/WorkQueue.h"
#include "journal/Future.h"
#include "journal/JournalMetadataListener.h"
#include "journal/ReplayEntry.h"
#include "journal/ReplayHandler.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/TypeTraits.h"
#include <atomic>
#include <unordered_map>
+class ContextWQ;
class SafeTimer;
-namespace journal {
-class Journaler;
-}
+namespace journal { class Journaler; }
namespace librbd {
Journal(ImageCtxT &image_ctx);
~Journal();
+ static void get_work_queue(CephContext *cct, ContextWQ **work_queue);
+
static bool is_journal_supported(ImageCtxT &image_ctx);
static int create(librados::IoCtx &io_ctx, const std::string &image_id,
uint8_t order, uint8_t splay_width,
static void is_tag_owner(ImageCtxT *image_ctx, bool *is_tag_owner,
Context *on_finish);
static void is_tag_owner(librados::IoCtx& io_ctx, std::string& image_id,
- bool *is_tag_owner, ContextWQ *op_work_queue,
+ bool *is_tag_owner, asio::ContextWQ *op_work_queue,
Context *on_finish);
static void get_tag_owner(librados::IoCtx& io_ctx, std::string& image_id,
std::string *mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish);
+ asio::ContextWQ *op_work_queue, Context *on_finish);
static int request_resync(ImageCtxT *image_ctx);
static void promote(ImageCtxT *image_ctx, Context *on_finish);
static void demote(ImageCtxT *image_ctx, Context *on_finish);
MetadataListener(Journal<ImageCtxT> *journal) : journal(journal) { }
- void handle_update(::journal::JournalMetadata *) override {
- auto ctx = new LambdaContext([this](int r) {
- journal->handle_metadata_updated();
- });
- journal->m_work_queue->queue(ctx, 0);
- }
+ void handle_update(::journal::JournalMetadata *) override;
} m_metadata_listener;
typedef std::set<journal::Listener *> Listeners;
// vim: ts=8 sw=2 smarttab
#include "librbd/ManagedLock.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/managed_lock/AcquireRequest.h"
#include "librbd/managed_lock/BreakRequest.h"
#include "librbd/managed_lock/GetLockerRequest.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/Cond.h"
-#include "common/WorkQueue.h"
#include "librbd/Utils.h"
#define dout_subsys ceph_subsys_rbd
using managed_lock::util::encode_lock_cookie;
template <typename I>
-ManagedLock<I>::ManagedLock(librados::IoCtx &ioctx, ContextWQ *work_queue,
+ManagedLock<I>::ManagedLock(librados::IoCtx &ioctx, asio::ContextWQ *work_queue,
const string& oid, Watcher *watcher, Mode mode,
bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds)
#include <string>
#include <utility>
-class ContextWQ;
-
namespace librbd {
struct ImageCtx;
+namespace asio { struct ContextWQ; }
namespace managed_lock { struct Locker; }
template <typename ImageCtxT = librbd::ImageCtx>
typedef typename TypeTraits::Watcher Watcher;
public:
- static ManagedLock *create(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ static ManagedLock *create(librados::IoCtx& ioctx,
+ asio::ContextWQ *work_queue,
const std::string& oid, Watcher *watcher,
managed_lock::Mode mode,
bool blacklist_on_break_lock,
delete this;
}
- ManagedLock(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ ManagedLock(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid, Watcher *watcher,
managed_lock::Mode mode, bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds);
librados::IoCtx& m_ioctx;
CephContext *m_cct;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
std::string m_oid;
Watcher *m_watcher;
managed_lock::Mode m_mode;
template <typename I>
MirroringWatcher<I>::MirroringWatcher(librados::IoCtx &io_ctx,
- ContextWQ *work_queue)
+ asio::ContextWQ *work_queue)
: Watcher(io_ctx, work_queue, RBD_MIRRORING) {
}
namespace librbd {
+namespace asio { struct ContextWQ; }
namespace watcher {
namespace util {
template <typename> struct HandlePayloadVisitor;
friend struct watcher::util::HandlePayloadVisitor<MirroringWatcher<ImageCtxT>>;
public:
- MirroringWatcher(librados::IoCtx &io_ctx, ContextWQ *work_queue);
+ MirroringWatcher(librados::IoCtx &io_ctx, asio::ContextWQ *work_queue);
static int notify_mode_updated(librados::IoCtx &io_ctx,
cls::rbd::MirrorMode mirror_mode);
#include "librbd/BlockGuard.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/object_map/RefreshRequest.h"
#include "librbd/object_map/ResizeRequest.h"
#include "librbd/object_map/SnapshotCreateRequest.h"
#include "librbd/Utils.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "include/rados/librados.hpp"
#include "common/dout.h"
#include "common/errno.h"
#include "common/perf_counters.h"
-#include "common/WorkQueue.h"
#include "osdc/Striper.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/Types.h"
#include "librbd/Utils.h"
#include "librbd/api/Config.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/DisabledPolicy.h"
#include "librbd/journal/StandardPolicy.h"
#include "librbd/operation/DisableFeaturesRequest.h"
} // anonymous namespace
template <typename I>
-TrashWatcher<I>::TrashWatcher(librados::IoCtx &io_ctx, ContextWQ *work_queue)
+TrashWatcher<I>::TrashWatcher(librados::IoCtx &io_ctx,
+ asio::ContextWQ *work_queue)
: Watcher(io_ctx, work_queue, RBD_TRASH) {
}
namespace librbd {
+namespace asio { struct ContextWQ; }
namespace watcher {
namespace util {
template <typename> struct HandlePayloadVisitor;
class TrashWatcher : public Watcher {
friend struct watcher::util::HandlePayloadVisitor<TrashWatcher<ImageCtxT>>;
public:
- TrashWatcher(librados::IoCtx &io_ctx, ContextWQ *work_queue);
+ TrashWatcher(librados::IoCtx &io_ctx, asio::ContextWQ *work_queue);
static void notify_image_added(librados::IoCtx &io_ctx,
const std::string& image_id,
#include "librbd/watcher/RewatchRequest.h"
#include "librbd/Utils.h"
#include "librbd/TaskFinisher.h"
+#include "librbd/asio/ContextWQ.h"
#include "include/encoding.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include <boost/bind.hpp>
// re-include our assert to clobber the system one; fix dout:
#define dout_prefix *_dout << "librbd::Watcher: " << this << " " << __func__ \
<< ": "
-Watcher::Watcher(librados::IoCtx& ioctx, ContextWQ *work_queue,
+Watcher::Watcher(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const string& oid)
: m_ioctx(ioctx), m_work_queue(work_queue), m_oid(oid),
m_cct(reinterpret_cast<CephContext *>(ioctx.cct())),
- m_watch_lock(ceph::make_shared_mutex(util::unique_lock_name("librbd::Watcher::m_watch_lock", this))),
+ m_watch_lock(ceph::make_shared_mutex(
+ util::unique_lock_name("librbd::Watcher::m_watch_lock", this))),
m_watch_handle(0), m_notifier(work_queue, ioctx, oid),
m_watch_state(WATCH_STATE_IDLE), m_watch_ctx(*this) {
}
#include <string>
#include <utility>
-class ContextWQ;
-
namespace librbd {
+namespace asio { struct ContextWQ; }
namespace watcher { struct NotifyResponse; }
class Watcher {
void finish(int r) override;
};
- Watcher(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ Watcher(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid);
virtual ~Watcher();
};
librados::IoCtx& m_ioctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
std::string m_oid;
CephContext *m_cct;
mutable ceph::shared_mutex m_watch_lock;
snap_id_end = src->snap_id;
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
C_SaferCond cond;
SnapSeqs snap_seqs;
deep_copy::ProgressHandler progress_handler{&prog_ctx};
auto req = DeepCopyRequest<I>::create(
- src, dest, snap_id_start, snap_id_end, 0U, flatten, boost::none, op_work_queue,
- &snap_seqs, &progress_handler, &cond);
+ src, dest, snap_id_start, snap_id_end, 0U, flatten, boost::none,
+ op_work_queue, &snap_seqs, &progress_handler, &cond);
req->send();
int r = cond.wait();
if (r < 0) {
// fall-through if trash isn't supported
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
// might be a V1 image format that cannot be moved to the trash
ceph_assert(dst_image_ctx->ignore_migrating);
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(m_cct, &op_work_queue);
C_SaferCond on_remove;
auto req = librbd::image::RemoveRequest<>::create(
}
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(m_cct, &op_work_queue);
ConfigProxy config{m_cct->_conf};
ceph_assert(m_src_image_ctx->ignore_migrating);
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(m_cct, &op_work_queue);
C_SaferCond on_remove;
auto req = librbd::image::RemoveRequest<I>::create(
template <typename I>
void Mirror<I>::image_get_info(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
mirror_image_info_t *mirror_image_info,
Context *on_finish) {
template <typename I>
int Mirror<I>::image_get_info(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
mirror_image_info_t *mirror_image_info) {
C_SaferCond ctx;
break;
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
for (auto &it : images) {
#include <string>
#include <vector>
-class ContextWQ;
-
struct Context;
namespace librbd {
struct ImageCtx;
+namespace asio { struct ContextWQ; }
namespace api {
mirror_image_info_t *mirror_image_info,
Context *on_finish);
static int image_get_info(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
mirror_image_info_t *mirror_image_info);
static void image_get_info(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
mirror_image_info_t *mirror_image_info,
Context *on_finish);
return 0;
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
C_SaferCond ctx;
ldout(cct, 10) << dendl;
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
C_SaferCond ctx;
auto req = mirror::EnableRequest<I>::create(
return -EBUSY;
}
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
C_SaferCond cond;
#include "librbd/cache/ObjectCacherObjectDispatch.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/cache/ObjectCacherWriteback.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "common/ceph_context.h"
#include "common/dout.h"
#include "common/ceph_mutex.h"
-#include "common/WorkQueue.h"
#include "osdc/Striper.h"
#include "include/Context.h"
#include "include/rados/librados.hpp"
#include "librbd/ObjectMap.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
-#include "librbd/Journal.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/io/Utils.h"
#include "common/Timer.h"
#include "common/perf_counters.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/cache/rwl/ImageCacheState.h"
#include "librbd/cache/rwl/LogEntry.h"
#include "librbd/cache/rwl/Types.h"
#include "librbd/cache/WriteAroundObjectDispatch.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "SetHeadRequest.h"
#include "SnapshotCreateRequest.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ObjectMap.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "osdc/Striper.h"
#define dout_subsys ceph_subsys_rbd
librados::snap_t src_snap_id_start,
librados::snap_t src_snap_id_end,
librados::snap_t dst_snap_id_start,
- bool flatten, ContextWQ *work_queue,
+ bool flatten,
+ asio::ContextWQ *work_queue,
SnapSeqs *snap_seqs,
Context *on_finish)
: RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
class Context;
namespace librbd {
+
+namespace asio { struct ContextWQ; }
+
namespace deep_copy {
template <typename ImageCtxT = librbd::ImageCtx>
librados::snap_t src_snap_id_start,
librados::snap_t src_snap_id_end,
librados::snap_t dst_snap_id_start,
- bool flatten, ContextWQ *work_queue,
+ bool flatten, asio::ContextWQ *work_queue,
SnapSeqs *snap_seqs, Context *on_finish) {
return new SnapshotCopyRequest(src_image_ctx, dst_image_ctx,
src_snap_id_start, src_snap_id_end,
librados::snap_t src_snap_id_start,
librados::snap_t src_snap_id_end,
librados::snap_t dst_snap_id_start,
- bool flatten, ContextWQ *work_queue, SnapSeqs *snap_seqs,
- Context *on_finish);
+ bool flatten, asio::ContextWQ *work_queue,
+ SnapSeqs *snap_seqs, Context *on_finish);
void send();
void cancel();
librados::snap_t m_src_snap_id_end;
librados::snap_t m_dst_snap_id_start;
bool m_flatten;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
SnapSeqs *m_snap_seqs_result;
SnapSeqs m_snap_seqs;
Context *m_on_finish;
#include "include/Context.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "cls/lock/cls_lock_types.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "include/stringify.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageWatcher.h"
#include "librbd/ImageState.h"
+#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#include "librbd/image/AttachParentRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "include/ceph_assert.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/deep_copy/MetadataCopyRequest.h"
#include "librbd/image/AttachChildRequest.h"
#include "librbd/image/AttachParentRequest.h"
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish)
+ asio::ContextWQ *op_work_queue, Context *on_finish)
: m_config(config), m_parent_io_ctx(parent_io_ctx),
m_parent_image_id(parent_image_id), m_parent_snap_name(parent_snap_name),
m_parent_snap_namespace(parent_snap_namespace),
using librados::IoCtx;
namespace librbd {
+
+namespace asio { struct ContextWQ; }
+
namespace image {
template <typename ImageCtxT = ImageCtx>
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish) {
+ asio::ContextWQ *op_work_queue, Context *on_finish) {
return new CloneRequest(config, parent_io_ctx, parent_image_id,
parent_snap_name, parent_snap_namespace,
parent_snap_id, c_ioctx, c_name, c_id, c_options,
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish);
+ asio::ContextWQ *op_work_queue, Context *on_finish);
void send();
const std::string m_non_primary_global_image_id;
const std::string m_primary_mirror_uuid;
NoOpProgressContext m_no_op;
- ContextWQ *m_op_work_queue;
+ asio::ContextWQ *m_op_work_queue;
Context *m_on_finish;
CephContext *m_cct;
#include "librbd/ImageWatcher.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageDispatcher.h"
#include "librbd/io/ImageDispatchSpec.h"
#include "librbd/Journal.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/image/Types.h"
#include "librbd/image/ValidatePoolRequest.h"
#include "librbd/journal/CreateRequest.h"
#include "librbd/journal/RemoveRequest.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/EnableRequest.h"
#include "journal/Journaler.h"
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish)
+ asio::ContextWQ *op_work_queue,
+ Context *on_finish)
: m_config(config), m_image_name(image_name), m_image_id(image_id),
m_size(size), m_create_flags(create_flags),
m_mirror_image_mode(mirror_image_mode),
tag_data.mirror_uuid = (use_primary_mirror_uuid ? m_primary_mirror_uuid :
librbd::Journal<I>::LOCAL_MIRROR_UUID);
+ typename journal::TypeTraits<I>::ContextWQ* context_wq;
+ Journal<>::get_work_queue(m_cct, &context_wq);
+
auto req = librbd::journal::CreateRequest<I>::create(
m_io_ctx, m_image_id, m_journal_order, m_journal_splay_width,
m_journal_pool, cls::journal::Tag::TAG_CLASS_NEW, tag_data,
- librbd::Journal<I>::IMAGE_CLIENT_ID, m_op_work_queue, ctx);
+ librbd::Journal<I>::IMAGE_CLIENT_ID, context_wq, ctx);
req->send();
}
Context *ctx = create_context_callback<klass, &klass::handle_journal_remove>(
this);
+ typename journal::TypeTraits<I>::ContextWQ* context_wq;
+ Journal<>::get_work_queue(m_cct, &context_wq);
+
librbd::journal::RemoveRequest<I> *req =
librbd::journal::RemoveRequest<I>::create(
- m_io_ctx, m_image_id, librbd::Journal<I>::IMAGE_CLIENT_ID, m_op_work_queue,
+ m_io_ctx, m_image_id, librbd::Journal<I>::IMAGE_CLIENT_ID, context_wq,
ctx);
req->send();
}
#include "librbd/ImageCtx.h"
class Context;
-class ContextWQ;
using librados::IoCtx;
namespace journal { class Journaler; }
namespace librbd {
+
+namespace asio { struct ContextWQ; }
+
namespace image {
template <typename ImageCtxT = ImageCtx>
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish) {
+ asio::ContextWQ *op_work_queue,
+ Context *on_finish) {
return new CreateRequest(config, ioctx, image_name, image_id, size,
image_options, create_flags,
mirror_image_mode, non_primary_global_image_id,
cls::rbd::MirrorImageMode mirror_image_mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue, Context *on_finish);
+ asio::ContextWQ *op_work_queue, Context *on_finish);
const ConfigProxy& m_config;
IoCtx m_io_ctx;
const std::string m_primary_mirror_uuid;
bool m_negotiate_features = false;
- ContextWQ *m_op_work_queue;
+ asio::ContextWQ *m_op_work_queue;
Context *m_on_finish;
CephContext *m_cct;
#include "librbd/image/DetachChildRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/DisabledPolicy.h"
#include "librbd/trash/RemoveRequest.h"
#include <string>
#include "librbd/image/DetachParentRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "include/rados/librados.hpp"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/image/CloseRequest.h"
#include "librbd/image/OpenRequest.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/image/DetachChildRequest.h"
#include "librbd/image/PreRemoveRequest.h"
#include "librbd/journal/RemoveRequest.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/DisableRequest.h"
#include "librbd/operation/TrimRequest.h"
Context *ctx = create_context_callback<
klass, &klass::handle_journal_remove>(this);
+ typename journal::TypeTraits<I>::ContextWQ* context_wq;
+ Journal<I>::get_work_queue(m_cct, &context_wq);
+
journal::RemoveRequest<I> *req = journal::RemoveRequest<I>::create(
- m_ioctx, m_image_id, Journal<>::IMAGE_CLIENT_ID, m_op_work_queue, ctx);
+ m_ioctx, m_image_id, Journal<>::IMAGE_CLIENT_ID, context_wq, ctx);
req->send();
}
#include <list>
class Context;
-class ContextWQ;
class SafeTimer;
namespace librbd {
#ifndef CEPH_LIBRBD_IMAGE_TYPE_TRAITS_H
#define CEPH_LIBRBD_IMAGE_TYPE_TRAITS_H
-class ContextWQ;
-
namespace librbd {
+
+namespace asio { struct ContextWQ; }
+
namespace image {
template <typename ImageCtxT>
struct TypeTraits {
- typedef ::ContextWQ ContextWQ;
+ typedef asio::ContextWQ ContextWQ;
};
} // namespace image
#include "include/ceph_assert.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
template <typename I>
ValidatePoolRequest<I>::ValidatePoolRequest(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
Context *on_finish)
: m_cct(reinterpret_cast<CephContext*>(io_ctx.cct())),
m_op_work_queue(op_work_queue), m_on_finish(on_finish) {
#include "include/buffer.h"
class Context;
-class ContextWQ;
namespace librbd {
struct ImageCtx;
+namespace asio { struct ContextWQ; }
namespace image {
class ValidatePoolRequest {
public:
static ValidatePoolRequest* create(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
Context *on_finish) {
return new ValidatePoolRequest(io_ctx, op_work_queue, on_finish);
}
- ValidatePoolRequest(librados::IoCtx& io_ctx, ContextWQ *op_work_queue,
+ ValidatePoolRequest(librados::IoCtx& io_ctx, asio::ContextWQ *op_work_queue,
Context *on_finish);
void send();
librados::IoCtx m_io_ctx;
CephContext* m_cct;
- ContextWQ* m_op_work_queue;
+ asio::ContextWQ* m_op_work_queue;
Context* m_on_finish;
int m_ret_val = 0;
lderr(cct) << "Forced V1 image creation. " << dendl;
r = create_v1(io_ctx, image_name.c_str(), size, order);
} else {
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
ConfigProxy config{cct->_conf};
ConfigProxy config{reinterpret_cast<CephContext *>(c_ioctx.cct())->_conf};
api::Config<>::apply_pool_overrides(c_ioctx, &config);
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
ImageCtx::get_work_queue(cct, &op_work_queue);
C_SaferCond cond;
#include "include/rbd/librbd.hpp"
#include "include/rbd_types.h"
#include "cls/rbd/cls_rbd_types.h"
-#include "common/WorkQueue.h"
#include "common/ceph_time.h"
#include "librbd/Types.h"
#include "common/dout.h"
#include "common/errno.h"
#include "common/perf_counters.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/internal.h"
#include "librbd/Journal.h"
#include "librbd/Types.h"
+#include "librbd/asio/ContextWQ.h"
#ifdef WITH_LTTNG
#include "tracing/librbd.h"
#include "librbd/io/AsyncOperation.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rbd
#include "common/ceph_mutex.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/AsyncObjectThrottle.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/deep_copy/ObjectCopyRequest.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageRequest.h"
#include "librbd/io/ImageDispatch.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageRequest.h"
#include "include/Context.h"
#include "common/AsyncOpTracker.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
#include "librbd/io/AsyncOperation.h"
#include "librbd/Journal.h"
#include "librbd/Types.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/cache/ImageCache.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/AsyncOperation.h"
#include "librbd/journal/Types.h"
#include "include/rados/librados.hpp"
#include "common/perf_counters.h"
-#include "common/WorkQueue.h"
#include "osdc/Striper.h"
#include <algorithm>
#include <functional>
#include "librbd/io/ObjectDispatch.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectRequest.h"
#define dout_subsys ceph_subsys_rbd
#include "include/Context.h"
#include "common/AsyncOpTracker.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatch.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include <boost/variant.hpp>
#include "common/dout.h"
#include "common/errno.h"
#include "common/ceph_mutex.h"
-#include "common/WorkQueue.h"
#include "include/Context.h"
#include "include/err.h"
#include "osd/osd_types.h"
#include "librbd/ImageCtx.h"
#include "librbd/ObjectMap.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/CopyupRequest.h"
#include "librbd/io/ImageRequest.h"
#include "librbd/io/QosImageDispatch.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/FlushTracker.h"
#include <map>
#include "librbd/io/QueueImageDispatch.h"
#include "common/dout.h"
#include "common/Cond.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageDispatchSpec.h"
#include "librbd/io/SimpleSchedulerObjectDispatch.h"
#include "common/Timer.h"
-#include "common/WorkQueue.h"
#include "common/errno.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcher.h"
#include "librbd/io/Utils.h"
#include "librbd/io/WriteBlockImageDispatch.h"
#include "common/dout.h"
#include "common/Cond.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageDispatchSpec.h"
#include "include/ceph_assert.h"
#include "librbd/Utils.h"
#include "common/Timer.h"
-#include "common/WorkQueue.h"
#include "journal/Settings.h"
#include "librbd/journal/CreateRequest.h"
#include "librbd/journal/RemoveRequest.h"
#include "librbd/journal/DemoteRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.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/journal/OpenRequest.h"
#define dout_subsys ceph_subsys_rbd
#include "librbd/journal/ObjectDispatch.h"
#include "common/dout.h"
-#include "common/WorkQueue.h"
#include "osdc/Striper.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/ObjectDispatchSpec.h"
#include "librbd/io/ObjectDispatcherInterface.h"
#include "librbd/journal/OpenRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "journal/Journaler.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/Types.h"
#include "librbd/journal/Utils.h"
#include "librbd/journal/PromoteRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.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/journal/OpenRequest.h"
#define dout_subsys ceph_subsys_rbd
#include "common/dout.h"
#include "common/errno.h"
#include "common/Timer.h"
-#include "common/WorkQueue.h"
#include "journal/Settings.h"
#include "include/ceph_assert.h"
#include "librbd/Utils.h"
#include "librbd/journal/Replay.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ExclusiveLock.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/internal.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/io/ImageRequest.h"
// vim: ts=8 sw=2 smarttab
#include "librbd/journal/StandardPolicy.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Journal.h"
+#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
#ifndef CEPH_LIBRBD_JOURNAL_TYPE_TRAITS_H
#define CEPH_LIBRBD_JOURNAL_TYPE_TRAITS_H
+struct ContextWQ;
+
namespace journal {
class Future;
class Journaler;
typedef ::journal::Journaler Journaler;
typedef ::journal::Future Future;
typedef ::journal::ReplayEntry ReplayEntry;
+ typedef ::ContextWQ ContextWQ;
};
} // namespace journal
#include "cls/lock/cls_lock_types.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "include/stringify.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/managed_lock/BreakRequest.h"
#include "librbd/managed_lock/GetLockerRequest.h"
#include "librbd/managed_lock/Utils.h"
template <typename I>
AcquireRequest<I>* AcquireRequest<I>::create(librados::IoCtx& ioctx,
Watcher *watcher,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
const string& oid,
const string& cookie,
bool exclusive,
template <typename I>
AcquireRequest<I>::AcquireRequest(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue, const string& oid,
+ asio::ContextWQ *work_queue,
+ const string& oid,
const string& cookie, bool exclusive,
bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds,
m_exclusive(exclusive),
m_blacklist_on_break_lock(blacklist_on_break_lock),
m_blacklist_expire_seconds(blacklist_expire_seconds),
- m_on_finish(new C_AsyncCallback<ContextWQ>(work_queue, on_finish)) {
+ m_on_finish(new C_AsyncCallback<asio::ContextWQ>(work_queue, on_finish)) {
}
template <typename I>
#include <string>
class Context;
-class ContextWQ;
namespace librbd {
class Watcher;
+namespace asio { struct ContextWQ; }
namespace managed_lock {
public:
static AcquireRequest* create(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue,
+ const std::string& oid,
const std::string& cookie,
bool exclusive,
bool blacklist_on_break_lock,
*/
AcquireRequest(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue, const std::string& oid,
const std::string& cookie, bool exclusive,
bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds, Context *on_finish);
librados::IoCtx& m_ioctx;
Watcher *m_watcher;
CephContext *m_cct;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
std::string m_oid;
std::string m_cookie;
bool m_exclusive;
#include "librbd/managed_lock/BreakRequest.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "include/stringify.h"
#include "cls/lock/cls_lock_client.h"
#include "cls/lock/cls_lock_types.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/managed_lock/GetLockerRequest.h"
#define dout_subsys ceph_subsys_rbd
} // anonymous namespace
template <typename I>
-BreakRequest<I>::BreakRequest(librados::IoCtx& ioctx, ContextWQ *work_queue,
+BreakRequest<I>::BreakRequest(librados::IoCtx& ioctx,
+ asio::ContextWQ *work_queue,
const std::string& oid, const Locker &locker,
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds,
class ImageCtx;
template <typename> class Journal;
+namespace asio { struct ContextWQ; }
namespace managed_lock {
template <typename ImageCtxT = ImageCtx>
class BreakRequest {
public:
- static BreakRequest* create(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ static BreakRequest* create(librados::IoCtx& ioctx,
+ asio::ContextWQ *work_queue,
const std::string& oid, const Locker &locker,
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds,
librados::IoCtx &m_ioctx;
CephContext *m_cct;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
std::string m_oid;
Locker m_locker;
bool m_exclusive;
Locker m_refreshed_locker;
- BreakRequest(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ BreakRequest(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid, const Locker &locker,
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds, bool force_break_lock,
// vim: ts=8 sw=2 smarttab
#include "librbd/managed_lock/ReleaseRequest.h"
-#include "librbd/Watcher.h"
#include "cls/lock/cls_lock_client.h"
#include "cls/lock/cls_lock_types.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "librbd/Utils.h"
-
#include "librbd/ImageCtx.h"
+#include "librbd/Utils.h"
+#include "librbd/Watcher.h"
+#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
template <typename I>
ReleaseRequest<I>* ReleaseRequest<I>::create(librados::IoCtx& ioctx,
Watcher *watcher,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
const string& oid,
const string& cookie,
Context *on_finish) {
template <typename I>
ReleaseRequest<I>::ReleaseRequest(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue, const string& oid,
- const string& cookie, Context *on_finish)
+ asio::ContextWQ *work_queue,
+ const string& oid, const string& cookie,
+ Context *on_finish)
: m_ioctx(ioctx), m_watcher(watcher), m_oid(oid), m_cookie(cookie),
- m_on_finish(new C_AsyncCallback<ContextWQ>(work_queue, on_finish)) {
+ m_on_finish(new C_AsyncCallback<asio::ContextWQ>(work_queue, on_finish)) {
}
template <typename I>
namespace librbd {
class Watcher;
+namespace asio { struct ContextWQ; }
namespace managed_lock {
public:
static ReleaseRequest* create(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
const std::string& oid,
const std::string& cookie,
Context *on_finish);
*/
ReleaseRequest(librados::IoCtx& ioctx, Watcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue, const std::string& oid,
const std::string& cookie, Context *on_finish);
librados::IoCtx& m_ioctx;
// vim: ts=8 sw=2 smarttab
#include "librbd/mirror/DisableRequest.h"
-#include "common/WorkQueue.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/journal/cls_journal_client.h"
#include "librbd/Journal.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/journal/PromoteRequest.h"
#include "librbd/mirror/GetInfoRequest.h"
#include "librbd/mirror/ImageRemoveRequest.h"
I* image_ctx,
cls::rbd::MirrorImageMode mode,
const std::string &non_primary_global_image_id,
- bool image_clean, ContextWQ *op_work_queue,
+ bool image_clean,
+ asio::ContextWQ *op_work_queue,
Context *on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id), m_image_ctx(image_ctx),
m_mode(mode), m_non_primary_global_image_id(non_primary_global_image_id),
#include <string>
class Context;
-class ContextWQ;
namespace librbd {
+
+namespace asio { struct ContextWQ; }
+
namespace mirror {
template <typename ImageCtxT = ImageCtx>
const std::string &image_id,
cls::rbd::MirrorImageMode mode,
const std::string &non_primary_global_image_id,
- bool image_clean, ContextWQ *op_work_queue,
+ bool image_clean, asio::ContextWQ *op_work_queue,
Context *on_finish) {
return new EnableRequest(io_ctx, image_id, nullptr, mode,
non_primary_global_image_id, image_clean,
EnableRequest(librados::IoCtx &io_ctx, const std::string &image_id,
ImageCtxT* image_ctx, cls::rbd::MirrorImageMode mode,
const std::string &non_primary_global_image_id,
- bool image_clean, ContextWQ *op_work_queue, Context *on_finish);
+ bool image_clean, asio::ContextWQ *op_work_queue,
+ Context *on_finish);
librados::IoCtx &m_io_ctx;
std::string m_image_id;
cls::rbd::MirrorImageMode m_mode;
std::string m_non_primary_global_image_id;
bool m_image_clean;
- ContextWQ *m_op_work_queue;
+ asio::ContextWQ *m_op_work_queue;
Context *m_on_finish;
CephContext *m_cct = nullptr;
template <typename I>
GetInfoRequest<I>::GetInfoRequest(librados::IoCtx& io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
cls::rbd::MirrorImage *mirror_image,
PromotionState *promotion_state,
#include "librbd/mirror/Types.h"
#include <string>
-class ContextWQ;
struct Context;
namespace cls { namespace rbd { struct MirrorImage; } }
namespace librbd {
struct ImageCtx;
+namespace asio { struct ContextWQ; }
namespace mirror {
class GetInfoRequest {
public:
static GetInfoRequest *create(librados::IoCtx &io_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
const std::string &image_id,
cls::rbd::MirrorImage *mirror_image,
PromotionState *promotion_state,
primary_mirror_uuid, on_finish);
}
- GetInfoRequest(librados::IoCtx& io_ctx, ContextWQ *op_work_queue,
+ GetInfoRequest(librados::IoCtx& io_ctx, asio::ContextWQ *op_work_queue,
const std::string &image_id,
cls::rbd::MirrorImage *mirror_image,
PromotionState *promotion_state,
ImageCtxT *m_image_ctx = nullptr;
librados::IoCtx &m_io_ctx;
- ContextWQ *m_op_work_queue;
+ asio::ContextWQ *m_op_work_queue;
std::string m_image_id;
cls::rbd::MirrorImage *m_mirror_image;
PromotionState *m_promotion_state;
#include "librbd/ImageState.h"
#include "librbd/Operations.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/image/ListWatchersRequest.h"
#include "librbd/mirror/snapshot/CreateNonPrimaryRequest.h"
#include "librbd/mirror/snapshot/CreatePrimaryRequest.h"
#include "include/buffer.h"
#include "include/rbd/librbd.hpp"
+#include "common/ceph_mutex.h"
#include "librbd/internal.h"
#include <string>
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/journal/RemoveRequest.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/DisableRequest.h"
#include "librbd/object_map/RemoveRequest.h"
DisableFeaturesRequest<I>,
&DisableFeaturesRequest<I>::handle_remove_journal>(this);
+ typename journal::TypeTraits<I>::ContextWQ* context_wq;
+ Journal<I>::get_work_queue(cct, &context_wq);
+
journal::RemoveRequest<I> *req = journal::RemoveRequest<I>::create(
image_ctx.md_ctx, image_ctx.id, librbd::Journal<>::IMAGE_CLIENT_ID,
- image_ctx.op_work_queue, ctx);
+ context_wq, ctx);
req->send();
}
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/ImageDispatcherInterface.h"
#include "librbd/journal/CreateRequest.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/EnableRequest.h"
#include "librbd/object_map/CreateRequest.h"
EnableFeaturesRequest<I>,
&EnableFeaturesRequest<I>::handle_create_journal>(this);
+ typename journal::TypeTraits<I>::ContextWQ* context_wq;
+ Journal<I>::get_work_queue(cct, &context_wq);
+
journal::CreateRequest<I> *req = journal::CreateRequest<I>::create(
image_ctx.md_ctx, image_ctx.id,
image_ctx.config.template get_val<uint64_t>("rbd_journal_order"),
image_ctx.config.template get_val<uint64_t>("rbd_journal_splay_width"),
image_ctx.config.template get_val<std::string>("rbd_journal_pool"),
cls::journal::Tag::TAG_CLASS_NEW, tag_data,
- librbd::Journal<>::IMAGE_CLIENT_ID, image_ctx.op_work_queue, ctx);
+ librbd::Journal<>::IMAGE_CLIENT_ID, context_wq, ctx);
req->send();
}
#include "librbd/operation/Request.h"
#include "common/dout.h"
#include "common/errno.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
+#include "librbd/asio/ContextWQ.h"
#define dout_subsys ceph_subsys_rbd
#undef dout_prefix
// vim: ts=8 sw=2 smarttab
#include "librbd/trash/RemoveRequest.h"
-#include "common/WorkQueue.h"
#include "common/dout.h"
#include "common/errno.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/ImageCtx.h"
#include "librbd/ImageState.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/image/RemoveRequest.h"
#define dout_subsys ceph_subsys_rbd
#include <string>
class Context;
-class ContextWQ;
namespace librbd {
-class ProgressContext;
-
struct ImageCtx;
+class ProgressContext;
+namespace asio { struct ContextWQ; }
namespace trash {
public:
static RemoveRequest* create(librados::IoCtx &io_ctx,
const std::string &image_id,
- ContextWQ *op_work_queue, bool force,
+ asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish) {
return new RemoveRequest(io_ctx, image_id, op_work_queue, force, prog_ctx,
on_finish);
}
static RemoveRequest* create(librados::IoCtx &io_ctx, ImageCtxT *image_ctx,
- ContextWQ *op_work_queue, bool force,
+ asio::ContextWQ *op_work_queue, bool force,
ProgressContext &prog_ctx, Context *on_finish) {
return new RemoveRequest(io_ctx, image_ctx, op_work_queue, force, prog_ctx,
on_finish);
RemoveRequest(librados::IoCtx &io_ctx, const std::string &image_id,
- ContextWQ *op_work_queue, bool force, ProgressContext &prog_ctx,
- Context *on_finish)
+ asio::ContextWQ *op_work_queue, bool force,
+ ProgressContext &prog_ctx, Context *on_finish)
: m_io_ctx(io_ctx), m_image_id(image_id), m_op_work_queue(op_work_queue),
m_force(force), m_prog_ctx(prog_ctx), m_on_finish(on_finish),
m_cct(reinterpret_cast<CephContext *>(io_ctx.cct())) {
}
RemoveRequest(librados::IoCtx &io_ctx, ImageCtxT *image_ctx,
- ContextWQ *op_work_queue, bool force, ProgressContext &prog_ctx,
- Context *on_finish)
+ asio::ContextWQ *op_work_queue, bool force,
+ ProgressContext &prog_ctx, Context *on_finish)
: m_io_ctx(io_ctx), m_image_ctx(image_ctx), m_image_id(m_image_ctx->id),
m_op_work_queue(op_work_queue), m_force(force), m_prog_ctx(prog_ctx),
m_on_finish(on_finish),
librados::IoCtx &m_io_ctx;
ImageCtxT *m_image_ctx = nullptr;
std::string m_image_id;
- ContextWQ *m_op_work_queue;
+ asio::ContextWQ *m_op_work_queue;
bool m_force;
ProgressContext &m_prog_ctx;
Context *m_on_finish;
// vim: ts=8 sw=2 smarttab
#include "librbd/watcher/Notifier.h"
-#include "common/WorkQueue.h"
#include "librbd/ImageCtx.h"
#include "librbd/Utils.h"
+#include "librbd/asio/ContextWQ.h"
#include "librbd/watcher/Types.h"
#define dout_subsys ceph_subsys_rbd
notifier->handle_notify(r, on_finish);
}
-Notifier::Notifier(ContextWQ *work_queue, IoCtx &ioctx, const std::string &oid)
+Notifier::Notifier(asio::ContextWQ *work_queue, IoCtx &ioctx,
+ const std::string &oid)
: m_work_queue(work_queue), m_ioctx(ioctx), m_oid(oid),
m_aio_notify_lock(ceph::make_mutex(util::unique_lock_name(
"librbd::object_watcher::Notifier::m_aio_notify_lock", this))) {
#include "include/Context.h"
#include "include/rados/librados.hpp"
#include "common/ceph_mutex.h"
-#include "common/WorkQueue.h"
#include <list>
namespace librbd {
+namespace asio { struct ContextWQ; }
+
namespace watcher {
struct NotifyResponse;
public:
static const uint64_t NOTIFY_TIMEOUT;
- Notifier(ContextWQ *work_queue, librados::IoCtx &ioctx,
+ Notifier(asio::ContextWQ *work_queue, librados::IoCtx &ioctx,
const std::string &oid);
~Notifier();
void finish(int r) override;
};
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
librados::IoCtx &m_ioctx;
CephContext *m_cct;
std::string m_oid;
librbd::ImageCtx *m_src_image_ctx;
librbd::ImageCtx *m_dst_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
librbd::SnapSeqs m_snap_seqs;
SnapMap m_snap_map;
librbd::ImageCtx *m_src_image_ctx;
librbd::ImageCtx *m_dst_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
void SetUp() override {
TestMockFixture::SetUp();
librbd::ImageCtx *m_src_image_ctx;
librbd::ImageCtx *m_dst_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
SnapMap m_snap_map;
std::vector<librados::snap_t> m_src_snap_ids;
typedef image::DetachParentRequest<MockTestImageCtx> MockDetachParentRequest;
librbd::ImageCtx *m_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
void SetUp() override {
TestMockFixture::SetUp();
librbd::ImageCtx *m_src_image_ctx;
librbd::ImageCtx *m_dst_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
librbd::SnapSeqs m_snap_seqs;
typedef SnapshotCreateRequest<librbd::MockTestImageCtx> MockSnapshotCreateRequest;
librbd::ImageCtx *m_image_ctx;
- ContextWQ *m_work_queue;
+ asio::ContextWQ *m_work_queue;
void SetUp() override {
TestMockFixture::SetUp();
cls::rbd::MirrorImageMode mode,
const std::string &non_primary_global_image_id,
const std::string &primary_mirror_uuid,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
Context *on_finish) {
ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
const std::string &image_id,
bool force, bool from_trash_remove,
ProgressContext &prog_ctx,
- ContextWQ *op_work_queue,
+ asio::ContextWQ *op_work_queue,
Context *on_finish) {
ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
#include "librbd/image/PreRemoveRequest.h"
#include "librbd/image/RemoveRequest.h"
#include "librbd/journal/RemoveRequest.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/mirror/DisableRequest.h"
#include "librbd/operation/TrimRequest.h"
#include "gmock/gmock.h"
} // anonymous namespace
+template<>
+struct Journal<MockTestImageCtx> {
+ static void get_work_queue(CephContext*, MockContextWQ**) {
+ }
+};
+
namespace image {
template <>
} // namespace image
+namespace journal {
+
+template <>
+struct TypeTraits<MockTestImageCtx> {
+ typedef librbd::MockContextWQ ContextWQ;
+};
+
+} // namespace journal
+
namespace operation {
template <>
void expect_init_journaler(::journal::MockJournaler &mock_journaler, int r) {
EXPECT_CALL(mock_journaler, init(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_get_journaler_cached_client(::journal::MockJournaler &mock_journaler,
EXPECT_CALL(mock_journaler, allocate_tag(456, ContentsEqual(tag_data_bl),
_, _))
- .WillOnce(WithArg<3>(CompleteContext(r, static_cast<ContextWQ*>(NULL))));
+ .WillOnce(WithArg<3>(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL))));
}
void expect_append_journaler(::journal::MockJournaler &mock_journaler) {
void expect_future_flush(::journal::MockFuture &mock_future, int r) {
EXPECT_CALL(mock_future, flush(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_future_committed(::journal::MockJournaler &mock_journaler) {
void expect_flush_commit_position(::journal::MockJournaler &mock_journaler,
int r) {
EXPECT_CALL(mock_journaler, flush_commit_position(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_start_append(::journal::MockJournaler &mock_journaler) {
void expect_stop_append(::journal::MockJournaler &mock_journaler, int r) {
EXPECT_CALL(mock_journaler, stop_append(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_shut_down_journaler(::journal::MockJournaler &mock_journaler,
int r) {
EXPECT_CALL(mock_journaler, shut_down(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
};
MockCreateRequest mock_create_request;
expect_create(mock_create_request, 0);
+ ContextWQ* context_wq;
+ Journal<>::get_work_queue(ictx->cct, &context_wq);
+
C_SaferCond ctx;
auto req = MockResetRequest::create(m_ioctx, "image id",
Journal<>::IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- ictx->op_work_queue , &ctx);
+ context_wq, &ctx);
req->send();
ASSERT_EQ(0, ctx.wait());
}
expect_init_journaler(mock_journaler, -EINVAL);
expect_shut_down_journaler(mock_journaler, 0);
+ ContextWQ* context_wq;
+ Journal<>::get_work_queue(ictx->cct, &context_wq);
+
C_SaferCond ctx;
auto req = MockResetRequest::create(m_ioctx, "image id",
Journal<>::IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- ictx->op_work_queue , &ctx);
+ context_wq, &ctx);
req->send();
ASSERT_EQ(-EINVAL, ctx.wait());
}
expect_get_metadata(mock_journaler);
expect_shut_down_journaler(mock_journaler, -EINVAL);
+ ContextWQ* context_wq;
+ Journal<>::get_work_queue(ictx->cct, &context_wq);
+
C_SaferCond ctx;
auto req = MockResetRequest::create(m_ioctx, "image id",
Journal<>::IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- ictx->op_work_queue , &ctx);
+ context_wq, &ctx);
req->send();
ASSERT_EQ(-EINVAL, ctx.wait());
}
MockRemoveRequest mock_remove_request;
expect_remove(mock_remove_request, -EINVAL);
+ ContextWQ* context_wq;
+ Journal<>::get_work_queue(ictx->cct, &context_wq);
+
C_SaferCond ctx;
auto req = MockResetRequest::create(m_ioctx, "image id",
Journal<>::IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- ictx->op_work_queue , &ctx);
+ context_wq, &ctx);
req->send();
ASSERT_EQ(-EINVAL, ctx.wait());
}
MockCreateRequest mock_create_request;
expect_create(mock_create_request, -EINVAL);
+ ContextWQ* context_wq;
+ Journal<>::get_work_queue(ictx->cct, &context_wq);
+
C_SaferCond ctx;
auto req = MockResetRequest::create(m_ioctx, "image id",
Journal<>::IMAGE_CLIENT_ID,
Journal<>::LOCAL_MIRROR_UUID,
- ictx->op_work_queue , &ctx);
+ context_wq, &ctx);
req->send();
ASSERT_EQ(-EINVAL, ctx.wait());
}
struct BreakRequest<librbd::MockImageCtx> {
Context *on_finish = nullptr;
static BreakRequest *s_instance;
- static BreakRequest* create(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ static BreakRequest* create(librados::IoCtx& ioctx,
+ asio::ContextWQ *work_queue,
const std::string& oid, const Locker &locker,
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds,
#include "test/librbd/mock/MockJournalPolicy.h"
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/internal.h"
+#include "librbd/Journal.h"
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/mirror/DisableRequest.h"
#include "librbd/journal/RemoveRequest.h"
#include "librbd/journal/StandardPolicy.h"
#include "librbd/journal/Types.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/object_map/RemoveRequest.h"
#include "librbd/operation/DisableFeaturesRequest.h"
#include "gmock/gmock.h"
} // anonymous namespace
+template<>
+struct Journal<MockOperationImageCtx> {
+ static void get_work_queue(CephContext*, MockContextWQ**) {
+ }
+};
+
namespace image {
template<>
}
};
+template <>
+struct TypeTraits<MockOperationImageCtx> {
+ typedef librbd::MockContextWQ ContextWQ;
+};
+
} // namespace journal
namespace mirror {
#include "cls/rbd/cls_rbd_client.h"
#include "librbd/Operations.h"
#include "librbd/internal.h"
+#include "librbd/Journal.h"
#include "librbd/image/SetFlagsRequest.h"
#include "librbd/io/AioCompletion.h"
#include "librbd/mirror/EnableRequest.h"
#include "librbd/journal/CreateRequest.h"
#include "librbd/journal/Types.h"
+#include "librbd/journal/TypeTraits.h"
#include "librbd/object_map/CreateRequest.h"
#include "librbd/operation/EnableFeaturesRequest.h"
#include "gmock/gmock.h"
} // anonymous namespace
+template<>
+struct Journal<MockOperationImageCtx> {
+ static void get_work_queue(CephContext*, MockContextWQ**) {
+ }
+};
+
namespace image {
template<>
CreateRequest<MockOperationImageCtx> *CreateRequest<MockOperationImageCtx>::s_instance = nullptr;
+template <>
+struct TypeTraits<MockOperationImageCtx> {
+ typedef librbd::MockContextWQ ContextWQ;
+};
+
} // namespace journal
namespace mirror {
librados::snap_t src_snap_id_start,
librados::snap_t src_snap_id_end,
librados::snap_t dst_snap_id_start,
- bool flatten, ContextWQ *work_queue,
+ bool flatten,
+ librbd::asio::ContextWQ *work_queue,
SnapSeqs *snap_seqs, Context *on_finish) {
ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
librbd::ImageCtx *m_src_image_ctx;
librbd::ImageCtx *m_dst_image_ctx;
- ContextWQ *m_work_queue;
+ librbd::asio::ContextWQ *m_work_queue;
void SetUp() override {
TestMockFixture::SetUp();
namespace {
struct MockExclusiveLockImageCtx : public MockImageCtx {
- ContextWQ *op_work_queue;
+ asio::ContextWQ *op_work_queue;
MockExclusiveLockImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) {
op_work_queue = image_ctx.op_work_queue;
template <>
struct ManagedLock<MockExclusiveLockImageCtx> {
- ManagedLock(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ ManagedLock(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid, librbd::MockImageWatcher *watcher,
managed_lock::Mode mode, bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds)
void expect_shut_down(MockManagedLock *managed_lock) {
EXPECT_CALL(*managed_lock, shut_down(_))
- .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(nullptr)));
+ .WillOnce(CompleteContext(0, static_cast<asio::ContextWQ*>(nullptr)));
}
void expect_accept_blocked_request(
#include "test/librbd/mock/io/MockObjectDispatch.h"
#include "common/Cond.h"
#include "common/ceph_mutex.h"
+#include "common/WorkQueue.h"
#include "cls/journal/cls_journal_types.h"
#include "journal/Journaler.h"
#include "librbd/Journal.h"
void expect_shut_down_journaler(::journal::MockJournaler &mock_journaler) {
EXPECT_CALL(mock_journaler, remove_listener(_));
EXPECT_CALL(mock_journaler, shut_down(_))
- .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(0, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_register_dispatch(MockImageCtx& mock_image_ctx,
void expect_stop_replay(::journal::MockJournaler &mock_journaler) {
EXPECT_CALL(mock_journaler, stop_replay(_))
- .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(0, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_shut_down_replay(MockJournalImageCtx &mock_image_ctx,
EXPECT_CALL(mock_journal_replay, decode(_, _))
.WillOnce(Return(0));
EXPECT_CALL(mock_journal_replay, process(_, _, _))
- .WillOnce(DoAll(WithArg<1>(CompleteContext(0, static_cast<ContextWQ*>(NULL))),
+ .WillOnce(DoAll(WithArg<1>(CompleteContext(0, static_cast<asio::ContextWQ*>(NULL))),
WithArg<2>(Invoke(this, &TestMockJournal::save_commit_context))));
}
void expect_stop_append(::journal::MockJournaler &mock_journaler, int r) {
EXPECT_CALL(mock_journaler, stop_append(_))
- .WillOnce(CompleteContext(r, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(r, static_cast<asio::ContextWQ*>(NULL)));
}
void expect_committed(::journal::MockJournaler &mock_journaler,
void expect_flush_commit_position(::journal::MockJournaler &mock_journaler) {
EXPECT_CALL(mock_journaler, flush_commit_position(_))
- .WillOnce(CompleteContext(0, static_cast<ContextWQ*>(NULL)));
+ .WillOnce(CompleteContext(0, static_cast<asio::ContextWQ*>(NULL)));
}
int when_open(MockJournal *mock_journal) {
}
struct MockMockManagedLock : public ManagedLock<MockManagedLockImageCtx> {
- MockMockManagedLock(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ MockMockManagedLock(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid, librbd::MockImageWatcher *watcher,
managed_lock::Mode mode, bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds)
Context *on_finish = nullptr;
static T* create(librados::IoCtx& ioctx, MockImageWatcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue, const std::string& oid,
const std::string& cookie, Context *on_finish) {
ceph_assert(!s_requests.empty());
T* req = s_requests.front();
struct AcquireRequest<MockManagedLockImageCtx> : public BaseRequest<AcquireRequest<MockManagedLockImageCtx> > {
static AcquireRequest* create(librados::IoCtx& ioctx,
MockImageWatcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue,
+ const std::string& oid,
const std::string& cookie,
bool exclusive, bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds,
template <>
struct ReleaseRequest<MockManagedLockImageCtx> : public BaseRequest<ReleaseRequest<MockManagedLockImageCtx> > {
static ReleaseRequest* create(librados::IoCtx& ioctx, MockImageWatcher *watcher,
- ContextWQ *work_queue, const std::string& oid,
+ asio::ContextWQ *work_queue,
+ const std::string& oid,
const std::string& cookie, Context *on_finish) {
return BaseRequest::create(ioctx, watcher, work_queue, oid, cookie,
on_finish);
template <>
struct BreakRequest<MockManagedLockImageCtx> {
- static BreakRequest* create(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ static BreakRequest* create(librados::IoCtx& ioctx,
+ asio::ContextWQ *work_queue,
const std::string& oid, const Locker &locker,
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds,
}
void expect_acquire_lock(MockImageWatcher &watcher,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
MockAcquireRequest &acquire_request, int r) {
expect_get_watch_handle(watcher);
EXPECT_CALL(acquire_request, send())
.WillOnce(QueueRequest(&acquire_request, r, work_queue));
}
- void expect_release_lock(ContextWQ *work_queue,
+ void expect_release_lock(asio::ContextWQ *work_queue,
MockReleaseRequest &release_request, int r) {
EXPECT_CALL(release_request, send())
.WillOnce(QueueRequest(&release_request, r, work_queue));
}
void expect_reacquire_lock(MockImageWatcher& watcher,
- ContextWQ *work_queue,
+ asio::ContextWQ *work_queue,
MockReacquireRequest &mock_reacquire_request,
int r) {
EXPECT_CALL(mock_reacquire_request, send())
void expect_flush_notifies(MockImageWatcher *mock_watcher) {
EXPECT_CALL(*mock_watcher, flush(_))
- .WillOnce(CompleteContext(0, (ContextWQ *)nullptr));
+ .WillOnce(CompleteContext(0, (asio::ContextWQ *)nullptr));
}
void expect_post_reacquired_lock_handler(MockImageWatcher& watcher,
struct MockWatcher : public Watcher {
std::string oid;
- MockWatcher(librados::IoCtx& ioctx, ContextWQ *work_queue,
+ MockWatcher(librados::IoCtx& ioctx, asio::ContextWQ *work_queue,
const std::string& oid)
: Watcher(ioctx, work_queue, oid) {
}
#include "test/librbd/test_fixture.h"
#include "test/librbd/mock/MockImageCtx.h"
#include "test/librados_test_stub/LibradosTestStub.h"
-#include "common/WorkQueue.h"
+#include "librbd/asio/ContextWQ.h"
#include <boost/shared_ptr.hpp>
#include <gmock/gmock.h>
}
ACTION_P2(CompleteContext, r, wq) {
- ContextWQ *context_wq = reinterpret_cast<ContextWQ *>(wq);
+ librbd::asio::ContextWQ *context_wq = reinterpret_cast<
+ librbd::asio::ContextWQ *>(wq);
if (context_wq != NULL) {
context_wq->queue(arg0, r);
} else {
projects / ceph.git / commitdiff