#include <atomic>
-struct RefCountedObject {
+/* This class provides mechanisms to make a sub-class work with
+ * boost::intrusive_ptr (aka ceph::ref_t).
+ *
+ * Generally, you'll want to inherit from RefCountedObjectSafe and not from
+ * RefCountedObject directly. This is because the ::get and ::put methods are
+ * public and can be used to create/delete references outside of the
+ * ceph::ref_t pointers with the potential to leak memory.
+ *
+ * It is also suggested that you make constructors and destructors private in
+ * your final class. This prevents instantiation of the object with assignment
+ * to a raw pointer. Consequently, you'll want to use ceph::make_ref<> to
+ * create a ceph::ref_t<> holding your object:
+ *
+ * auto ptr = ceph::make_ref<Foo>(...);
+ *
+ * Use FRIEND_MAKE_REF(ClassName) to allow ceph::make_ref to call the private
+ * constructors.
+ *
+ */
+
+class RefCountedObject {
public:
void set_cct(class CephContext *c) {
cct = c;
RefCountedObject& operator=(const RefCountedObject& o) = delete;
RefCountedObject(RefCountedObject&&) = delete;
RefCountedObject& operator=(RefCountedObject&&) = delete;
- RefCountedObject(class CephContext* c = nullptr, int n = 1) : cct(c), nref(n) {}
+ RefCountedObject(class CephContext* c) : cct(c) {}
virtual ~RefCountedObject();
class CephContext *cct{nullptr};
};
+class RefCountedObjectSafe : public RefCountedObject {
+public:
+ RefCountedObject *get() = delete;
+ const RefCountedObject *get() const = delete;
+ void put() const = delete;
+protected:
+template<typename... Args>
+ RefCountedObjectSafe(Args&&... args) : RefCountedObject(std::forward<Args>(args)...) {}
+ virtual ~RefCountedObjectSafe() override {}
+};
+
#ifndef WITH_SEASTAR
/**
namespace journal {
+Future::Future() = default;
+Future::Future(const Future& o) = default;
+Future& Future::operator=(const Future& o) = default;
+Future::Future(Future&& o) = default;
+Future& Future::operator=(Future&& o) = default;
+Future::Future(ceph::ref_t<FutureImpl> future_impl) : m_future_impl(std::move(future_impl)) {}
+Future::~Future() = default;
+
void Future::flush(Context *on_safe) {
m_future_impl->flush(on_safe);
}
return m_future_impl->get_return_value();
}
-void intrusive_ptr_add_ref(FutureImpl *p) {
- p->get();
-}
-
-void intrusive_ptr_release(FutureImpl *p) {
- p->put();
-}
-
std::ostream &operator<<(std::ostream &os, const Future &future) {
- return os << *future.m_future_impl.get();
+ return os << *future.m_future_impl;
}
} // namespace journal
#ifndef CEPH_JOURNAL_FUTURE_H
#define CEPH_JOURNAL_FUTURE_H
-#include "include/int_types.h"
-#include <string>
#include <iosfwd>
-#include <boost/intrusive_ptr.hpp>
+#include <string>
+
#include "include/ceph_assert.h"
+#include "include/int_types.h"
+#include "common/ref.h"
class Context;
class Future {
public:
- typedef boost::intrusive_ptr<FutureImpl> FutureImplPtr;
-
- Future() {}
- Future(const FutureImplPtr &future_impl) : m_future_impl(future_impl) {}
-
- inline bool is_valid() const {
- return m_future_impl.get() != nullptr;
+ Future();
+ Future(const Future&);
+ Future& operator=(const Future&);
+ Future(Future&&);
+ Future& operator=(Future&&);
+ Future(ceph::ref_t<FutureImpl> future_impl);
+ ~Future();
+
+ bool is_valid() const {
+ return bool(m_future_impl);
}
void flush(Context *on_safe);
friend class Journaler;
friend std::ostream& operator<<(std::ostream&, const Future&);
- inline FutureImplPtr get_future_impl() const {
+ const auto& get_future_impl() const {
return m_future_impl;
}
- FutureImplPtr m_future_impl;
+ ceph::ref_t<FutureImpl> m_future_impl;
};
-void intrusive_ptr_add_ref(FutureImpl *p);
-void intrusive_ptr_release(FutureImpl *p);
-
std::ostream &operator<<(std::ostream &os, const Future &future);
} // namespace journal
-using journal::intrusive_ptr_add_ref;
-using journal::intrusive_ptr_release;
using journal::operator<<;
#endif // CEPH_JOURNAL_FUTURE_H
FutureImpl::FutureImpl(uint64_t tag_tid, uint64_t entry_tid,
uint64_t commit_tid)
- : RefCountedObject(NULL, 0), m_tag_tid(tag_tid), m_entry_tid(entry_tid),
+ : m_tag_tid(tag_tid),
+ m_entry_tid(entry_tid),
m_commit_tid(commit_tid),
- m_safe(false),
- m_consistent(false), m_return_value(0), m_flush_state(FLUSH_STATE_NONE),
- m_consistent_ack(this) {
+ m_consistent_ack(this)
+{
}
-void FutureImpl::init(const FutureImplPtr &prev_future) {
+void FutureImpl::init(const ceph::ref_t<FutureImpl> &prev_future) {
// chain ourself to the prior future (if any) to that we known when the
// journal is consistent
if (prev_future) {
bool complete;
FlushHandlers flush_handlers;
- FutureImplPtr prev_future;
+ ceph::ref_t<FutureImpl> prev_future;
{
std::lock_guard locker{m_lock};
complete = (m_safe && m_consistent);
}
}
-FutureImplPtr FutureImpl::prepare_flush(FlushHandlers *flush_handlers) {
+ceph::ref_t<FutureImpl> FutureImpl::prepare_flush(FlushHandlers *flush_handlers) {
std::lock_guard locker{m_lock};
return prepare_flush(flush_handlers, m_lock);
}
-FutureImplPtr FutureImpl::prepare_flush(FlushHandlers *flush_handlers,
+ceph::ref_t<FutureImpl> FutureImpl::prepare_flush(FlushHandlers *flush_handlers,
ceph::mutex &lock) {
ceph_assert(ceph_mutex_is_locked(m_lock));
if (m_flush_state == FLUSH_STATE_NONE) {
m_flush_state = FLUSH_STATE_REQUESTED;
- if (m_flush_handler && flush_handlers->count(m_flush_handler) == 0) {
- flush_handlers->insert({m_flush_handler, this});
+ auto h = m_flush_handler;
+ if (h) {
+ flush_handlers->try_emplace(std::move(h), this);
}
}
return m_prev_future;
return m_return_value;
}
-bool FutureImpl::attach(const FlushHandlerPtr &flush_handler) {
+bool FutureImpl::attach(FlushHandler::ref flush_handler) {
std::lock_guard locker{m_lock};
ceph_assert(!m_flush_handler);
- m_flush_handler = flush_handler;
+ m_flush_handler = std::move(flush_handler);
return m_flush_state != FLUSH_STATE_NONE;
}
return os;
}
-void intrusive_ptr_add_ref(FutureImpl::FlushHandler *p) {
- p->get();
-}
-
-void intrusive_ptr_release(FutureImpl::FlushHandler *p) {
- p->put();
-}
-
} // namespace journal
#include <list>
#include <map>
#include <boost/noncopyable.hpp>
-#include <boost/intrusive_ptr.hpp>
#include "include/ceph_assert.h"
class Context;
namespace journal {
-class FutureImpl;
-typedef boost::intrusive_ptr<FutureImpl> FutureImplPtr;
-
class FutureImpl : public RefCountedObject, boost::noncopyable {
public:
struct FlushHandler {
- virtual ~FlushHandler() {}
- virtual void flush(const FutureImplPtr &future) = 0;
- virtual void get() = 0;
- virtual void put() = 0;
+ using ref = std::shared_ptr<FlushHandler>;
+ virtual void flush(const ceph::ref_t<FutureImpl> &future) = 0;
+ virtual ~FlushHandler() = default;
};
- typedef boost::intrusive_ptr<FlushHandler> FlushHandlerPtr;
-
- FutureImpl(uint64_t tag_tid, uint64_t entry_tid, uint64_t commit_tid);
- void init(const FutureImplPtr &prev_future);
+ void init(const ceph::ref_t<FutureImpl> &prev_future);
inline uint64_t get_tag_tid() const {
return m_tag_tid;
return (m_flush_state == FLUSH_STATE_IN_PROGRESS);
}
inline void set_flush_in_progress() {
+ auto h = std::move(m_flush_handler);
+ ceph_assert(h);
std::lock_guard locker{m_lock};
- ceph_assert(m_flush_handler);
- m_flush_handler.reset();
m_flush_state = FLUSH_STATE_IN_PROGRESS;
}
- bool attach(const FlushHandlerPtr &flush_handler);
+ bool attach(FlushHandler::ref flush_handler);
inline void detach() {
- std::lock_guard locker{m_lock};
m_flush_handler.reset();
}
- inline FlushHandlerPtr get_flush_handler() const {
- std::lock_guard locker{m_lock};
+ inline FlushHandler::ref get_flush_handler() const {
return m_flush_handler;
}
private:
friend std::ostream &operator<<(std::ostream &, const FutureImpl &);
- typedef std::map<FlushHandlerPtr, FutureImplPtr> FlushHandlers;
+ typedef std::map<FlushHandler::ref, ceph::ref_t<FutureImpl>> FlushHandlers;
typedef std::list<Context *> Contexts;
enum FlushState {
};
struct C_ConsistentAck : public Context {
- FutureImplPtr future;
- C_ConsistentAck(FutureImpl *_future) : future(_future) {}
+ ceph::ref_t<FutureImpl> future;
+ C_ConsistentAck(ceph::ref_t<FutureImpl> _future) : future(std::move(_future)) {}
void complete(int r) override {
future->consistent(r);
future.reset();
void finish(int r) override {}
};
+ FRIEND_MAKE_REF(FutureImpl);
+ FutureImpl(uint64_t tag_tid, uint64_t entry_tid, uint64_t commit_tid);
+ ~FutureImpl() override = default;
+
uint64_t m_tag_tid;
uint64_t m_entry_tid;
uint64_t m_commit_tid;
mutable ceph::mutex m_lock = ceph::make_mutex("FutureImpl::m_lock", false);
- FutureImplPtr m_prev_future;
- bool m_safe;
- bool m_consistent;
- int m_return_value;
+ ceph::ref_t<FutureImpl> m_prev_future;
+ bool m_safe = false;
+ bool m_consistent = false;
+ int m_return_value = 0;
- FlushHandlerPtr m_flush_handler;
- FlushState m_flush_state;
+ FlushHandler::ref m_flush_handler;
+ FlushState m_flush_state = FLUSH_STATE_NONE;
C_ConsistentAck m_consistent_ack;
Contexts m_contexts;
- FutureImplPtr prepare_flush(FlushHandlers *flush_handlers);
- FutureImplPtr prepare_flush(FlushHandlers *flush_handlers, ceph::mutex &lock);
+ ceph::ref_t<FutureImpl> prepare_flush(FlushHandlers *flush_handlers);
+ ceph::ref_t<FutureImpl> prepare_flush(FlushHandlers *flush_handlers, ceph::mutex &lock);
void consistent(int r);
void finish_unlock();
};
-void intrusive_ptr_add_ref(FutureImpl::FlushHandler *p);
-void intrusive_ptr_release(FutureImpl::FlushHandler *p);
-
std::ostream &operator<<(std::ostream &os, const FutureImpl &future);
} // namespace journal
const std::string &oid,
const std::string &client_id,
const Settings &settings)
- : RefCountedObject(NULL, 0), m_cct(NULL), m_oid(oid),
- m_client_id(client_id), m_settings(settings), m_order(0),
- m_splay_width(0), m_pool_id(-1), m_initialized(false),
+ : m_oid(oid),
+ m_client_id(client_id), m_settings(settings),
m_work_queue(work_queue), m_timer(timer), m_timer_lock(timer_lock),
- m_commit_tid(0), m_watch_ctx(this),
- m_watch_handle(0), m_minimum_set(0), m_active_set(0),
- m_update_notifications(0), m_commit_position_ctx(NULL),
- m_commit_position_task_ctx(NULL) {
+ m_watch_ctx(this)
+{
m_ioctx.dup(ioctx);
m_cct = reinterpret_cast<CephContext*>(m_ioctx.cct());
}
#include "cls/journal/cls_journal_types.h"
#include "journal/JournalMetadataListener.h"
#include "journal/Settings.h"
-#include <boost/intrusive_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <functional>
namespace journal {
-class JournalMetadata;
-typedef boost::intrusive_ptr<JournalMetadata> JournalMetadataPtr;
-
class JournalMetadata : public RefCountedObject, boost::noncopyable {
public:
typedef std::function<Context*()> CreateContext;
typedef std::set<Client> RegisteredClients;
typedef std::list<Tag> Tags;
- JournalMetadata(ContextWQ *work_queue, SafeTimer *timer, ceph::mutex *timer_lock,
- librados::IoCtx &ioctx, const std::string &oid,
- const std::string &client_id, const Settings &settings);
- ~JournalMetadata() override;
-
void init(Context *on_init);
void shut_down(Context *on_finish);
void wait_for_ops();
private:
+ FRIEND_MAKE_REF(JournalMetadata);
+ JournalMetadata(ContextWQ *work_queue, SafeTimer *timer, ceph::mutex *timer_lock,
+ librados::IoCtx &ioctx, const std::string &oid,
+ const std::string &client_id, const Settings &settings);
+ ~JournalMetadata() override;
+
typedef std::map<uint64_t, uint64_t> AllocatedEntryTids;
typedef std::list<JournalMetadataListener*> Listeners;
typedef std::list<Context*> Contexts;
};
librados::IoCtx m_ioctx;
- CephContext *m_cct;
+ CephContext *m_cct = nullptr;
std::string m_oid;
std::string m_client_id;
Settings m_settings;
- uint8_t m_order;
- uint8_t m_splay_width;
- int64_t m_pool_id;
- bool m_initialized;
+ uint8_t m_order = 0;
+ uint8_t m_splay_width = 0;
+ int64_t m_pool_id = -1;
+ bool m_initialized = false;
ContextWQ *m_work_queue;
SafeTimer *m_timer;
mutable ceph::mutex m_lock = ceph::make_mutex("JournalMetadata::m_lock");
- uint64_t m_commit_tid;
+ uint64_t m_commit_tid = 0;
CommitTids m_pending_commit_tids;
Listeners m_listeners;
C_WatchCtx m_watch_ctx;
- uint64_t m_watch_handle;
+ uint64_t m_watch_handle = 0;
- uint64_t m_minimum_set;
- uint64_t m_active_set;
+ uint64_t m_minimum_set = 0;
+ uint64_t m_active_set = 0;
RegisteredClients m_registered_clients;
Client m_client;
AllocatedEntryTids m_allocated_entry_tids;
- size_t m_update_notifications;
+ size_t m_update_notifications = 0;
ceph::condition_variable m_update_cond;
size_t m_ignore_watch_notifies = 0;
uint64_t m_commit_position_tid = 0;
ObjectSetPosition m_commit_position;
- Context *m_commit_position_ctx;
- Context *m_commit_position_task_ctx;
+ Context *m_commit_position_ctx = nullptr;
+ Context *m_commit_position_task_ctx = nullptr;
size_t m_flush_commits_in_progress = 0;
Contexts m_flush_commit_position_ctxs;
static const uint64_t MIN_FETCH_BYTES = 32768;
struct C_HandleComplete : public Context {
- ReplayHandler *replay_handler;
+ ReplayHandler* replay_handler;
- explicit C_HandleComplete(ReplayHandler *_replay_handler)
- : replay_handler(_replay_handler) {
- replay_handler->get();
- }
- ~C_HandleComplete() override {
- replay_handler->put();
- }
+ explicit C_HandleComplete(ReplayHandler* r) : replay_handler(std::move(r)) {}
+ ~C_HandleComplete() override {}
void finish(int r) override {
replay_handler->handle_complete(r);
}
};
struct C_HandleEntriesAvailable : public Context {
- ReplayHandler *replay_handler;
+ ReplayHandler* replay_handler;
- explicit C_HandleEntriesAvailable(ReplayHandler *_replay_handler)
- : replay_handler(_replay_handler) {
- replay_handler->get();
- }
- ~C_HandleEntriesAvailable() override {
- replay_handler->put();
- }
+ explicit C_HandleEntriesAvailable(ReplayHandler* r) : replay_handler(std::move(r)) {}
+ ~C_HandleEntriesAvailable() override {}
void finish(int r) override {
replay_handler->handle_entries_available();
}
} // anonymous namespace
JournalPlayer::JournalPlayer(librados::IoCtx &ioctx,
- const std::string &object_oid_prefix,
- const JournalMetadataPtr& journal_metadata,
- ReplayHandler *replay_handler,
+ std::string_view object_oid_prefix,
+ ceph::ref_t<JournalMetadata> journal_metadata,
+ ReplayHandler* replay_handler,
CacheManagerHandler *cache_manager_handler)
- : m_cct(NULL), m_object_oid_prefix(object_oid_prefix),
- m_journal_metadata(journal_metadata), m_replay_handler(replay_handler),
+ : m_object_oid_prefix(object_oid_prefix),
+ m_journal_metadata(std::move(journal_metadata)),
+ m_replay_handler(std::move(replay_handler)),
m_cache_manager_handler(cache_manager_handler),
- m_cache_rebalance_handler(this),
- m_state(STATE_INIT), m_splay_offset(0), m_watch_enabled(false),
- m_watch_scheduled(false), m_watch_interval(0) {
- m_replay_handler->get();
+ m_cache_rebalance_handler(this)
+{
m_ioctx.dup(ioctx);
m_cct = reinterpret_cast<CephContext *>(m_ioctx.cct());
ceph_assert(m_fetch_object_numbers.empty());
ceph_assert(!m_watch_scheduled);
}
- m_replay_handler->put();
if (m_cache_manager_handler != nullptr) {
m_cache_manager_handler->unregister_cache(m_cache_name);
m_journal_metadata, on_finish);
if (m_watch_scheduled) {
- ObjectPlayerPtr object_player = get_object_player();
+ auto object_player = get_object_player();
switch (m_watch_step) {
case WATCH_STEP_FETCH_FIRST:
object_player = m_object_players.begin()->second;
return false;
}
- ObjectPlayerPtr object_player = get_object_player();
+ auto object_player = get_object_player();
ceph_assert(object_player && !object_player->empty());
object_player->front(entry);
bool prefetch_complete = false;
ceph_assert(m_object_players.count(splay_offset) == 1);
- ObjectPlayerPtr object_player = m_object_players[splay_offset];
+ auto object_player = m_object_players[splay_offset];
// prefetch in-order since a newer splay object could prefetch first
if (m_fetch_object_numbers.count(object_player->get_object_number()) == 0) {
return false;
}
- ObjectPlayerPtr object_player = get_object_player();
+ auto object_player = get_object_player();
ceph_assert(object_player);
uint64_t object_num = object_player->get_object_number();
}
bool pruned = false;
- for (auto &player_pair : m_object_players) {
- ObjectPlayerPtr object_player(player_pair.second);
+ for (const auto &player_pair : m_object_players) {
+ auto& object_player = player_pair.second;
ldout(m_cct, 15) << __func__ << ": checking " << object_player->get_oid()
<< dendl;
while (!object_player->empty()) {
if (pruned) {
ldout(m_cct, 15) << __func__ << ": resetting refetch state to immediate"
<< dendl;
- for (auto &player_pair : m_object_players) {
- ObjectPlayerPtr object_player(player_pair.second);
+ for (const auto &player_pair : m_object_players) {
+ auto& object_player = player_pair.second;
object_player->set_refetch_state(ObjectPlayer::REFETCH_STATE_IMMEDIATE);
}
}
// trim empty player to prefetch the next available object
- for (auto &player_pair : m_object_players) {
+ for (const auto &player_pair : m_object_players) {
remove_empty_object_player(player_pair.second);
}
}
prune_tag(active_tag_tid);
}
-ObjectPlayerPtr JournalPlayer::get_object_player() const {
+ceph::ref_t<ObjectPlayer> JournalPlayer::get_object_player() const {
ceph_assert(ceph_mutex_is_locked(m_lock));
SplayedObjectPlayers::const_iterator it = m_object_players.find(
return it->second;
}
-ObjectPlayerPtr JournalPlayer::get_object_player(uint64_t object_number) const {
+ceph::ref_t<ObjectPlayer> JournalPlayer::get_object_player(uint64_t object_number) const {
ceph_assert(ceph_mutex_is_locked(m_lock));
uint8_t splay_width = m_journal_metadata->get_splay_width();
auto splay_it = m_object_players.find(splay_offset);
ceph_assert(splay_it != m_object_players.end());
- ObjectPlayerPtr object_player = splay_it->second;
+ auto object_player = splay_it->second;
ceph_assert(object_player->get_object_number() == object_number);
return object_player;
}
<< static_cast<uint32_t>(m_splay_offset) << dendl;
}
-bool JournalPlayer::remove_empty_object_player(const ObjectPlayerPtr &player) {
+bool JournalPlayer::remove_empty_object_player(const ceph::ref_t<ObjectPlayer> &player) {
ceph_assert(ceph_mutex_is_locked(m_lock));
ceph_assert(!m_watch_scheduled);
ldout(m_cct, 20) << __func__ << ": new active set detected, all players "
<< "require refetch" << dendl;
m_active_set = active_set;
- for (auto &pair : m_object_players) {
+ for (const auto& pair : m_object_players) {
pair.second->set_refetch_state(ObjectPlayer::REFETCH_STATE_IMMEDIATE);
}
return false;
void JournalPlayer::fetch(uint64_t object_num) {
ceph_assert(ceph_mutex_is_locked(m_lock));
- ObjectPlayerPtr object_player(new ObjectPlayer(
+ auto object_player = ceph::make_ref<ObjectPlayer>(
m_ioctx, m_object_oid_prefix, object_num, m_journal_metadata->get_timer(),
m_journal_metadata->get_timer_lock(), m_journal_metadata->get_order(),
- m_max_fetch_bytes));
+ m_max_fetch_bytes);
auto splay_width = m_journal_metadata->get_splay_width();
m_object_players[object_num % splay_width] = object_player;
fetch(object_player);
}
-void JournalPlayer::fetch(const ObjectPlayerPtr &object_player) {
+void JournalPlayer::fetch(const ceph::ref_t<ObjectPlayer> &object_player) {
ceph_assert(ceph_mutex_is_locked(m_lock));
uint64_t object_num = object_player->get_object_number();
}
if (r == 0) {
- ObjectPlayerPtr object_player = get_object_player(object_num);
+ auto object_player = get_object_player(object_num);
remove_empty_object_player(object_player);
}
process_state(object_num, r);
return;
}
- ObjectPlayerPtr object_player = get_object_player();
+ auto object_player = get_object_player();
if (object_player->refetch_required()) {
object_player->set_refetch_state(ObjectPlayer::REFETCH_STATE_NONE);
fetch(object_player);
return;
}
- ObjectPlayerPtr object_player;
+ ceph::ref_t<ObjectPlayer> object_player;
double watch_interval = m_watch_interval;
switch (m_watch_step) {
return;
}
- ObjectPlayerPtr object_player = get_object_player(object_num);
+ auto object_player = get_object_player(object_num);
if (r == 0 && object_player->empty()) {
// possibly need to prune this empty object player if we've
// already fetched it after the active set was advanced with no
m_handler_notified = true;
ldout(m_cct, 10) << __func__ << ": entries available" << dendl;
- m_journal_metadata->queue(new C_HandleEntriesAvailable(
- m_replay_handler), 0);
+ m_journal_metadata->queue(new C_HandleEntriesAvailable(m_replay_handler), 0);
}
void JournalPlayer::notify_complete(int r) {
m_handler_notified = true;
ldout(m_cct, 10) << __func__ << ": replay complete: r=" << r << dendl;
- m_journal_metadata->queue(new C_HandleComplete(
- m_replay_handler), r);
+ m_journal_metadata->queue(new C_HandleComplete(m_replay_handler), r);
}
void JournalPlayer::handle_cache_rebalanced(uint64_t new_cache_bytes) {
typedef cls::journal::ObjectPositions ObjectPositions;
typedef cls::journal::ObjectSetPosition ObjectSetPosition;
- JournalPlayer(librados::IoCtx &ioctx, const std::string &object_oid_prefix,
- const JournalMetadataPtr& journal_metadata,
- ReplayHandler *replay_handler, CacheManagerHandler *cache_manager_handler);
+ JournalPlayer(librados::IoCtx &ioctx, std::string_view object_oid_prefix,
+ ceph::ref_t<JournalMetadata> journal_metadata,
+ ReplayHandler* replay_handler,
+ CacheManagerHandler *cache_manager_handler);
~JournalPlayer();
void prefetch();
private:
typedef std::set<uint8_t> PrefetchSplayOffsets;
- typedef std::map<uint8_t, ObjectPlayerPtr> SplayedObjectPlayers;
+ typedef std::map<uint8_t, ceph::ref_t<ObjectPlayer>> SplayedObjectPlayers;
typedef std::map<uint8_t, ObjectPosition> SplayedObjectPositions;
typedef std::set<uint64_t> ObjectNumbers;
};
librados::IoCtx m_ioctx;
- CephContext *m_cct;
+ CephContext *m_cct = nullptr;
std::string m_object_oid_prefix;
- JournalMetadataPtr m_journal_metadata;
- ReplayHandler *m_replay_handler;
+ ceph::ref_t<JournalMetadata> m_journal_metadata;
+ ReplayHandler* m_replay_handler;
CacheManagerHandler *m_cache_manager_handler;
std::string m_cache_name;
AsyncOpTracker m_async_op_tracker;
mutable ceph::mutex m_lock = ceph::make_mutex("JournalPlayer::m_lock");
- State m_state;
- uint8_t m_splay_offset;
+ State m_state = STATE_INIT;
+ uint8_t m_splay_offset = 0;
- bool m_watch_enabled;
- bool m_watch_scheduled;
- double m_watch_interval;
+ bool m_watch_enabled = false;
+ bool m_watch_scheduled = false;
+ double m_watch_interval = 0;
WatchStep m_watch_step = WATCH_STEP_FETCH_CURRENT;
bool m_watch_prune_active_tag = false;
void prune_tag(uint64_t tag_tid);
void prune_active_tag(const boost::optional<uint64_t>& tag_tid);
- ObjectPlayerPtr get_object_player() const;
- ObjectPlayerPtr get_object_player(uint64_t object_number) const;
- bool remove_empty_object_player(const ObjectPlayerPtr &object_player);
+ ceph::ref_t<ObjectPlayer> get_object_player() const;
+ ceph::ref_t<ObjectPlayer> get_object_player(uint64_t object_number) const;
+ bool remove_empty_object_player(const ceph::ref_t<ObjectPlayer> &object_player);
void process_state(uint64_t object_number, int r);
int process_prefetch(uint64_t object_number);
int process_playback(uint64_t object_number);
void fetch(uint64_t object_num);
- void fetch(const ObjectPlayerPtr &object_player);
+ void fetch(const ceph::ref_t<ObjectPlayer> &object_player);
void handle_fetched(uint64_t object_num, int r);
void refetch(bool immediate);
namespace {
struct C_Flush : public Context {
- JournalMetadataPtr journal_metadata;
+ ceph::ref_t<JournalMetadata> journal_metadata;
Context *on_finish;
- std::atomic<int64_t> pending_flushes = { 0 };
- int ret_val;
+ std::atomic<int64_t> pending_flushes{0};
+ int ret_val = 0;
- C_Flush(JournalMetadataPtr _journal_metadata, Context *_on_finish,
+ C_Flush(ceph::ref_t<JournalMetadata> _journal_metadata, Context *_on_finish,
size_t _pending_flushes)
- : journal_metadata(_journal_metadata), on_finish(_on_finish),
- pending_flushes(_pending_flushes), ret_val(0) {
+ : journal_metadata(std::move(_journal_metadata)),
+ on_finish(_on_finish),
+ pending_flushes(_pending_flushes) {
}
void complete(int r) override {
} // anonymous namespace
JournalRecorder::JournalRecorder(librados::IoCtx &ioctx,
- const std::string &object_oid_prefix,
- const JournalMetadataPtr& journal_metadata,
+ std::string_view object_oid_prefix,
+ ceph::ref_t<JournalMetadata> journal_metadata,
uint64_t max_in_flight_appends)
- : m_cct(NULL), m_object_oid_prefix(object_oid_prefix),
- m_journal_metadata(journal_metadata),
- m_max_in_flight_appends(max_in_flight_appends), m_listener(this),
+ : m_object_oid_prefix(object_oid_prefix),
+ m_journal_metadata(std::move(journal_metadata)),
+ m_max_in_flight_appends(max_in_flight_appends),
+ m_listener(this),
m_object_handler(this),
- m_lock(ceph::make_mutex("JournalerRecorder::m_lock")),
m_current_set(m_journal_metadata->get_active_set()),
m_object_locks{ceph::make_lock_container<ceph::mutex>(
- journal_metadata->get_splay_width(), [](const size_t splay_offset) {
+ m_journal_metadata->get_splay_width(), [](const size_t splay_offset) {
return ceph::make_mutex("ObjectRecorder::m_lock::" +
std::to_string(splay_offset));
})}
{
-
std::lock_guard locker{m_lock};
m_ioctx.dup(ioctx);
m_cct = reinterpret_cast<CephContext*>(m_ioctx.cct());
uint8_t splay_width = m_journal_metadata->get_splay_width();
uint8_t splay_offset = entry_tid % splay_width;
- ObjectRecorderPtr object_ptr = get_object(splay_offset);
+ auto object_ptr = get_object(splay_offset);
uint64_t commit_tid = m_journal_metadata->allocate_commit_tid(
object_ptr->get_object_number(), tag_tid, entry_tid);
- FutureImplPtr future(new FutureImpl(tag_tid, entry_tid, commit_tid));
+ auto future = ceph::make_ref<FutureImpl>(tag_tid, entry_tid, commit_tid);
future->init(m_prev_future);
m_prev_future = future;
std::lock_guard locker{m_lock};
ctx = new C_Flush(m_journal_metadata, on_safe, m_object_ptrs.size() + 1);
- for (ObjectRecorderPtrs::iterator it = m_object_ptrs.begin();
- it != m_object_ptrs.end(); ++it) {
- it->second->flush(ctx);
+ for (const auto& p : m_object_ptrs) {
+ p.second->flush(ctx);
}
}
ctx->complete(0);
}
-ObjectRecorderPtr JournalRecorder::get_object(uint8_t splay_offset) {
+ceph::ref_t<ObjectRecorder> JournalRecorder::get_object(uint8_t splay_offset) {
ceph_assert(ceph_mutex_is_locked(m_lock));
- ObjectRecorderPtr object_recoder = m_object_ptrs[splay_offset];
- ceph_assert(object_recoder != NULL);
+ const auto& object_recoder = m_object_ptrs.at(splay_offset);
+ ceph_assert(object_recoder);
return object_recoder;
}
uint8_t splay_width = m_journal_metadata->get_splay_width();
lock_object_recorders();
- for (ObjectRecorderPtrs::iterator it = m_object_ptrs.begin();
- it != m_object_ptrs.end(); ++it) {
- ObjectRecorderPtr object_recorder = it->second;
+ for (const auto& p : m_object_ptrs) {
+ const auto& object_recorder = p.second;
uint64_t object_number = object_recorder->get_object_number();
if (object_number / splay_width != m_current_set) {
ceph_assert(object_recorder->is_closed());
// closing the object to ensure correct order of future appends
uint8_t splay_width = m_journal_metadata->get_splay_width();
lock_object_recorders();
- for (ObjectRecorderPtrs::iterator it = m_object_ptrs.begin();
- it != m_object_ptrs.end(); ++it) {
- ObjectRecorderPtr object_recorder = it->second;
+ for (const auto& p : m_object_ptrs) {
+ const auto& object_recorder = p.second;
if (object_recorder->get_object_number() / splay_width != active_set) {
ldout(m_cct, 10) << "closing object " << object_recorder->get_oid()
<< dendl;
return (m_in_flight_object_closes == 0);
}
-ObjectRecorderPtr JournalRecorder::create_object_recorder(
+ceph::ref_t<ObjectRecorder> JournalRecorder::create_object_recorder(
uint64_t object_number, ceph::mutex* lock) {
ldout(m_cct, 10) << "object_number=" << object_number << dendl;
- ObjectRecorderPtr object_recorder(new ObjectRecorder(
+ auto object_recorder = ceph::make_ref<ObjectRecorder>(
m_ioctx, utils::get_object_name(m_object_oid_prefix, object_number),
object_number, lock, m_journal_metadata->get_work_queue(),
&m_object_handler, m_journal_metadata->get_order(),
- m_max_in_flight_appends));
+ m_max_in_flight_appends);
object_recorder->set_append_batch_options(m_flush_interval, m_flush_bytes,
m_flush_age);
return object_recorder;
}
void JournalRecorder::create_next_object_recorder(
- ObjectRecorderPtr object_recorder) {
+ ceph::ref_t<ObjectRecorder> object_recorder) {
ceph_assert(ceph_mutex_is_locked(m_lock));
uint64_t object_number = object_recorder->get_object_number();
ceph_assert(ceph_mutex_is_locked(m_object_locks[splay_offset]));
- ObjectRecorderPtr new_object_recorder = create_object_recorder(
+ auto new_object_recorder = create_object_recorder(
(m_current_set * splay_width) + splay_offset, &m_object_locks[splay_offset]);
ldout(m_cct, 10) << "old oid=" << object_recorder->get_oid() << ", "
}
new_object_recorder->append(std::move(append_buffers));
- m_object_ptrs[splay_offset] = new_object_recorder;
+ m_object_ptrs[splay_offset] = std::move(new_object_recorder);
}
void JournalRecorder::handle_update() {
uint64_t object_number = object_recorder->get_object_number();
uint8_t splay_width = m_journal_metadata->get_splay_width();
uint8_t splay_offset = object_number % splay_width;
- ObjectRecorderPtr active_object_recorder = m_object_ptrs[splay_offset];
+ auto& active_object_recorder = m_object_ptrs.at(splay_offset);
ceph_assert(active_object_recorder->get_object_number() == object_number);
ceph_assert(m_in_flight_object_closes > 0);
uint64_t object_number = object_recorder->get_object_number();
uint8_t splay_width = m_journal_metadata->get_splay_width();
uint8_t splay_offset = object_number % splay_width;
- ObjectRecorderPtr active_object_recorder = m_object_ptrs[splay_offset];
+ auto& active_object_recorder = m_object_ptrs.at(splay_offset);
ceph_assert(active_object_recorder->get_object_number() == object_number);
ldout(m_cct, 10) << "object " << active_object_recorder->get_oid()
class JournalRecorder {
public:
- JournalRecorder(librados::IoCtx &ioctx, const std::string &object_oid_prefix,
- const JournalMetadataPtr &journal_metadata,
+ JournalRecorder(librados::IoCtx &ioctx, std::string_view object_oid_prefix,
+ ceph::ref_t<JournalMetadata> journal_metadata,
uint64_t max_in_flight_appends);
~JournalRecorder();
Future append(uint64_t tag_tid, const bufferlist &bl);
void flush(Context *on_safe);
- ObjectRecorderPtr get_object(uint8_t splay_offset);
+ ceph::ref_t<ObjectRecorder> get_object(uint8_t splay_offset);
private:
- typedef std::map<uint8_t, ObjectRecorderPtr> ObjectRecorderPtrs;
+ typedef std::map<uint8_t, ceph::ref_t<ObjectRecorder>> ObjectRecorderPtrs;
struct Listener : public JournalMetadataListener {
JournalRecorder *journal_recorder;
};
librados::IoCtx m_ioctx;
- CephContext *m_cct;
+ CephContext *m_cct = nullptr;
std::string m_object_oid_prefix;
- JournalMetadataPtr m_journal_metadata;
+ ceph::ref_t<JournalMetadata> m_journal_metadata;
uint32_t m_flush_interval = 0;
uint64_t m_flush_bytes = 0;
Listener m_listener;
ObjectHandler m_object_handler;
- ceph::mutex m_lock;
+ ceph::mutex m_lock = ceph::make_mutex("JournalerRecorder::m_lock");
uint32_t m_in_flight_advance_sets = 0;
uint32_t m_in_flight_object_closes = 0;
ObjectRecorderPtrs m_object_ptrs;
ceph::containers::tiny_vector<ceph::mutex> m_object_locks;
- FutureImplPtr m_prev_future;
+ ceph::ref_t<FutureImpl> m_prev_future;
Context *m_on_object_set_advanced = nullptr;
void close_and_advance_object_set(uint64_t object_set);
- ObjectRecorderPtr create_object_recorder(uint64_t object_number,
+ ceph::ref_t<ObjectRecorder> create_object_recorder(uint64_t object_number,
ceph::mutex* lock);
- void create_next_object_recorder(ObjectRecorderPtr object_recorder);
+ void create_next_object_recorder(ceph::ref_t<ObjectRecorder> object_recorder);
void handle_update();
JournalTrimmer::JournalTrimmer(librados::IoCtx &ioctx,
const std::string &object_oid_prefix,
- const JournalMetadataPtr &journal_metadata)
+ const ceph::ref_t<JournalMetadata>& journal_metadata)
: m_cct(NULL), m_object_oid_prefix(object_oid_prefix),
m_journal_metadata(journal_metadata), m_metadata_listener(this),
m_remove_set_pending(false),
typedef cls::journal::ObjectSetPosition ObjectSetPosition;
JournalTrimmer(librados::IoCtx &ioctx, const std::string &object_oid_prefix,
- const JournalMetadataPtr &journal_metadata);
+ const ceph::ref_t<JournalMetadata> &journal_metadata);
~JournalTrimmer();
void shut_down(Context *on_finish);
CephContext *m_cct;
std::string m_object_oid_prefix;
- JournalMetadataPtr m_journal_metadata;
+ ceph::ref_t<JournalMetadata> m_journal_metadata;
MetadataListener m_metadata_listener;
AsyncOpTracker m_async_op_tracker;
m_header_oid = header_oid(journal_id);
m_object_oid_prefix = object_oid_prefix(m_header_ioctx.get_id(), journal_id);
- m_metadata = new JournalMetadata(work_queue, timer, timer_lock,
+ m_metadata = ceph::make_ref<JournalMetadata>(work_queue, timer, timer_lock,
m_header_ioctx, m_header_oid, m_client_id,
settings);
- m_metadata->get();
}
Journaler::~Journaler() {
// since we wouldn't expect shut_down to be invoked
m_metadata->wait_for_ops();
}
- m_metadata->put();
- m_metadata = nullptr;
+ m_metadata.reset();
}
ceph_assert(m_trimmer == nullptr);
ceph_assert(m_player == nullptr);
ceph_assert(m_player == nullptr);
ceph_assert(m_recorder == nullptr);
- JournalMetadata *metadata = nullptr;
- ceph_assert(m_metadata != nullptr);
- std::swap(metadata, m_metadata);
- ceph_assert(metadata != nullptr);
+ auto metadata = std::move(m_metadata);
+ ceph_assert(metadata);
on_finish = new LambdaContext([metadata, on_finish](int r) {
- metadata->put();
on_finish->complete(0);
});
m_metadata->get_tags(start_after_tag_tid, tag_class, tags, on_finish);
}
-void Journaler::start_replay(ReplayHandler *replay_handler) {
+void Journaler::start_replay(ReplayHandler* replay_handler) {
create_player(replay_handler);
m_player->prefetch();
}
-void Journaler::start_live_replay(ReplayHandler *replay_handler,
+void Journaler::start_live_replay(ReplayHandler* replay_handler,
double interval) {
create_player(replay_handler);
m_player->prefetch_and_watch(interval);
}
void Journaler::stop_replay(Context *on_finish) {
- JournalPlayer *player = nullptr;
- ceph_assert(m_player != nullptr);
- std::swap(player, m_player);
- ceph_assert(player != nullptr);
+ auto player = std::move(m_player);
+ auto* playerp = player.get();
- auto f = [player, on_finish](int r) {
- delete player;
+ auto f = [player=std::move(player), on_finish](int r) {
on_finish->complete(r);
};
on_finish = new LambdaContext(std::move(f));
- player->shut_down(on_finish);
+ playerp->shut_down(on_finish);
}
void Journaler::committed(const ReplayEntry &replay_entry) {
}
void Journaler::committed(const Future &future) {
- FutureImplPtr future_impl = future.get_future_impl();
+ auto& future_impl = future.get_future_impl();
m_trimmer->committed(future_impl->get_commit_tid());
}
// TODO verify active object set >= current replay object set
- m_recorder = new JournalRecorder(m_data_ioctx, m_object_oid_prefix,
+ m_recorder = std::make_unique<JournalRecorder>(m_data_ioctx, m_object_oid_prefix,
m_metadata, max_in_flight_appends);
}
}
void Journaler::stop_append(Context *on_safe) {
- JournalRecorder *recorder = nullptr;
- ceph_assert(m_recorder != nullptr);
- std::swap(recorder, m_recorder);
- ceph_assert(recorder != nullptr);
+ auto recorder = std::move(m_recorder);
+ ceph_assert(recorder);
- on_safe = new LambdaContext([recorder, on_safe](int r) {
- delete recorder;
+ auto* recorderp = recorder.get();
+ on_safe = new LambdaContext([recorder=std::move(recorder), on_safe](int r) {
on_safe->complete(r);
});
- recorder->shut_down(on_safe);
+ recorderp->shut_down(on_safe);
}
uint64_t Journaler::get_max_append_size() const {
m_recorder->flush(on_safe);
}
-void Journaler::create_player(ReplayHandler *replay_handler) {
+void Journaler::create_player(ReplayHandler* replay_handler) {
ceph_assert(m_player == nullptr);
- m_player = new JournalPlayer(m_data_ioctx, m_object_oid_prefix, m_metadata,
+ m_player = std::make_unique<JournalPlayer>(m_data_ioctx, m_object_oid_prefix, m_metadata,
replay_handler, m_cache_manager_handler);
}
struct CacheManagerHandler;
-class JournalMetadata;
-class JournalPlayer;
-class JournalRecorder;
class JournalTrimmer;
class ReplayEntry;
class ReplayHandler;
void get_tags(uint64_t start_after_tag_tid, uint64_t tag_class, Tags *tags,
Context *on_finish);
- void start_replay(ReplayHandler *replay_handler);
- void start_live_replay(ReplayHandler *replay_handler, double interval);
+ void start_replay(ReplayHandler* replay_handler);
+ void start_live_replay(ReplayHandler* replay_handler, double interval);
bool try_pop_front(ReplayEntry *replay_entry, uint64_t *tag_tid = nullptr);
void stop_replay();
void stop_replay(Context *on_finish);
std::string m_object_oid_prefix;
bool m_initialized = false;
- JournalMetadata *m_metadata = nullptr;
- JournalPlayer *m_player = nullptr;
- JournalRecorder *m_recorder = nullptr;
+ ceph::ref_t<class JournalMetadata> m_metadata;
+ std::unique_ptr<class JournalPlayer> m_player;
+ std::unique_ptr<class JournalRecorder> m_recorder;
JournalTrimmer *m_trimmer = nullptr;
void set_up(ContextWQ *work_queue, SafeTimer *timer, ceph::mutex *timer_lock,
const Settings &settings);
int init_complete();
- void create_player(ReplayHandler *replay_handler);
+ void create_player(ReplayHandler* replay_handler);
friend std::ostream &operator<<(std::ostream &os,
const Journaler &journaler);
} // anonymous namespace
ObjectPlayer::ObjectPlayer(librados::IoCtx &ioctx,
- const std::string &object_oid_prefix,
+ const std::string& object_oid_prefix,
uint64_t object_num, SafeTimer &timer,
ceph::mutex &timer_lock, uint8_t order,
uint64_t max_fetch_bytes)
- : RefCountedObject(NULL, 0), m_object_num(object_num),
+ : m_object_num(object_num),
m_oid(utils::get_object_name(object_oid_prefix, m_object_num)),
- m_cct(NULL), m_timer(timer), m_timer_lock(timer_lock), m_order(order),
+ m_timer(timer), m_timer_lock(timer_lock), m_order(order),
m_max_fetch_bytes(max_fetch_bytes > 0 ? max_fetch_bytes : 2 << order),
- m_watch_interval(0), m_watch_task(NULL),
- m_lock(ceph::make_mutex(utils::unique_lock_name("ObjectPlayer::m_lock", this))),
- m_fetch_in_progress(false) {
+ m_lock(ceph::make_mutex(utils::unique_lock_name("ObjectPlayer::m_lock", this)))
+{
m_ioctx.dup(ioctx);
m_cct = reinterpret_cast<CephContext*>(m_ioctx.cct());
}
#include "journal/Entry.h"
#include <list>
#include <string>
-#include <boost/intrusive_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/unordered_map.hpp>
#include "include/ceph_assert.h"
namespace journal {
-class ObjectPlayer;
-typedef boost::intrusive_ptr<ObjectPlayer> ObjectPlayerPtr;
-
class ObjectPlayer : public RefCountedObject {
public:
typedef std::list<Entry> Entries;
REFETCH_STATE_IMMEDIATE
};
- ObjectPlayer(librados::IoCtx &ioctx, const std::string &object_oid_prefix,
- uint64_t object_num, SafeTimer &timer, ceph::mutex &timer_lock,
- uint8_t order, uint64_t max_fetch_bytes);
- ~ObjectPlayer() override;
-
inline const std::string &get_oid() const {
return m_oid;
}
}
private:
+ FRIEND_MAKE_REF(ObjectPlayer);
+ ObjectPlayer(librados::IoCtx &ioctx, const std::string& object_oid_prefix,
+ uint64_t object_num, SafeTimer &timer, ceph::mutex &timer_lock,
+ uint8_t order, uint64_t max_fetch_bytes);
+ ~ObjectPlayer() override;
+
typedef std::pair<uint64_t, uint64_t> EntryKey;
typedef boost::unordered_map<EntryKey, Entries::iterator> EntryKeys;
struct C_Fetch : public Context {
- ObjectPlayerPtr object_player;
+ ceph::ref_t<ObjectPlayer> object_player;
Context *on_finish;
bufferlist read_bl;
C_Fetch(ObjectPlayer *o, Context *ctx) : object_player(o), on_finish(ctx) {
void finish(int r) override;
};
struct C_WatchFetch : public Context {
- ObjectPlayerPtr object_player;
+ ceph::ref_t<ObjectPlayer> object_player;
C_WatchFetch(ObjectPlayer *o) : object_player(o) {
}
void finish(int r) override;
librados::IoCtx m_ioctx;
uint64_t m_object_num;
std::string m_oid;
- CephContext *m_cct;
+ CephContext *m_cct = nullptr;
SafeTimer &m_timer;
ceph::mutex &m_timer_lock;
uint8_t m_order;
uint64_t m_max_fetch_bytes;
- double m_watch_interval;
- Context *m_watch_task;
+ double m_watch_interval = 0;
+ Context *m_watch_task = nullptr;
mutable ceph::mutex m_lock;
- bool m_fetch_in_progress;
+ bool m_fetch_in_progress = false;
bufferlist m_read_bl;
uint32_t m_read_off = 0;
uint32_t m_read_bl_off = 0;
namespace journal {
-ObjectRecorder::ObjectRecorder(librados::IoCtx &ioctx, const std::string &oid,
+ObjectRecorder::ObjectRecorder(librados::IoCtx &ioctx, std::string_view oid,
uint64_t object_number, ceph::mutex* lock,
ContextWQ *work_queue, Handler *handler,
uint8_t order, int32_t max_in_flight_appends)
- : RefCountedObject(NULL, 0), m_oid(oid), m_object_number(object_number),
- m_cct(NULL), m_op_work_queue(work_queue), m_handler(handler),
+ : m_oid(oid), m_object_number(object_number),
+ m_op_work_queue(work_queue), m_handler(handler),
m_order(order), m_soft_max_size(1 << m_order),
- m_max_in_flight_appends(max_in_flight_appends), m_flush_handler(this),
- m_lock(lock), m_last_flush_time(ceph_clock_now()), m_append_tid(0),
- m_overflowed(false), m_object_closed(false), m_in_flight_flushes(false) {
+ m_max_in_flight_appends(max_in_flight_appends),
+ m_lock(lock), m_last_flush_time(ceph_clock_now())
+{
m_ioctx.dup(ioctx);
m_cct = reinterpret_cast<CephContext*>(m_ioctx.cct());
ceph_assert(m_handler != NULL);
ceph_assert(ceph_mutex_is_locked(*m_lock));
- FutureImplPtr last_flushed_future;
+ ceph::ref_t<FutureImpl> last_flushed_future;
+ auto flush_handler = get_flush_handler();
for (auto& append_buffer : append_buffers) {
ldout(m_cct, 20) << *append_buffer.first << ", "
<< "size=" << append_buffer.second.length() << dendl;
- bool flush_requested = append_buffer.first->attach(&m_flush_handler);
+ bool flush_requested = append_buffer.first->attach(flush_handler);
if (flush_requested) {
last_flushed_future = append_buffer.first;
}
}
}
-void ObjectRecorder::flush(const FutureImplPtr &future) {
+void ObjectRecorder::flush(const ceph::ref_t<FutureImpl>& future) {
ldout(m_cct, 20) << "flushing " << *future << dendl;
m_lock->lock();
- if (future->get_flush_handler().get() != &m_flush_handler) {
- // if we don't own this future, re-issue the flush so that it hits the
- // correct journal object owner
- future->flush();
- m_lock->unlock();
- return;
- } else if (future->is_flush_in_progress()) {
- m_lock->unlock();
- return;
+ {
+ auto flush_handler = future->get_flush_handler();
+ auto my_handler = get_flush_handler();
+ if (flush_handler != my_handler) {
+ // if we don't own this future, re-issue the flush so that it hits the
+ // correct journal object owner
+ future->flush();
+ m_lock->unlock();
+ return;
+ } else if (future->is_flush_in_progress()) {
+ m_lock->unlock();
+ return;
+ }
}
bool overflowed = send_appends(true, future);
restart_append_buffers.swap(m_pending_buffers);
}
-bool ObjectRecorder::send_appends(bool force, FutureImplPtr flush_future) {
+bool ObjectRecorder::send_appends(bool force, ceph::ref_t<FutureImpl> flush_future) {
ldout(m_cct, 20) << dendl;
ceph_assert(ceph_mutex_is_locked(*m_lock));
#include <list>
#include <map>
#include <set>
-#include <boost/intrusive_ptr.hpp>
#include <boost/noncopyable.hpp>
#include "include/ceph_assert.h"
namespace journal {
class ObjectRecorder;
-typedef boost::intrusive_ptr<ObjectRecorder> ObjectRecorderPtr;
-typedef std::pair<FutureImplPtr, bufferlist> AppendBuffer;
+typedef std::pair<ceph::ref_t<FutureImpl>, bufferlist> AppendBuffer;
typedef std::list<AppendBuffer> AppendBuffers;
class ObjectRecorder : public RefCountedObject, boost::noncopyable {
virtual void overflow(ObjectRecorder *object_recorder) = 0;
};
- ObjectRecorder(librados::IoCtx &ioctx, const std::string &oid,
- uint64_t object_number, ceph::mutex* lock,
- ContextWQ *work_queue, Handler *handler, uint8_t order,
- int32_t max_in_flight_appends);
- ~ObjectRecorder() override;
-
void set_append_batch_options(int flush_interval, uint64_t flush_bytes,
double flush_age);
bool append(AppendBuffers &&append_buffers);
void flush(Context *on_safe);
- void flush(const FutureImplPtr &future);
+ void flush(const ceph::ref_t<FutureImpl> &future);
void claim_append_buffers(AppendBuffers *append_buffers);
}
private:
+ FRIEND_MAKE_REF(ObjectRecorder);
+ ObjectRecorder(librados::IoCtx &ioctx, std::string_view oid,
+ uint64_t object_number, ceph::mutex* lock,
+ ContextWQ *work_queue, Handler *handler, uint8_t order,
+ int32_t max_in_flight_appends);
+ ~ObjectRecorder() override;
+
typedef std::set<uint64_t> InFlightTids;
typedef std::map<uint64_t, AppendBuffers> InFlightAppends;
struct FlushHandler : public FutureImpl::FlushHandler {
- ObjectRecorder *object_recorder;
- FlushHandler(ObjectRecorder *o) : object_recorder(o) {}
- void get() override {
- object_recorder->get();
- }
- void put() override {
- object_recorder->put();
- }
- void flush(const FutureImplPtr &future) override {
+ ceph::ref_t<ObjectRecorder> object_recorder;
+ virtual void flush(const ceph::ref_t<FutureImpl> &future) override {
object_recorder->flush(future);
}
+ FlushHandler(ceph::ref_t<ObjectRecorder> o) : object_recorder(std::move(o)) {}
};
struct C_AppendFlush : public Context {
- ObjectRecorder *object_recorder;
+ ceph::ref_t<ObjectRecorder> object_recorder;
uint64_t tid;
- C_AppendFlush(ObjectRecorder *o, uint64_t _tid)
- : object_recorder(o), tid(_tid) {
- object_recorder->get();
+ C_AppendFlush(ceph::ref_t<ObjectRecorder> o, uint64_t _tid)
+ : object_recorder(std::move(o)), tid(_tid) {
}
void finish(int r) override {
object_recorder->handle_append_flushed(tid, r);
- object_recorder->put();
}
};
librados::IoCtx m_ioctx;
std::string m_oid;
uint64_t m_object_number;
- CephContext *m_cct;
+ CephContext *m_cct = nullptr;
ContextWQ *m_op_work_queue;
bool m_compat_mode;
- FlushHandler m_flush_handler;
+ /* So that ObjectRecorder::FlushHandler doesn't create a circular reference: */
+ std::weak_ptr<FlushHandler> m_flush_handler;
+ auto get_flush_handler() {
+ auto h = m_flush_handler.lock();
+ if (!h) {
+ h = std::make_shared<FlushHandler>(this);
+ m_flush_handler = h;
+ }
+ return h;
+ }
mutable ceph::mutex* m_lock;
AppendBuffers m_pending_buffers;
uint64_t m_pending_bytes = 0;
utime_t m_last_flush_time;
- uint64_t m_append_tid;
+ uint64_t m_append_tid = 0;
InFlightTids m_in_flight_tids;
InFlightAppends m_in_flight_appends;
uint64_t m_object_bytes = 0;
- bool m_overflowed;
- bool m_object_closed;
+ bool m_overflowed = false;
+ bool m_object_closed = false;
bufferlist m_prefetch_bl;
- bool m_in_flight_flushes;
+ bool m_in_flight_flushes = false;
ceph::condition_variable m_in_flight_flushes_cond;
uint64_t m_in_flight_bytes = 0;
- bool send_appends(bool force, FutureImplPtr flush_sentinal);
+ bool send_appends(bool force, ceph::ref_t<FutureImpl> flush_sentinal);
void handle_append_flushed(uint64_t tid, int r);
void append_overflowed();
namespace journal {
-struct ReplayHandler {
- virtual ~ReplayHandler() {}
-
- virtual void get() = 0;
- virtual void put() = 0;
-
+struct ReplayHandler {
virtual void handle_entries_available() = 0;
virtual void handle_complete(int r) = 0;
+ virtual ~ReplayHandler() {}
};
} // namespace journal
#include "include/ceph_fs.h"
#include "common/dout.h"
#include "common/strtol.h"
+#include "common/RefCountedObj.h"
#include "osdc/Striper.h"
#include "librados/AioCompletionImpl.h"
#include <cls/lock/cls_lock_client.h>
* function in asynchronous operations
*/
struct CompletionData : RefCountedObject {
- /// constructor
- CompletionData(libradosstriper::RadosStriperImpl * striper,
- const std::string& soid,
- const std::string& lockCookie,
- librados::AioCompletionImpl *userCompletion = 0,
- int n = 1);
- /// destructor
- ~CompletionData() override;
/// complete method
void complete(int r);
/// striper to be used to handle the write completion
std::string m_lockCookie;
/// completion handler
librados::IoCtxImpl::C_aio_Complete *m_ack;
+protected:
+ CompletionData(libradosstriper::RadosStriperImpl * striper,
+ const std::string& soid,
+ const std::string& lockCookie,
+ librados::AioCompletionImpl *userCompletion = 0);
+ ~CompletionData() override;
+
};
CompletionData::CompletionData
(libradosstriper::RadosStriperImpl* striper,
const std::string& soid,
const std::string& lockCookie,
- librados::AioCompletionImpl *userCompletion,
- int n) :
- RefCountedObject(striper->cct(), n),
+ librados::AioCompletionImpl *userCompletion) :
+ RefCountedObject(striper->cct()),
m_striper(striper), m_soid(soid), m_lockCookie(lockCookie), m_ack(0) {
m_striper->get();
if (userCompletion) {
int m_readRc;
/// completion object for the unlocking of the striped object at the end of the read
librados::AioCompletion *m_unlockCompletion;
- /// constructor
+ /// complete method for when reading is over
+ void complete_read(int r);
+ /// complete method for when object is unlocked
+ void complete_unlock(int r);
+
+private:
+ FRIEND_MAKE_REF(ReadCompletionData);
ReadCompletionData(libradosstriper::RadosStriperImpl * striper,
const std::string& soid,
const std::string& lockCookie,
librados::AioCompletionImpl *userCompletion,
bufferlist* bl,
std::vector<ObjectExtent>* extents,
- std::vector<bufferlist>* resultbl,
- int n);
- /// destructor
+ std::vector<bufferlist>* resultbl);
~ReadCompletionData() override;
- /// complete method for when reading is over
- void complete_read(int r);
- /// complete method for when object is unlocked
- void complete_unlock(int r);
};
ReadCompletionData::ReadCompletionData
librados::AioCompletionImpl *userCompletion,
bufferlist* bl,
std::vector<ObjectExtent>* extents,
- std::vector<bufferlist>* resultbl,
- int n) :
- CompletionData(striper, soid, lockCookie, userCompletion, n),
+ std::vector<bufferlist>* resultbl) :
+ CompletionData(striper, soid, lockCookie, userCompletion),
m_bl(bl), m_extents(extents), m_resultbl(resultbl), m_readRc(0),
m_unlockCompletion(0) {}
librados::AioCompletion *m_unlockCompletion;
/// return code of write completion, to be remembered until unlocking happened
int m_writeRc;
- /// constructor
- WriteCompletionData(libradosstriper::RadosStriperImpl * striper,
- const std::string& soid,
- const std::string& lockCookie,
- librados::AioCompletionImpl *userCompletion,
- int n);
- /// destructor
- ~WriteCompletionData() override;
/// complete method for when writing is over
void complete_write(int r);
/// complete method for when object is unlocked
void complete_unlock(int r);
/// safe method
void safe(int r);
+private:
+ FRIEND_MAKE_REF(WriteCompletionData);
+ /// constructor
+ WriteCompletionData(libradosstriper::RadosStriperImpl * striper,
+ const std::string& soid,
+ const std::string& lockCookie,
+ librados::AioCompletionImpl *userCompletion);
+ /// destructor
+ ~WriteCompletionData() override;
};
WriteCompletionData::WriteCompletionData
(libradosstriper::RadosStriperImpl* striper,
const std::string& soid,
const std::string& lockCookie,
- librados::AioCompletionImpl *userCompletion,
- int n) :
- CompletionData(striper, soid, lockCookie, userCompletion, n), m_safe(0),
- m_unlockCompletion(0), m_writeRc(0) {
+ librados::AioCompletionImpl *userCompletion) :
+ CompletionData(striper, soid, lockCookie, userCompletion),
+ m_safe(0), m_unlockCompletion(0), m_writeRc(0) {
if (userCompletion) {
m_safe = new librados::IoCtxImpl::C_aio_Complete(userCompletion);
}
struct RemoveCompletionData : CompletionData {
/// removal flags
int flags;
+
+private:
+ FRIEND_MAKE_REF(RemoveCompletionData);
/**
* constructor
* note that the constructed object will take ownership of the lock
* function in asynchronous truncate operations
*/
struct TruncateCompletionData : RefCountedObject {
+ /// striper to be used
+ libradosstriper::RadosStriperImpl *m_striper;
+ /// striped object concerned by the truncate operation
+ std::string m_soid;
+ /// the final size of the truncated object
+ uint64_t m_size;
+
+private:
+ FRIEND_MAKE_REF(TruncateCompletionData);
/// constructor
TruncateCompletionData(libradosstriper::RadosStriperImpl* striper,
const std::string& soid,
~TruncateCompletionData() override {
m_striper->put();
}
- /// striper to be used
- libradosstriper::RadosStriperImpl *m_striper;
- /// striped object concerned by the truncate operation
- std::string m_soid;
- /// the final size of the truncated object
- uint64_t m_size;
};
/**
* function in asynchronous read operations of a Rados File
*/
struct RadosReadCompletionData : RefCountedObject {
- /// constructor
- RadosReadCompletionData(MultiAioCompletionImplPtr multiAioCompl,
- uint64_t expectedBytes,
- bufferlist *bl,
- CephContext *context,
- int n = 1) :
- RefCountedObject(context, n),
- m_multiAioCompl(multiAioCompl), m_expectedBytes(expectedBytes), m_bl(bl) {}
/// the multi asynch io completion object to be used
MultiAioCompletionImplPtr m_multiAioCompl;
/// the expected number of bytes
uint64_t m_expectedBytes;
/// the bufferlist object where data have been written
bufferlist *m_bl;
+
+private:
+ FRIEND_MAKE_REF(RadosReadCompletionData);
+ /// constructor
+ RadosReadCompletionData(MultiAioCompletionImplPtr multiAioCompl,
+ uint64_t expectedBytes,
+ bufferlist *bl,
+ CephContext *context) :
+ RefCountedObject(context),
+ m_multiAioCompl(multiAioCompl), m_expectedBytes(expectedBytes), m_bl(bl) {}
};
/**
* versions (time_t or struct timespec)
*/
struct BasicStatCompletionData : CompletionData {
- /// constructor
- BasicStatCompletionData(libradosstriper::RadosStriperImpl* striper,
- const std::string& soid,
- librados::AioCompletionImpl *userCompletion,
- libradosstriper::MultiAioCompletionImpl *multiCompletion,
- uint64_t *psize,
- int n = 1) :
- CompletionData(striper, soid, "", userCompletion, n),
- m_multiCompletion(multiCompletion), m_psize(psize),
- m_statRC(0), m_getxattrRC(0) {};
// MultiAioCompletionImpl used to handle the double aysnc
// call in the back (stat + getxattr)
libradosstriper::MultiAioCompletionImpl *m_multiCompletion;
int m_statRC;
/// return code of the getxattr
int m_getxattrRC;
+
+protected:
+ /// constructor
+ BasicStatCompletionData(libradosstriper::RadosStriperImpl* striper,
+ const std::string& soid,
+ librados::AioCompletionImpl *userCompletion,
+ libradosstriper::MultiAioCompletionImpl *multiCompletion,
+ uint64_t *psize) :
+ CompletionData(striper, soid, "", userCompletion),
+ m_multiCompletion(multiCompletion), m_psize(psize),
+ m_statRC(0), m_getxattrRC(0) {};
+
};
/**
*/
template<class TimeType>
struct StatCompletionData : BasicStatCompletionData {
+ // where to store the file time
+ TimeType *m_pmtime;
+private:
+ FRIEND_MAKE_REF(StatCompletionData);
/// constructor
- StatCompletionData(libradosstriper::RadosStriperImpl* striper,
+ StatCompletionData<TimeType>(libradosstriper::RadosStriperImpl* striper,
const std::string& soid,
librados::AioCompletionImpl *userCompletion,
libradosstriper::MultiAioCompletionImpl *multiCompletion,
uint64_t *psize,
- TimeType *pmtime,
- int n = 1) :
- BasicStatCompletionData(striper, soid, userCompletion, multiCompletion, psize, n),
+ TimeType *pmtime) :
+ BasicStatCompletionData(striper, soid, userCompletion, multiCompletion, psize),
m_pmtime(pmtime) {};
- // where to store the file time
- TimeType *m_pmtime;
};
/**
* function in asynchronous remove operations of a Rados File
*/
struct RadosRemoveCompletionData : RefCountedObject {
+ /// the multi asynch io completion object to be used
+ MultiAioCompletionImplPtr m_multiAioCompl;
+private:
+ FRIEND_MAKE_REF(RadosRemoveCompletionData);
/// constructor
RadosRemoveCompletionData(MultiAioCompletionImplPtr multiAioCompl,
CephContext *context) :
- RefCountedObject(context, 2),
+ RefCountedObject(context),
m_multiAioCompl(multiAioCompl) {};
- /// the multi asynch io completion object to be used
- MultiAioCompletionImplPtr m_multiAioCompl;
};
static void rados_read_aio_unlock_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<ReadCompletionData*>(arg);
+ auto cdata = ceph::ref_t<ReadCompletionData>(static_cast<ReadCompletionData*>(arg), false);
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
cdata->complete_unlock(comp->rval);
- cdata->put();
}
static void striper_read_aio_req_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<ReadCompletionData*>(arg);
+ auto cdata = static_cast<ReadCompletionData*>(arg);
// launch the async unlocking of the object
cdata->m_striper->aio_unlockObject(cdata->m_soid, cdata->m_lockCookie, cdata->m_unlockCompletion);
// complete the read part in parallel
static void rados_req_read_safe(rados_completion_t c, void *arg)
{
- auto data = reinterpret_cast<RadosReadCompletionData*>(arg);
+ auto data = ceph::ref_t<RadosReadCompletionData>(static_cast<RadosReadCompletionData*>(arg), false);
int rc = rados_aio_get_return_value(c);
// ENOENT means that we are dealing with a sparse file. This is fine,
// data (0s) will be created on the fly by the rados_req_read_complete method
if (rc == -ENOENT) rc = 0;
auto multiAioComp = data->m_multiAioCompl;
multiAioComp->safe_request(rc);
- data->put();
}
static void rados_req_read_complete(rados_completion_t c, void *arg)
{
- auto data = reinterpret_cast<RadosReadCompletionData*>(arg);
+ auto data = static_cast<RadosReadCompletionData*>(arg);
int rc = rados_aio_get_return_value(c);
// We need to handle the case of sparse files here
if (rc == -ENOENT) {
}
auto multiAioComp = data->m_multiAioCompl;
multiAioComp->complete_request(rc);
- data->put();
}
int libradosstriper::RadosStriperImpl::aio_read(const std::string& soid,
// create a completion object and transfer ownership of extents and resultbl
vector<bufferlist> *resultbl = new vector<bufferlist>(extents->size());
- ReadCompletionData *cdata = new ReadCompletionData(this, soid, lockCookie, c,
- bl, extents, resultbl, 1);
+ auto cdata = ceph::make_ref<ReadCompletionData>(this, soid, lockCookie, c, bl, extents, resultbl);
c->is_read = true;
c->io = m_ioCtxImpl;
// create a completion for the unlocking of the striped object at the end of the read
librados::AioCompletion *unlock_completion =
- librados::Rados::aio_create_completion(cdata, rados_read_aio_unlock_complete, 0);
+ librados::Rados::aio_create_completion(cdata->get() /* create ref! */, rados_read_aio_unlock_complete, 0);
cdata->m_unlockCompletion = unlock_completion;
// create the multiCompletion object handling the reads
MultiAioCompletionImplPtr nc{new libradosstriper::MultiAioCompletionImpl,
false};
- nc->set_complete_callback(cdata, striper_read_aio_req_complete);
+ nc->set_complete_callback(cdata.get(), striper_read_aio_req_complete);
// go through the extents
int r = 0, i = 0;
for (vector<ObjectExtent>::iterator p = extents->begin(); p != extents->end(); ++p) {
nc->add_request();
// we need 2 references on data as both rados_req_read_safe and rados_req_read_complete
// will release one
- RadosReadCompletionData *data = new RadosReadCompletionData(nc, p->length, oid_bl, cct(), 2);
+ auto data = ceph::make_ref<RadosReadCompletionData>(nc, p->length, oid_bl, cct());
librados::AioCompletion *rados_completion =
- librados::Rados::aio_create_completion(data, rados_req_read_complete, rados_req_read_safe);
+ librados::Rados::aio_create_completion(data.detach(), rados_req_read_complete, rados_req_read_safe);
r = m_ioCtx.aio_read(p->oid.name, rados_completion, oid_bl, p->length, p->offset);
rados_completion->release();
if (r < 0)
}
static void striper_stat_aio_stat_complete(rados_completion_t c, void *arg) {
- auto data = reinterpret_cast<BasicStatCompletionData*>(arg);
+ auto data = ceph::ref_t<BasicStatCompletionData>(static_cast<BasicStatCompletionData*>(arg), false);
int rc = rados_aio_get_return_value(c);
if (rc == -ENOENT) {
// remember this has failed
data->m_statRC = rc;
}
data->m_multiCompletion->complete_request(rc);
- data->put();
}
static void striper_stat_aio_getxattr_complete(rados_completion_t c, void *arg) {
- auto data = reinterpret_cast<BasicStatCompletionData*>(arg);
+ auto data = ceph::ref_t<BasicStatCompletionData>(static_cast<BasicStatCompletionData*>(arg), false);
int rc = rados_aio_get_return_value(c);
// We need to handle the case of sparse files here
if (rc < 0) {
rc = 0;
}
data->m_multiCompletion->complete_request(rc);
- data->put();
}
static void striper_stat_aio_req_complete(rados_striper_multi_completion_t c,
void *arg) {
- auto data = reinterpret_cast<BasicStatCompletionData*>(arg);
+ auto data = ceph::ref_t<BasicStatCompletionData>(static_cast<BasicStatCompletionData*>(arg), false);
if (data->m_statRC) {
data->complete(data->m_statRC);
} else {
data->complete(0);
}
}
- data->put();
}
template<class TimeType>
new libradosstriper::MultiAioCompletionImpl, false};
// Data object used for passing context to asynchronous calls
std::string firstObjOid = getObjectId(soid, 0);
- StatCompletionData<TimeType> *cdata =
- new StatCompletionData<TimeType>(this, firstObjOid, c,
- multi_completion.get(), psize, pmtime, 4);
- multi_completion->set_complete_callback(cdata, striper_stat_aio_req_complete);
+ auto cdata = ceph::make_ref<StatCompletionData<TimeType>>(this, firstObjOid, c, multi_completion.get(), psize, pmtime);
+ multi_completion->set_complete_callback(cdata->get() /* create ref! */, striper_stat_aio_req_complete);
// use a regular AioCompletion for the stat async call
librados::AioCompletion *stat_completion =
- librados::Rados::aio_create_completion(cdata, striper_stat_aio_stat_complete, 0);
+ librados::Rados::aio_create_completion(cdata->get() /* create ref! */, striper_stat_aio_stat_complete, 0);
multi_completion->add_safe_request();
object_t obj(firstObjOid);
int rc = (m_ioCtxImpl->*statFunction)(obj, stat_completion->pc,
stat_completion->release();
if (rc < 0) {
// nothing is really started so cancel everything
- delete cdata;
+ delete cdata.detach();
return rc;
}
// use a regular AioCompletion for the getxattr async call
librados::AioCompletion *getxattr_completion =
- librados::Rados::aio_create_completion(cdata, striper_stat_aio_getxattr_complete, 0);
+ librados::Rados::aio_create_completion(cdata->get() /* create ref! */, striper_stat_aio_getxattr_complete, 0);
multi_completion->add_safe_request();
// in parallel, get the pmsize from the first object asynchronously
rc = m_ioCtxImpl->aio_getxattr(obj, getxattr_completion->pc,
multi_completion->complete_request(rc);
return rc;
}
- cdata->put();
return 0;
}
static void rados_req_remove_complete(rados_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<RadosRemoveCompletionData*>(arg);
+ auto cdata = static_cast<RadosRemoveCompletionData*>(arg);
int rc = rados_aio_get_return_value(c);
// in case the object did not exist, it means we had a sparse file, all is fine
if (rc == -ENOENT) {
rc = 0;
}
cdata->m_multiAioCompl->complete_request(rc);
- cdata->put();
}
static void rados_req_remove_safe(rados_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<RadosRemoveCompletionData*>(arg);
+ auto cdata = ceph::ref_t<RadosRemoveCompletionData>(static_cast<RadosRemoveCompletionData*>(arg), false);
int rc = rados_aio_get_return_value(c);
// in case the object did not exist, it means we had a sparse file, all is fine
if (rc == -ENOENT) {
rc = 0;
}
cdata->m_multiAioCompl->safe_request(rc);
- cdata->put();
}
static void striper_remove_aio_req_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<RemoveCompletionData*>(arg);
+ auto cdata = ceph::ref_t<RemoveCompletionData>(static_cast<RemoveCompletionData*>(arg), false);
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
ldout(cdata->m_striper->cct(), 10)
<< dendl;
}
cdata->complete(rc);
- cdata->put();
}
int libradosstriper::RadosStriperImpl::remove(const std::string& soid, int flags)
int rc = m_ioCtx.lock_exclusive(getObjectId(soid, 0), RADOS_LOCK_NAME, lockCookie, "", 0, 0);
if (rc) return rc;
// create CompletionData for the async remove call
- RemoveCompletionData *cdata = new RemoveCompletionData(this, soid, lockCookie, c, flags);
+ auto cdata = ceph::make_ref<RemoveCompletionData>(this, soid, lockCookie, c, flags);
MultiAioCompletionImplPtr multi_completion{
new libradosstriper::MultiAioCompletionImpl, false};
- multi_completion->set_complete_callback(cdata, striper_remove_aio_req_complete);
+ multi_completion->set_complete_callback(cdata->get() /* create ref! */, striper_remove_aio_req_complete);
// call asynchronous internal version of remove
ldout(cct(), 10)
<< "RadosStriperImpl : Aio_remove starting for "
int rcr = 0;
for (int i = nb_objects-1; i >= 1; i--) {
multi_completion->add_request();
- RadosRemoveCompletionData *data =
- new RadosRemoveCompletionData(multi_completion, cct());
+ auto data = ceph::make_ref<RadosRemoveCompletionData>(multi_completion, cct());
librados::AioCompletion *rados_completion =
- librados::Rados::aio_create_completion(data,
+ librados::Rados::aio_create_completion(data->get() /* create ref! */,
rados_req_remove_complete,
rados_req_remove_safe);
if (flags == 0) {
static void rados_write_aio_unlock_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<WriteCompletionData*>(arg);
+ auto cdata = ceph::ref_t<WriteCompletionData>(static_cast<WriteCompletionData*>(arg), false);
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
cdata->complete_unlock(comp->rval);
- cdata->put();
}
static void striper_write_aio_req_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<WriteCompletionData*>(arg);
+ auto cdata = ceph::ref_t<WriteCompletionData>(static_cast<WriteCompletionData*>(arg), false);
// launch the async unlocking of the object
cdata->m_striper->aio_unlockObject(cdata->m_soid, cdata->m_lockCookie, cdata->m_unlockCompletion);
// complete the write part in parallel
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
cdata->complete_write(comp->rval);
- cdata->put();
}
static void striper_write_aio_req_safe(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<WriteCompletionData*>(arg);
+ auto cdata = ceph::ref_t<WriteCompletionData>(static_cast<WriteCompletionData*>(arg), false);
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
cdata->safe(comp->rval);
- cdata->put();
}
int libradosstriper::RadosStriperImpl::write_in_open_object(const std::string& soid,
// create a completion object to be passed to the callbacks of the multicompletion
// we need 3 references as striper_write_aio_req_complete will release two and
// striper_write_aio_req_safe will release one
- WriteCompletionData *cdata = new WriteCompletionData(this, soid, lockCookie, 0, 3);
- cdata->get(); // local ref
+ auto cdata = ceph::make_ref<WriteCompletionData>(this, soid, lockCookie, nullptr);
// create a completion object for the unlocking of the striped object at the end of the write
librados::AioCompletion *unlock_completion =
- librados::Rados::aio_create_completion(cdata, rados_write_aio_unlock_complete, 0);
+ librados::Rados::aio_create_completion(cdata->get() /* create ref! */, rados_write_aio_unlock_complete, 0);
cdata->m_unlockCompletion = unlock_completion;
// create the multicompletion that will handle the write completion
MultiAioCompletionImplPtr c{new libradosstriper::MultiAioCompletionImpl,
false};
- c->set_complete_callback(cdata, striper_write_aio_req_complete);
- c->set_safe_callback(cdata, striper_write_aio_req_safe);
+ c->set_complete_callback(cdata->get() /* create ref! */, striper_write_aio_req_complete);
+ c->set_safe_callback(cdata->get() /* create ref! */, striper_write_aio_req_safe);
// call the asynchronous API
int rc = internal_aio_write(soid, c, bl, len, off, layout);
if (!rc) {
// return result
rc = c->get_return_value();
}
- cdata->put();
return rc;
}
// create a completion object to be passed to the callbacks of the multicompletion
// we need 3 references as striper_write_aio_req_complete will release two and
// striper_write_aio_req_safe will release one
- WriteCompletionData *cdata = new WriteCompletionData(this, soid, lockCookie, c, 3);
- cdata->get(); // local ref
+ auto cdata = ceph::make_ref<WriteCompletionData>(this, soid, lockCookie, c);
m_ioCtxImpl->get();
c->io = m_ioCtxImpl;
// create a completion object for the unlocking of the striped object at the end of the write
librados::AioCompletion *unlock_completion =
- librados::Rados::aio_create_completion(cdata, rados_write_aio_unlock_complete, 0);
+ librados::Rados::aio_create_completion(cdata->get() /* create ref! */, rados_write_aio_unlock_complete, 0);
cdata->m_unlockCompletion = unlock_completion;
// create the multicompletion that will handle the write completion
libradosstriper::MultiAioCompletionImplPtr nc{
new libradosstriper::MultiAioCompletionImpl, false};
- nc->set_complete_callback(cdata, striper_write_aio_req_complete);
- nc->set_safe_callback(cdata, striper_write_aio_req_safe);
+ nc->set_complete_callback(cdata->get() /* create ref! */, striper_write_aio_req_complete);
+ nc->set_safe_callback(cdata->get() /* create ref! */, striper_write_aio_req_safe);
// internal asynchronous API
int rc = internal_aio_write(soid, nc, bl, len, off, layout);
- cdata->put();
return rc;
}
static void striper_truncate_aio_req_complete(rados_striper_multi_completion_t c, void *arg)
{
- auto cdata = reinterpret_cast<TruncateCompletionData*>(arg);
+ auto cdata = ceph::ref_t<TruncateCompletionData>(static_cast<TruncateCompletionData*>(arg), false);
libradosstriper::MultiAioCompletionImpl *comp =
reinterpret_cast<libradosstriper::MultiAioCompletionImpl*>(c);
if (0 == comp->rval) {
bl.append(oss.str());
cdata->m_striper->setxattr(cdata->m_soid, XATTR_SIZE, bl);
}
- cdata->put();
}
int libradosstriper::RadosStriperImpl::truncate(const std::string& soid,
uint64_t size,
ceph_file_layout &layout)
{
- TruncateCompletionData *cdata = new TruncateCompletionData(this, soid, size);
+ auto cdata = ceph::make_ref<TruncateCompletionData>(this, soid, size);
libradosstriper::MultiAioCompletionImplPtr multi_completion{
new libradosstriper::MultiAioCompletionImpl, false};
- multi_completion->set_complete_callback(cdata, striper_truncate_aio_req_complete);
+ multi_completion->set_complete_callback(cdata->get() /* create ref! */, striper_truncate_aio_req_complete);
// call asynchrous version of truncate
int rc = aio_truncate(soid, multi_completion, original_size, size, layout);
// wait for completion of the truncation
if (exists) {
// remove asynchronously
multi_completion->add_request();
- RadosRemoveCompletionData *data =
- new RadosRemoveCompletionData(multi_completion, cct());
+ auto data = ceph::make_ref<RadosRemoveCompletionData>(multi_completion, cct());
librados::AioCompletion *rados_completion =
- librados::Rados::aio_create_completion(data,
+ librados::Rados::aio_create_completion(data->get() /* create ref! */,
rados_req_remove_complete,
rados_req_remove_safe);
int rc = m_ioCtx.aio_remove(getObjectId(soid, objectno), rados_completion);
} else {
// removes are asynchronous in order to speed up truncations of big files
multi_completion->add_request();
- RadosRemoveCompletionData *data =
- new RadosRemoveCompletionData(multi_completion, cct());
+ auto data = ceph::make_ref<RadosRemoveCompletionData>(multi_completion, cct());
librados::AioCompletion *rados_completion =
- librados::Rados::aio_create_completion(data,
+ librados::Rados::aio_create_completion(data->get() /* create ref! */,
rados_req_remove_complete,
rados_req_remove_safe);
rc = m_ioCtx.aio_remove(getObjectId(soid, objectno), rados_completion);
ContextWQ *work_queue, SnapSeqs *snap_seqs,
ProgressContext *prog_ctx,
Context *on_finish)
- : RefCountedObject(dst_image_ctx->cct, 1), m_src_image_ctx(src_image_ctx),
+ : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
m_dst_image_ctx(dst_image_ctx), m_snap_id_start(snap_id_start),
m_snap_id_end(snap_id_end), m_flatten(flatten),
m_object_number(object_number), m_work_queue(work_queue),
ReplayHandler(Journal *_journal) : journal(_journal) {
}
- void get() override {
- // TODO
- }
- void put() override {
- // TODO
- }
-
void handle_entries_available() override {
journal->handle_replay_ready();
}
const SnapSeqs &snap_seqs,
ProgressContext *prog_ctx,
Context *on_finish)
- : RefCountedObject(dst_image_ctx->cct, 1), m_src_image_ctx(src_image_ctx),
+ : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
m_dst_image_ctx(dst_image_ctx), m_snap_id_start(snap_id_start),
m_snap_id_end(snap_id_end), m_flatten(flatten),
m_object_number(object_number), m_snap_seqs(snap_seqs),
bool flatten, ContextWQ *work_queue,
SnapSeqs *snap_seqs,
Context *on_finish)
- : RefCountedObject(dst_image_ctx->cct, 1), m_src_image_ctx(src_image_ctx),
+ : RefCountedObject(dst_image_ctx->cct), m_src_image_ctx(src_image_ctx),
m_dst_image_ctx(dst_image_ctx), m_snap_id_end(snap_id_end),
m_flatten(flatten), m_work_queue(work_queue), m_snap_seqs_result(snap_seqs),
m_snap_seqs(*snap_seqs), m_on_finish(on_finish), m_cct(dst_image_ctx->cct),
int DaemonServer::ms_handle_authentication(Connection *con)
{
- MgrSession *s = new MgrSession(cct);
+ auto s = ceph::make_ref<MgrSession>(cct);
con->set_priv(s);
s->inst.addr = con->get_peer_addr();
s->entity_name = con->peer_name;
pair<utime_t,utime_t> life_expectancy; ///< when device failure is expected
utime_t life_expectancy_stamp; ///< when life expectency was recorded
- DeviceState(const std::string& n)
- : RefCountedObject(nullptr, 0),
- devid(n) {}
-
void set_metadata(map<string,string>&& m);
void set_life_expectancy(utime_t from, utime_t to, utime_t now);
void dump(Formatter *f) const;
void print(ostream& out) const;
-};
-typedef boost::intrusive_ptr<DeviceState> DeviceStateRef;
+private:
+ FRIEND_MAKE_REF(DeviceState);
+ DeviceState(const std::string& n) : devid(n) {}
+};
/**
* Fuse the collection of per-daemon metadata from Ceph into
DaemonStateCollection all;
std::set<DaemonKey> updating;
- std::map<std::string,DeviceStateRef> devices;
+ std::map<std::string,ceph::ref_t<DeviceState>> devices;
void _erase(const DaemonKey& dmk);
- DeviceStateRef _get_or_create_device(const std::string& dev) {
- auto p = devices.find(dev);
- if (p != devices.end()) {
- return p->second;
+ ceph::ref_t<DeviceState> _get_or_create_device(const std::string& dev) {
+ auto em = devices.try_emplace(dev, nullptr);
+ auto& d = em.first->second;
+ if (em.second) {
+ d = ceph::make_ref<DeviceState>(dev);
}
- devices[dev] = new DeviceState(dev);
- return devices[dev];
+ return d;
}
- void _erase_device(DeviceStateRef d) {
+ void _erase_device(const ceph::ref_t<DeviceState>& d) {
devices.erase(d->devid);
}
std::set<std::string> declared_types;
- explicit MgrSession(CephContext *cct) : RefCountedObject(cct, 0) {}
- ~MgrSession() override {}
-
const entity_addr_t& get_peer_addr() {
return inst.addr;
}
+
+private:
+ FRIEND_MAKE_REF(MgrSession);
+ explicit MgrSession(CephContext *cct) : RefCountedObject(cct) {}
+ ~MgrSession() override = default;
};
-typedef boost::intrusive_ptr<MgrSession> MgrSessionRef;
+using MgrSessionRef = ceph::ref_t<MgrSession>;
#endif
// fake connection attached to forwarded messages
struct AnonConnection : public Connection {
entity_addr_t socket_addr;
- explicit AnonConnection(CephContext *cct,
- const entity_addr_t& sa)
- : Connection(cct, NULL),
- socket_addr(sa) {}
int send_message(Message *m) override {
ceph_assert(!"send_message on anonymous connection");
entity_addr_t get_peer_socket_addr() const override {
return socket_addr;
}
+
+private:
+ FRIEND_MAKE_REF(AnonConnection);
+ explicit AnonConnection(CephContext *cct, const entity_addr_t& sa)
+ : Connection(cct, nullptr),
+ socket_addr(sa) {}
};
//extract the original message and put it into the regular dispatch function
PaxosServiceMessage *req = m->claim_message();
ceph_assert(req != NULL);
- ConnectionRef c(new AnonConnection(cct, m->client_socket_addr));
+ auto c = ceph::make_ref<AnonConnection>(cct, m->client_socket_addr);
MonSession *s = new MonSession(static_cast<Connection*>(c.get()));
s->_ident(req->get_source(),
req->get_source_addrs());
#include <stdlib.h>
#include <ostream>
-#include <boost/intrusive_ptr.hpp>
-
#include "auth/Auth.h"
#include "common/RefCountedObj.h"
#include "common/config.h"
#include "common/debug.h"
+#include "common/ref.h"
#include "common/ceph_mutex.h"
#include "include/ceph_assert.h" // Because intusive_ptr clobbers our assert...
#include "include/buffer.h"
class Interceptor;
#endif
-struct Connection : public RefCountedObject {
+struct Connection : public RefCountedObjectSafe {
mutable ceph::mutex lock = ceph::make_mutex("Connection::lock");
Messenger *msgr;
RefCountedPtr priv;
- int peer_type;
+ int peer_type = -1;
int64_t peer_id = -1; // [msgr2 only] the 0 of osd.0, 4567 or client.4567
safe_item_history<entity_addrvec_t> peer_addrs;
utime_t last_keepalive, last_keepalive_ack;
private:
- uint64_t features;
+ uint64_t features = 0;
public:
- bool is_loopback;
- bool failed; // true if we are a lossy connection that has failed.
+ bool is_loopback = false;
+ bool failed = false; // true if we are a lossy connection that has failed.
- int rx_buffers_version;
+ int rx_buffers_version = 0;
std::map<ceph_tid_t,std::pair<ceph::buffer::list, int>> rx_buffers;
// authentication state
Interceptor *interceptor;
#endif
- friend class boost::intrusive_ptr<Connection>;
friend class PipeConnection;
public:
- Connection(CephContext *cct, Messenger *m)
- // we are managed exclusively by ConnectionRef; make it so you can
- // ConnectionRef foo = new Connection;
- : RefCountedObject(cct, 0),
- msgr(m),
- peer_type(-1),
- features(0),
- is_loopback(false),
- failed(false),
- rx_buffers_version(0) {
- }
-
- ~Connection() override {
- //generic_dout(0) << "~Connection " << this << dendl;
- }
-
void set_priv(const RefCountedPtr& o) {
std::lock_guard l{lock};
priv = o;
last_keepalive_ack = t;
}
bool is_blackhole() const;
-};
-typedef boost::intrusive_ptr<Connection> ConnectionRef;
+protected:
+ Connection(CephContext *cct, Messenger *m)
+ : RefCountedObjectSafe(cct),
+ msgr(m)
+ {}
+
+ ~Connection() override {
+ //generic_dout(0) << "~Connection " << this << dendl;
+ }
+};
+using ConnectionRef = ceph::ref_t<Connection>;
#endif /* CEPH_CONNECTION_H */
AsyncConnection::AsyncConnection(CephContext *cct, AsyncMessenger *m, DispatchQueue *q,
Worker *w, bool m2, bool local)
- : Connection(cct, m), delay_state(NULL), async_msgr(m), conn_id(q->get_id()),
+ : Connection(cct, m),
+ delay_state(NULL), async_msgr(m), conn_id(q->get_id()),
logger(w->get_perf_counter()),
state(STATE_NONE), port(-1),
dispatch_queue(q), recv_buf(NULL),
* sequence, try to reconnect peer endpoint.
*/
class AsyncConnection : public Connection {
-
ssize_t read(unsigned len, char *buffer,
std::function<void(char *, ssize_t)> callback);
ssize_t read_until(unsigned needed, char *p);
void flush();
} *delay_state;
- public:
+private:
+ FRIEND_MAKE_REF(AsyncConnection);
AsyncConnection(CephContext *cct, AsyncMessenger *m, DispatchQueue *q,
Worker *w, bool is_msgr2, bool local);
~AsyncConnection() override;
+public:
void maybe_start_delay_thread();
ostream& _conn_prefix(std::ostream *_dout);
friend class ProtocolV2;
}; /* AsyncConnection */
-typedef boost::intrusive_ptr<AsyncConnection> AsyncConnectionRef;
+using AsyncConnectionRef = ceph::ref_t<AsyncConnection>;
#endif
stack = single->stack.get();
stack->start();
local_worker = stack->get_worker();
- local_connection = new AsyncConnection(cct, this, &dispatch_queue,
+ local_connection = ceph::make_ref<AsyncConnection>(cct, this, &dispatch_queue,
local_worker, true, true);
init_local_connection();
reap_handler = new C_handle_reap(this);
const entity_addr_t &peer_addr)
{
std::lock_guard l{lock};
- AsyncConnectionRef conn = new AsyncConnection(cct, this, &dispatch_queue, w,
+ auto conn = ceph::make_ref<AsyncConnection>(cct, this, &dispatch_queue, w,
listen_addr.is_msgr2(), false);
conn->accept(std::move(cli_socket), listen_addr, peer_addr);
accepting_conns.insert(conn);
// create connection
Worker *w = stack->get_worker();
- AsyncConnectionRef conn = new AsyncConnection(cct, this, &dispatch_queue, w,
+ auto conn = ceph::make_ref<AsyncConnection>(cct, this, &dispatch_queue, w,
target.is_msgr2(), false);
conn->connect(addrs, type, target);
ceph_assert(!conns.count(addrs));
struct CollectionImpl : public RefCountedObject {
const coll_t cid;
- CollectionImpl(const coll_t& c)
- : RefCountedObject(NULL, 0),
- cid(c) {}
-
/// wait for any queued transactions to apply
// block until any previous transactions are visible. specifically,
// collection_list and collection_empty need to reflect prior operations.
const coll_t &get_cid() {
return cid;
}
+ protected:
+ CollectionImpl() = delete;
+ CollectionImpl(CephContext* cct, const coll_t& c) : RefCountedObject(cct), cid(c) {}
+ ~CollectionImpl() = default;
};
- typedef boost::intrusive_ptr<CollectionImpl> CollectionHandle;
+ using CollectionHandle = ceph::ref_t<CollectionImpl>;
/*********************************
dout(1) << __func__ << " uuid " << super.uuid << dendl;
// init log
- FileRef log_file = new File;
+ FileRef log_file = ceph::make_ref<File>();
log_file->fnode.ino = 1;
log_file->fnode.prefer_bdev = BDEV_WAL;
int r = _allocate(
if (!noop) {
map<string,DirRef>::iterator q = dir_map.find(dirname);
ceph_assert(q == dir_map.end());
- dir_map[dirname] = new Dir;
+ dir_map[dirname] = ceph::make_ref<Dir>();
}
}
break;
{
auto p = file_map.find(ino);
if (p == file_map.end()) {
- FileRef f = new File;
+ FileRef f = ceph::make_ref<File>();
file_map[ino] = f;
dout(30) << __func__ << " ino " << ino << " = " << f
<< " (new)" << dendl;
// create a new log [writer] so that we know compaction is in progress
// (see _should_compact_log)
- new_log = new File;
+ new_log = ceph::make_ref<File>();
new_log->fnode.ino = 0; // so that _flush_range won't try to log the fnode
// 0. wait for any racing flushes to complete. (We do not want to block
<< " does not exist" << dendl;
return -ENOENT;
}
- file = new File;
+ file = ceph::make_ref<File>();
file->fnode.ino = ++ino_last;
file_map[ino_last] = file;
dir->file_map[filename] = file;
dout(20) << __func__ << " dir " << dirname << " exists" << dendl;
return -EEXIST;
}
- dir_map[dirname] = new Dir;
+ dir_map[dirname] = ceph::make_ref<Dir>();
log_t.op_dir_create(dirname);
return 0;
}
}
DirRef dir = p->second;
map<string,FileRef>::iterator q = dir->file_map.find(filename);
- File *file;
+ FileRef file;
if (q == dir->file_map.end()) {
dout(20) << __func__ << " dir " << dirname << " (" << dir
<< ") file " << filename
<< " not found, creating" << dendl;
- file = new File;
+ file = ceph::make_ref<File>();
file->fnode.ino = ++ino_last;
file->fnode.mtime = ceph_clock_now();
file_map[ino_last] = file;
log_t.op_file_update(file->fnode);
log_t.op_dir_link(dirname, filename, file->fnode.ino);
} else {
- file = q->second.get();
+ file = q->second;
if (file->locked) {
dout(10) << __func__ << " already locked" << dendl;
return -ENOLCK;
#include <mutex>
#include "bluefs_types.h"
-#include "common/RefCountedObj.h"
#include "BlockDevice.h"
+#include "common/RefCountedObj.h"
+#include "common/ceph_context.h"
+#include "global/global_context.h"
+
#include "boost/intrusive/list.hpp"
-#include <boost/intrusive_ptr.hpp>
class PerfCounters;
std::atomic_int num_readers, num_writers;
std::atomic_int num_reading;
+ private:
+ FRIEND_MAKE_REF(File);
File()
- : RefCountedObject(NULL, 0),
+ :
refs(0),
dirty_seq(0),
locked(false),
ceph_assert(num_reading.load() == 0);
ceph_assert(!locked);
}
-
- friend void intrusive_ptr_add_ref(File *f) {
- f->get();
- }
- friend void intrusive_ptr_release(File *f) {
- f->put();
- }
};
- typedef boost::intrusive_ptr<File> FileRef;
+ using FileRef = ceph::ref_t<File>;
typedef boost::intrusive::list<
File,
mempool::bluefs::map<string,FileRef> file_map;
- Dir() : RefCountedObject(NULL, 0) {}
-
- friend void intrusive_ptr_add_ref(Dir *d) {
- d->get();
- }
- friend void intrusive_ptr_release(Dir *d) {
- d->put();
- }
+ private:
+ FRIEND_MAKE_REF(Dir);
+ Dir() = default;
};
- typedef boost::intrusive_ptr<Dir> DirRef;
+ using DirRef = ceph::ref_t<Dir>;
struct FileWriter {
MEMPOOL_CLASS_HELPERS();
FileRef file;
- uint64_t pos; ///< start offset for buffer
+ uint64_t pos = 0; ///< start offset for buffer
bufferlist buffer; ///< new data to write (at end of file)
bufferlist tail_block; ///< existing partial block at end of file, if any
bufferlist::page_aligned_appender buffer_appender; //< for const char* only
FileWriter(FileRef f)
: file(f),
- pos(0),
buffer_appender(buffer.get_page_aligned_appender(
g_conf()->bluefs_alloc_size / CEPH_PAGE_SIZE)) {
++file->num_writers;
#define dout_prefix *_dout << "bluestore(" << store->path << ").collection(" << cid << " " << this << ") "
BlueStore::Collection::Collection(BlueStore *store_, OnodeCacheShard *oc, BufferCacheShard *bc, coll_t cid)
- : CollectionImpl(cid),
+ : CollectionImpl(store_->cct, cid),
store(store_),
cache(bc),
exists(true),
it->next()) {
coll_t cid;
if (cid.parse(it->key())) {
- CollectionRef c(
- new Collection(
+ auto c = ceph::make_ref<Collection>(
this,
onode_cache_shards[cid.hash_to_shard(onode_cache_shards.size())],
buffer_cache_shards[cid.hash_to_shard(buffer_cache_shards.size())],
- cid));
+ cid);
bufferlist bl = it->value();
auto p = bl.cbegin();
try {
const coll_t& cid)
{
std::unique_lock l{coll_lock};
- Collection *c = new Collection(
+ auto c = ceph::make_ref<Collection>(
this,
onode_cache_shards[cid.hash_to_shard(onode_cache_shards.size())],
buffer_cache_shards[cid.hash_to_shard(buffer_cache_shards.size())],
cid);
new_coll_map[cid] = c;
- _osr_attach(c);
+ _osr_attach(c.get());
return c;
}
std::lock_guard l(zombie_osr_lock);
auto p = zombie_osr_set.find(c->cid);
if (p == zombie_osr_set.end()) {
- c->osr = new OpSequencer(this, c->cid);
+ c->osr = ceph::make_ref<OpSequencer>(this, c->cid);
ldout(cct, 10) << __func__ << " " << c->cid
<< " fresh osr " << c->osr << dendl;
} else {
};
class OpSequencer;
- typedef boost::intrusive_ptr<OpSequencer> OpSequencerRef;
+ using OpSequencerRef = ceph::ref_t<OpSequencer>;
struct Collection : public CollectionImpl {
BlueStore *store;
std::atomic_bool zombie = {false}; ///< in zombie_osr set (collection going away)
- OpSequencer(BlueStore *store, const coll_t& c)
- : RefCountedObject(store->cct, 0),
- store(store), cid(c) {
- }
- ~OpSequencer() {
- ceph_assert(q.empty());
- }
-
void queue_new(TransContext *txc) {
std::lock_guard l(qlock);
txc->seq = ++last_seq;
txc->oncommits.push_back(c);
return false;
}
+ private:
+ FRIEND_MAKE_REF(OpSequencer);
+ OpSequencer(BlueStore *store, const coll_t& c)
+ : RefCountedObject(store->cct),
+ store(store), cid(c) {
+ }
+ ~OpSequencer() {
+ ceph_assert(q.empty());
+ }
};
typedef boost::intrusive::list<
for (vector<coll_t>::iterator p = ls.begin(); p != ls.end(); ++p) {
if (p->is_temp())
continue;
- coll_map[*p] = new OpSequencer(cct, ++next_osr_id, *p);
+ coll_map[*p] = ceph::make_ref<OpSequencer>(cct, ++next_osr_id, *p);
if (p->is_meta())
continue;
coll_t temp = p->get_temp();
std::lock_guard l{coll_lock};
auto p = coll_map.find(c);
if (p == coll_map.end()) {
- auto *r = new OpSequencer(cct, ++next_osr_id, c);
+ auto r = ceph::make_ref<OpSequencer>(cct, ++next_osr_id, c);
coll_map[c] = r;
return r;
} else {
}
}
+ private:
+ FRIEND_MAKE_REF(OpSequencer);
OpSequencer(CephContext* cct, int i, coll_t cid)
- : CollectionImpl(cid),
+ : CollectionImpl(cct, cid),
cct(cct),
osr_name_str(stringify(cid)),
id(i),
#define dout_prefix *_dout << "kstore(" << store->path << ").collection(" << cid << ") "
KStore::Collection::Collection(KStore *ns, coll_t cid)
- : CollectionImpl(cid),
+ : CollectionImpl(ns->cct, cid),
store(ns),
osr(new OpSequencer()),
onode_map(store->cct)
it->next()) {
coll_t cid;
if (cid.parse(it->key())) {
- CollectionRef c(new Collection(this, cid));
+ auto c = ceph::make_ref<Collection>(this, cid);
bufferlist bl = it->value();
auto p = bl.cbegin();
try {
ObjectStore::CollectionHandle KStore::create_new_collection(const coll_t& cid)
{
- auto *c = new Collection(this, cid);
+ auto c = ceph::make_ref<Collection>(this, cid);
std::unique_lock l{coll_lock};
new_coll_map[cid] = c;
return c;
void flush() override;
bool flush_commit(Context *c) override;
+ private:
+ FRIEND_MAKE_REF(Collection);
Collection(KStore *ns, coll_t c);
};
- typedef boost::intrusive_ptr<Collection> CollectionRef;
+ using CollectionRef = ceph::ref_t<Collection>;
class OmapIteratorImpl : public ObjectMap::ObjectMapIteratorImpl {
CollectionRef c;
int r = cbl.read_file(fn.c_str(), &err);
if (r < 0)
return r;
- CollectionRef c(new Collection(cct, *q));
+ auto c = ceph::make_ref<Collection>(cct, *q);
auto p = cbl.cbegin();
c->decode(p);
coll_map[*q] = c;
ObjectStore::CollectionHandle MemStore::create_new_collection(const coll_t& cid)
{
std::lock_guard l{coll_lock};
- Collection *c = new Collection(cct, cid);
+ auto c = ceph::make_ref<Collection>(cct, cid);
new_coll_map[cid] = c;
return c;
}
static thread_local PageSet::page_vector tls_pages;
#endif
- explicit PageSetObject(size_t page_size) : data(page_size), data_len(0) {}
-
size_t get_size() const override { return data_len; }
int read(uint64_t offset, uint64_t len, bufferlist &bl) override;
decode_base(p);
DECODE_FINISH(p);
}
+
+private:
+ FRIEND_MAKE_REF(PageSetObject);
+ explicit PageSetObject(size_t page_size) : data(page_size), data_len(0) {}
};
#if defined(__GLIBCXX__)
MemStore::ObjectRef MemStore::Collection::create_object() const {
if (use_page_set)
- return new PageSetObject(cct->_conf->memstore_page_size);
+ return ceph::make_ref<PageSetObject>(cct->_conf->memstore_page_size);
return new BufferlistObject();
}
bufferlist omap_header;
map<string,bufferlist> omap;
- typedef boost::intrusive_ptr<Object> Ref;
- friend void intrusive_ptr_add_ref(Object *o) { o->get(); }
- friend void intrusive_ptr_release(Object *o) { o->put(); }
+ using Ref = ceph::ref_t<Object>;
- Object() : RefCountedObject(nullptr, 0) {}
// interface for object data
virtual size_t get_size() const = 0;
virtual int read(uint64_t offset, uint64_t len, bufferlist &bl) = 0;
}
f->close_section();
}
+ protected:
+ Object() = default;
};
- typedef Object::Ref ObjectRef;
+ using ObjectRef = Object::Ref;
struct PageSetObject;
struct Collection : public CollectionImpl {
ceph::make_mutex("MemStore::Collection::sequencer_mutex")};
typedef boost::intrusive_ptr<Collection> Ref;
- friend void intrusive_ptr_add_ref(Collection *c) { c->get(); }
- friend void intrusive_ptr_release(Collection *c) { c->put(); }
ObjectRef create_object() const;
return true;
}
+ private:
+ FRIEND_MAKE_REF(Collection);
explicit Collection(CephContext *cct, coll_t c)
- : CollectionImpl(c),
+ : CollectionImpl(cct, c),
cct(cct),
use_page_set(cct->_conf->memstore_page_set) {}
};
hb_stamps.resize(peer + 1);
}
if (!hb_stamps[peer]) {
- hb_stamps[peer].reset(new HeartbeatStamps(peer));
+ hb_stamps[peer] = ceph::make_ref<HeartbeatStamps>(peer);
}
return hb_stamps[peer];
}
auto stamps = service.get_hb_stamps(p);
- Session *sb = new Session(cct, cons.first.get());
+ auto sb = ceph::make_ref<Session>(cct, cons.first.get());
sb->peer = p;
sb->stamps = stamps;
- RefCountedPtr sbref{sb, false};
hi->hb_interval_start = ceph_clock_now();
hi->con_back = cons.first.get();
- hi->con_back->set_priv(sbref);
+ hi->con_back->set_priv(sb);
- Session *sf = new Session(cct, cons.second.get());
+ auto sf = ceph::make_ref<Session>(cct, cons.second.get());
sf->peer = p;
sf->stamps = stamps;
- RefCountedPtr sfref{sf, false};
hi->con_front = cons.second.get();
- hi->con_front->set_priv(sfref);
+ hi->con_front->set_priv(sf);
dout(10) << "_add_heartbeat_peer: new peer osd." << p
<< " " << hi->con_back->get_peer_addr()
{
if (con->get_peer_type() != CEPH_ENTITY_TYPE_MON &&
con->get_peer_type() != CEPH_ENTITY_TYPE_MGR) {
- auto priv = con->get_priv();
- auto s = static_cast<Session*>(priv.get());
- if (!s) {
- s = new Session{cct, con};
- con->set_priv(RefCountedPtr{s, false});
+ if (auto s = ceph::ref_cast<Session>(con->get_priv()); !s) {
+ s = ceph::make_ref<Session>(cct, con);
+ con->set_priv(s);
dout(10) << " new session (outgoing) " << s << " con=" << s->con
<< " addr=" << s->con->get_peer_addr() << dendl;
// we don't connect to clients
{
if (con->get_peer_type() != CEPH_ENTITY_TYPE_MON &&
con->get_peer_type() != CEPH_ENTITY_TYPE_MGR) {
- auto priv = con->get_priv();
- auto s = static_cast<Session*>(priv.get());
- if (!s) {
- s = new Session{cct, con};
- con->set_priv(RefCountedPtr{s, false});
+ if (auto s = ceph::ref_cast<Session>(con->get_priv()); !s) {
+ s = ceph::make_ref<Session>(cct, con);
+ con->set_priv(s);
dout(10) << "new session (incoming)" << s << " con=" << con
<< " addr=" << con->get_peer_addr()
<< " must have raced with connect" << dendl;
bool OSD::ms_handle_reset(Connection *con)
{
- auto s = con->get_priv();
- auto session = static_cast<Session*>(s.get());
- dout(2) << "ms_handle_reset con " << con << " session " << session << dendl;
+ auto session = ceph::ref_cast<Session>(con->get_priv());
+ dout(2) << "ms_handle_reset con " << con << " session " << session.get() << dendl;
if (!session)
return false;
session->wstate.reset(con);
// note that we break session->con *before* the session_handle_reset
// cleanup below. this avoids a race between us and
// PG::add_backoff, Session::check_backoff, etc.
- session_handle_reset(SessionRef{session});
+ session_handle_reset(session);
return true;
}
if (!cct->_conf->osd_fast_fail_on_connection_refused)
return false;
- auto priv = con->get_priv();
- auto session = static_cast<Session*>(priv.get());
- dout(2) << "ms_handle_refused con " << con << " session " << session << dendl;
+ auto session = ceph::ref_cast<Session>(con->get_priv());
+ dout(2) << "ms_handle_refused con " << con << " session " << session.get() << dendl;
if (!session)
return false;
int type = con->get_peer_type();
void OSD::handle_command(MCommand *m)
{
ConnectionRef con = m->get_connection();
- auto priv = con->get_priv();
- auto session = static_cast<Session *>(priv.get());
+ auto session = ceph::ref_cast<Session>(con->get_priv());
if (!session) {
con->send_message(new MCommandReply(m, -EPERM));
m->put();
}
OSDCap& caps = session->caps;
- priv.reset();
if (!caps.allow_all() || m->get_source().is_mon()) {
con->send_message(new MCommandReply(m, -EPERM));
{
// NOTE: we assume caller hold something that keeps the Connection itself
// pinned (e.g., an OpRequest's MessageRef).
- auto priv = con->get_priv();
- auto session = static_cast<Session*>(priv.get());
+ auto session = ceph::ref_cast<Session>(con->get_priv());
if (!session) {
return;
}
session->sent_epoch_lock.unlock();
}
-void OSD::dispatch_session_waiting(SessionRef session, OSDMapRef osdmap)
+void OSD::dispatch_session_waiting(const ceph::ref_t<Session>& session, OSDMapRef osdmap)
{
ceph_assert(ceph_mutex_is_locked(session->session_dispatch_lock));
int OSD::ms_handle_authentication(Connection *con)
{
int ret = 0;
- auto priv = con->get_priv();
- Session *s = static_cast<Session*>(priv.get());
+ auto s = ceph::ref_cast<Session>(con->get_priv());
if (!s) {
- s = new Session(cct, con);
- con->set_priv(RefCountedPtr{s, false});
+ s = ceph::make_ref<Session>(cct, con);
+ con->set_priv(s);
s->entity_name = con->get_peer_entity_name();
dout(10) << __func__ << " new session " << s << " con " << s->con
<< " entity " << s->entity_name
return;
}
- auto priv = m->get_connection()->get_priv();
- if (auto session = static_cast<Session *>(priv.get());
- session && !(session->entity_name.is_mon() ||
+ auto session = ceph::ref_cast<Session>(m->get_connection()->get_priv());
+ if (session && !(session->entity_name.is_mon() ||
session->entity_name.is_osd())) {
//not enough perms!
dout(10) << "got osd map from Session " << session
<< dendl;
ConnectionRef con = m->get_connection();
con->mark_down();
- auto priv = con->get_priv();
- if (auto s = static_cast<Session*>(priv.get()); s) {
+ if (auto s = ceph::ref_cast<Session>(con->get_priv()); s) {
if (!is_fast_dispatch)
s->session_dispatch_lock.lock();
clear_session_waiting_on_map(s);
// -- sessions --
private:
- void dispatch_session_waiting(SessionRef session, OSDMapRef osdmap);
+ void dispatch_session_waiting(const ceph::ref_t<Session>& session, OSDMapRef osdmap);
ceph::mutex session_waiting_lock = ceph::make_mutex("OSD::session_waiting_lock");
- set<SessionRef> session_waiting_for_map;
+ set<ceph::ref_t<Session>> session_waiting_for_map;
/// Caller assumes refs for included Sessions
- void get_sessions_waiting_for_map(set<SessionRef> *out) {
+ void get_sessions_waiting_for_map(set<ceph::ref_t<Session>> *out) {
std::lock_guard l(session_waiting_lock);
out->swap(session_waiting_for_map);
}
- void register_session_waiting_on_map(SessionRef session) {
+ void register_session_waiting_on_map(const ceph::ref_t<Session>& session) {
std::lock_guard l(session_waiting_lock);
session_waiting_for_map.insert(session);
}
- void clear_session_waiting_on_map(SessionRef session) {
+ void clear_session_waiting_on_map(const ceph::ref_t<Session>& session) {
std::lock_guard l(session_waiting_lock);
session_waiting_for_map.erase(session);
}
void dispatch_sessions_waiting_on_map() {
- set<SessionRef> sessions_to_check;
+ set<ceph::ref_t<Session>> sessions_to_check;
get_sessions_waiting_for_map(&sessions_to_check);
for (auto i = sessions_to_check.begin();
i != sessions_to_check.end();
sessions_to_check.erase(i++)) {
std::lock_guard l{(*i)->session_dispatch_lock};
- SessionRef session = *i;
- dispatch_session_waiting(session, osdmap);
+ dispatch_session_waiting(*i, osdmap);
}
}
- void session_handle_reset(SessionRef session) {
+ void session_handle_reset(const ceph::ref_t<Session>& session) {
std::lock_guard l(session->session_dispatch_lock);
clear_session_waiting_on_map(session);
snap_mapper.update_bits(split_bits);
}
-void PG::add_backoff(SessionRef s, const hobject_t& begin, const hobject_t& end)
+void PG::add_backoff(const ceph::ref_t<Session>& s, const hobject_t& begin, const hobject_t& end)
{
- ConnectionRef con = s->con;
+ auto con = s->con;
if (!con) // OSD::ms_handle_reset clears s->con without a lock
return;
- BackoffRef b(s->have_backoff(info.pgid, begin));
+ auto b = s->have_backoff(info.pgid, begin);
if (b) {
derr << __func__ << " already have backoff for " << s << " begin " << begin
<< " " << *b << dendl;
ceph_abort();
}
std::lock_guard l(backoff_lock);
- {
- b = new Backoff(info.pgid, this, s, ++s->backoff_seq, begin, end);
- backoffs[begin].insert(b);
- s->add_backoff(b);
- dout(10) << __func__ << " session " << s << " added " << *b << dendl;
- }
+ b = ceph::make_ref<Backoff>(info.pgid, this, s, ++s->backoff_seq, begin, end);
+ backoffs[begin].insert(b);
+ s->add_backoff(b);
+ dout(10) << __func__ << " session " << s << " added " << *b << dendl;
con->send_message(
new MOSDBackoff(
info.pgid,
void PG::release_backoffs(const hobject_t& begin, const hobject_t& end)
{
dout(10) << __func__ << " [" << begin << "," << end << ")" << dendl;
- vector<BackoffRef> bv;
+ vector<ceph::ref_t<Backoff>> bv;
{
std::lock_guard l(backoff_lock);
auto p = backoffs.lower_bound(begin);
void PG::clear_backoffs()
{
dout(10) << __func__ << " " << dendl;
- map<hobject_t,set<BackoffRef>> ls;
+ map<hobject_t,set<ceph::ref_t<Backoff>>> ls;
{
std::lock_guard l(backoff_lock);
ls.swap(backoffs);
}
// called by Session::clear_backoffs()
-void PG::rm_backoff(BackoffRef b)
+void PG::rm_backoff(const ceph::ref_t<Backoff>& b)
{
dout(10) << __func__ << " " << *b << dendl;
std::lock_guard l(backoff_lock);
__u8 &);
static bool _has_removal_flag(ObjectStore *store, spg_t pgid);
- void rm_backoff(BackoffRef b);
+ void rm_backoff(const ceph::ref_t<Backoff>& b);
void update_snap_mapper_bits(uint32_t bits) {
snap_mapper.update_bits(bits);
// -- backoff --
ceph::mutex backoff_lock = // orders inside Backoff::lock
ceph::make_mutex("PG::backoff_lock");
- map<hobject_t,set<BackoffRef>> backoffs;
+ map<hobject_t,set<ceph::ref_t<Backoff>>> backoffs;
- void add_backoff(SessionRef s, const hobject_t& begin, const hobject_t& end);
+ void add_backoff(const ceph::ref_t<Session>& s, const hobject_t& begin, const hobject_t& end);
void release_backoffs(const hobject_t& begin, const hobject_t& end);
void release_backoffs(const hobject_t& o) {
release_backoffs(o, o);
}
void clear_backoffs();
- void add_pg_backoff(SessionRef s) {
+ void add_pg_backoff(const ceph::ref_t<Session>& s) {
hobject_t begin = info.pgid.pgid.get_hobj_start();
hobject_t end = info.pgid.pgid.get_hobj_end(pool.info.get_pg_num());
add_backoff(s, begin, end);
/// highest up_from we've seen from this rank
epoch_t up_from = 0;
- HeartbeatStamps(int o)
- : RefCountedObject(NULL, 0),
- osd(o) {}
-
void print(ostream& out) const {
std::lock_guard l(lock);
out << "hbstamp(osd." << osd << " up_from " << up_from
peer_clock_delta_ub = delta_ub;
}
+private:
+ FRIEND_MAKE_REF(HeartbeatStamps);
+ HeartbeatStamps(int o)
+ : RefCountedObject(NULL),
+ osd(o) {}
};
-typedef boost::intrusive_ptr<HeartbeatStamps> HeartbeatStampsRef;
+using HeartbeatStampsRef = ceph::ref_t<HeartbeatStamps>;
inline ostream& operator<<(ostream& out, const HeartbeatStamps& hb)
{
void PrimaryLogPG::handle_backoff(OpRequestRef& op)
{
auto m = op->get_req<MOSDBackoff>();
- SessionRef session{static_cast<Session*>(m->get_connection()->get_priv().get())};
+ auto session = ceph::ref_cast<Session>(m->get_connection()->get_priv());
if (!session)
return; // drop it.
hobject_t begin = info.pgid.pgid.get_hobj_start();
const Message *m = op->get_req();
int msg_type = m->get_type();
if (m->get_connection()->has_feature(CEPH_FEATURE_RADOS_BACKOFF)) {
- SessionRef session{static_cast<Session*>(m->get_connection()->get_priv().get())};
+ auto session = ceph::ref_cast<Session>(m->get_connection()->get_priv());
if (!session)
return; // drop it.
bool can_backoff =
m->get_connection()->has_feature(CEPH_FEATURE_RADOS_BACKOFF);
- SessionRef session;
+ ceph::ref_t<Session> session;
if (can_backoff) {
session = static_cast<Session*>(m->get_connection()->get_priv().get());
if (!session.get()) {
class C_OSD_OnOpCommit : public Context {
ReplicatedBackend *pg;
- ReplicatedBackend::InProgressOpRef op;
+ ceph::ref_t<ReplicatedBackend::InProgressOp> op;
public:
- C_OSD_OnOpCommit(ReplicatedBackend *pg, ReplicatedBackend::InProgressOp *op)
- : pg(pg), op(op) {}
+ C_OSD_OnOpCommit(ReplicatedBackend *pg, ceph::ref_t<ReplicatedBackend::InProgressOp> op)
+ : pg(pg), op(std::move(op)) {}
void finish(int) override {
pg->op_commit(op);
}
auto insert_res = in_progress_ops.insert(
make_pair(
tid,
- new InProgressOp(
+ ceph::make_ref<InProgressOp>(
tid, on_all_commit,
orig_op, at_version)
)
}
}
-void ReplicatedBackend::op_commit(
- InProgressOpRef& op)
+void ReplicatedBackend::op_commit(const ceph::ref_t<InProgressOp>& op)
{
if (op->on_commit == nullptr) {
// aborted
Context *on_commit;
OpRequestRef op;
eversion_t v;
- InProgressOp(
- ceph_tid_t tid, Context *on_commit,
- OpRequestRef op, eversion_t v)
- : RefCountedObject(nullptr, 0),
- tid(tid), on_commit(on_commit),
- op(op), v(v) {}
bool done() const {
return waiting_for_commit.empty();
}
+ private:
+ FRIEND_MAKE_REF(InProgressOp);
+ InProgressOp(ceph_tid_t tid, Context *on_commit, OpRequestRef op, eversion_t v)
+ :
+ tid(tid), on_commit(on_commit),
+ op(op), v(v) {}
};
- typedef boost::intrusive_ptr<InProgressOp> InProgressOpRef;
- map<ceph_tid_t, InProgressOpRef> in_progress_ops;
+ map<ceph_tid_t, ceph::ref_t<InProgressOp>> in_progress_ops;
public:
friend class C_OSD_OnOpCommit;
std::optional<pg_hit_set_history_t> &hset_history,
InProgressOp *op,
ObjectStore::Transaction &op_t);
- void op_commit(InProgressOpRef& op);
+ void op_commit(const ceph::ref_t<InProgressOp>& op);
void do_repop_reply(OpRequestRef op);
void do_repop(OpRequestRef op);
void Session::clear_backoffs()
{
- map<spg_t,map<hobject_t,set<BackoffRef>>> ls;
+ map<spg_t,map<hobject_t,set<ceph::ref_t<Backoff>>>> ls;
{
std::lock_guard l(backoff_lock);
ls.swap(backoffs);
bool Session::check_backoff(
CephContext *cct, spg_t pgid, const hobject_t& oid, const Message *m)
{
- BackoffRef b(have_backoff(pgid, oid));
+ auto b = have_backoff(pgid, oid);
if (b) {
dout(10) << __func__ << " session " << this << " has backoff " << *b
<< " for " << *m << dendl;
//#define PG_DEBUG_REFS
-struct Session;
-typedef boost::intrusive_ptr<Session> SessionRef;
-struct Backoff;
-typedef boost::intrusive_ptr<Backoff> BackoffRef;
class PG;
#ifdef PG_DEBUG_REFS
#include "common/tracked_int_ptr.hpp"
// - both null (teardown), or
// - only session is set (and state == DELETING)
PGRef pg; ///< owning pg
- SessionRef session; ///< owning session
+ ceph::ref_t<class Session> session; ///< owning session
hobject_t begin, end; ///< [) range to block, unless ==, then single obj
- Backoff(spg_t pgid, PGRef pg, SessionRef s,
- uint64_t i,
- const hobject_t& b, const hobject_t& e)
- : RefCountedObject(g_ceph_context, 0),
- pgid(pgid),
- id(i),
- pg(pg),
- session(s),
- begin(b),
- end(e) {}
-
friend ostream& operator<<(ostream& out, const Backoff& b) {
return out << "Backoff(" << &b << " " << b.pgid << " " << b.id
<< " " << b.get_state_name()
<< " session " << b.session
<< " pg " << b.pg << ")";
}
+
+private:
+ FRIEND_MAKE_REF(Backoff);
+ Backoff(spg_t pgid, PGRef pg, ceph::ref_t<Session> s,
+ uint64_t i,
+ const hobject_t& b, const hobject_t& e)
+ : RefCountedObject(g_ceph_context),
+ pgid(pgid),
+ id(i),
+ pg(pg),
+ session(std::move(s)),
+ begin(b),
+ end(e) {}
};
boost::intrusive::list<OpRequest> waiting_on_map;
ceph::spinlock sent_epoch_lock;
- epoch_t last_sent_epoch;
+ epoch_t last_sent_epoch = 0;
/// protects backoffs; orders inside Backoff::lock *and* PG::backoff_lock
ceph::mutex backoff_lock = ceph::make_mutex("Session::backoff_lock");
std::atomic<int> backoff_count= {0}; ///< simple count of backoffs
- map<spg_t,map<hobject_t,set<BackoffRef>>> backoffs;
+ map<spg_t,map<hobject_t,set<ceph::ref_t<Backoff>>>> backoffs;
std::atomic<uint64_t> backoff_seq = {0};
int peer = -1;
HeartbeatStampsRef stamps;
- explicit Session(CephContext *cct, Connection *con_) :
- RefCountedObject(cct),
- con(con_),
- socket_addr(con_->get_peer_socket_addr()),
- wstate(cct),
- last_sent_epoch(0)
- {}
-
entity_addr_t& get_peer_socket_addr() {
return socket_addr;
}
const hobject_t& start,
const hobject_t& end);
- BackoffRef have_backoff(spg_t pgid, const hobject_t& oid) {
+ ceph::ref_t<Backoff> have_backoff(spg_t pgid, const hobject_t& oid) {
if (!backoff_count.load()) {
return nullptr;
}
bool check_backoff(
CephContext *cct, spg_t pgid, const hobject_t& oid, const Message *m);
- void add_backoff(BackoffRef b) {
+ void add_backoff(ceph::ref_t<Backoff> b) {
std::lock_guard l(backoff_lock);
ceph_assert(!backoff_count == backoffs.empty());
- backoffs[b->pgid][b->begin].insert(b);
+ backoffs[b->pgid][b->begin].insert(std::move(b));
++backoff_count;
}
// called by PG::release_*_backoffs and PG::clear_backoffs()
- void rm_backoff(BackoffRef b) {
+ void rm_backoff(const ceph::ref_t<Backoff>& b) {
std::lock_guard l(backoff_lock);
ceph_assert(ceph_mutex_is_locked_by_me(b->lock));
ceph_assert(b->session == this);
ceph_assert(!backoff_count == backoffs.empty());
}
void clear_backoffs();
+
+private:
+ FRIEND_MAKE_REF(Session);
+ explicit Session(CephContext *cct, Connection *con_) :
+ RefCountedObject(cct),
+ con(con_),
+ socket_addr(con_->get_peer_socket_addr()),
+ wstate(cct)
+ {}
};
#endif
/// clear this pointer) before dropping its own reference
std::atomic<Connection*> reply_connection{nullptr};
- public:
+ private:
+ FRIEND_MAKE_REF(DirectConnection);
DirectConnection(CephContext *cct, DirectMessenger *m,
DispatchStrategy *dispatchers)
: Connection(cct, m),
dispatchers(dispatchers)
{}
+ public:
/// sets the Connection that will receive replies to outgoing messages
void set_direct_reply_connection(ConnectionRef conn);
entity_name_t name,
DispatchStrategy *dispatchers)
{
- auto loopback = boost::intrusive_ptr<DirectConnection>(
- new DirectConnection(m->cct, m, dispatchers));
+ auto loopback = ceph::make_ref<DirectConnection>(m->cct, m, dispatchers);
// loopback replies go to itself
loopback->set_direct_reply_connection(loopback);
loopback->set_peer_type(name.type());
peer_inst = peer->get_myinst();
// allocate a Connection that dispatches to the peer messenger
- auto direct_connection = boost::intrusive_ptr<DirectConnection>(
- new DirectConnection(cct, peer, peer->dispatchers.get()));
+ auto direct_connection = ceph::make_ref<DirectConnection>(cct, peer, peer->dispatchers.get());
direct_connection->set_peer_addr(peer_inst.addr);
direct_connection->set_peer_type(peer_inst.name.type());
return cls::journal::client::create(m_ioctx, oid, order, splay_width, -1);
}
-journal::JournalMetadataPtr RadosTestFixture::create_metadata(
+ceph::ref_t<journal::JournalMetadata> RadosTestFixture::create_metadata(
const std::string &oid, const std::string &client_id,
double commit_interval, int max_concurrent_object_sets) {
journal::Settings settings;
settings.commit_interval = commit_interval;
settings.max_concurrent_object_sets = max_concurrent_object_sets;
- journal::JournalMetadataPtr metadata(new journal::JournalMetadata(
- m_work_queue, m_timer, &m_timer_lock, m_ioctx, oid, client_id, settings));
+ auto metadata = ceph::make_ref<journal::JournalMetadata>(
+ m_work_queue, m_timer, &m_timer_lock, m_ioctx, oid, client_id, settings);
m_metadatas.push_back(metadata);
return metadata;
}
return bl;
}
-int RadosTestFixture::init_metadata(journal::JournalMetadataPtr metadata) {
+int RadosTestFixture::init_metadata(const ceph::ref_t<journal::JournalMetadata>& metadata) {
C_SaferCond cond;
metadata->init(&cond);
return cond.wait();
}
-bool RadosTestFixture::wait_for_update(journal::JournalMetadataPtr metadata) {
+bool RadosTestFixture::wait_for_update(const ceph::ref_t<journal::JournalMetadata>& metadata) {
std::unique_lock locker{m_listener.mutex};
while (m_listener.updates[metadata.get()] == 0) {
if (m_listener.cond.wait_for(locker, 10s) == std::cv_status::timeout) {
int create(const std::string &oid, uint8_t order = 14,
uint8_t splay_width = 2);
- journal::JournalMetadataPtr create_metadata(const std::string &oid,
+ ceph::ref_t<journal::JournalMetadata> create_metadata(const std::string &oid,
const std::string &client_id = "client",
double commit_internal = 0.1,
int max_concurrent_object_sets = 0);
}
};
- int init_metadata(journal::JournalMetadataPtr metadata);
+ int init_metadata(const ceph::ref_t<journal::JournalMetadata>& metadata);
- bool wait_for_update(journal::JournalMetadataPtr metadata);
+ bool wait_for_update(const ceph::ref_t<journal::JournalMetadata>& metadata);
static std::string _pool_name;
static librados::Rados _rados;
Listener m_listener;
- std::list<journal::JournalMetadataPtr> m_metadatas;
+ std::list<ceph::ref_t<journal::JournalMetadata>> m_metadatas;
};
class TestFutureImpl : public RadosTestFixture {
public:
struct FlushHandler : public journal::FutureImpl::FlushHandler {
- uint64_t refs;
- uint64_t flushes;
- FlushHandler() : refs(0), flushes(0) {}
- void get() override {
- ++refs;
- }
- void put() override {
- ceph_assert(refs > 0);
- --refs;
- }
- void flush(const journal::FutureImplPtr &future) override {
+ uint64_t flushes = 0;
+ void flush(const ceph::ref_t<journal::FutureImpl>& future) override {
++flushes;
}
+ FlushHandler() = default;
};
- journal::FutureImplPtr create_future(uint64_t tag_tid, uint64_t entry_tid,
- uint64_t commit_tid,
- const journal::FutureImplPtr &prev =
- journal::FutureImplPtr()) {
- journal::FutureImplPtr future(new journal::FutureImpl(tag_tid,
- entry_tid,
- commit_tid));
+ TestFutureImpl() {
+ m_flush_handler = std::make_shared<FlushHandler>();
+ }
+
+ auto create_future(uint64_t tag_tid, uint64_t entry_tid,
+ uint64_t commit_tid,
+ ceph::ref_t<journal::FutureImpl> prev = nullptr) {
+ auto future = ceph::make_ref<journal::FutureImpl>(tag_tid, entry_tid, commit_tid);
future->init(prev);
return future;
}
- void flush(const journal::FutureImplPtr &future) {
+ void flush(const ceph::ref_t<journal::FutureImpl>& future) {
}
- FlushHandler m_flush_handler;
+ std::shared_ptr<FlushHandler> m_flush_handler;
};
TEST_F(TestFutureImpl, Getters) {
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
+ auto future = create_future(234, 123, 456);
ASSERT_EQ(234U, future->get_tag_tid());
ASSERT_EQ(123U, future->get_entry_tid());
ASSERT_EQ(456U, future->get_commit_tid());
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
- ASSERT_FALSE(future->attach(&m_flush_handler));
- ASSERT_EQ(1U, m_flush_handler.refs);
+ auto future = create_future(234, 123, 456);
+ ASSERT_FALSE(future->attach(m_flush_handler));
+ ASSERT_EQ(2U, m_flush_handler.use_count());
}
TEST_F(TestFutureImpl, AttachWithPendingFlush) {
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
+ auto future = create_future(234, 123, 456);
future->flush(NULL);
- ASSERT_TRUE(future->attach(&m_flush_handler));
- ASSERT_EQ(1U, m_flush_handler.refs);
+ ASSERT_TRUE(future->attach(m_flush_handler));
+ ASSERT_EQ(2U, m_flush_handler.use_count());
}
TEST_F(TestFutureImpl, Detach) {
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
- ASSERT_FALSE(future->attach(&m_flush_handler));
+ auto future = create_future(234, 123, 456);
+ ASSERT_FALSE(future->attach(m_flush_handler));
future->detach();
- ASSERT_EQ(0U, m_flush_handler.refs);
+ ASSERT_EQ(1U, m_flush_handler.use_count());
}
TEST_F(TestFutureImpl, DetachImplicit) {
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
- ASSERT_FALSE(future->attach(&m_flush_handler));
+ auto future = create_future(234, 123, 456);
+ ASSERT_FALSE(future->attach(m_flush_handler));
future.reset();
- ASSERT_EQ(0U, m_flush_handler.refs);
+ ASSERT_EQ(1U, m_flush_handler.use_count());
}
TEST_F(TestFutureImpl, Flush) {
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
- ASSERT_FALSE(future->attach(&m_flush_handler));
+ auto future = create_future(234, 123, 456);
+ ASSERT_FALSE(future->attach(m_flush_handler));
C_SaferCond cond;
future->flush(&cond);
- ASSERT_EQ(1U, m_flush_handler.flushes);
+ ASSERT_EQ(1U, m_flush_handler->flushes);
future->safe(-EIO);
ASSERT_EQ(-EIO, cond.wait());
}
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
- ASSERT_FALSE(future->attach(&m_flush_handler));
+ auto future = create_future(234, 123, 456);
+ ASSERT_FALSE(future->attach(m_flush_handler));
future->flush(NULL);
- ASSERT_EQ(1U, m_flush_handler.flushes);
+ ASSERT_EQ(1U, m_flush_handler->flushes);
future->safe(-EIO);
ASSERT_TRUE(future->is_complete());
ASSERT_EQ(-EIO, future->get_return_value());
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future1 = create_future(234, 123, 456);
- journal::FutureImplPtr future2 = create_future(234, 124, 457,
- future1);
- journal::FutureImplPtr future3 = create_future(235, 1, 458,
- future2);
+ auto future1 = create_future(234, 123, 456);
+ auto future2 = create_future(234, 124, 457, future1);
+ auto future3 = create_future(235, 1, 458, future2);
- FlushHandler flush_handler;
- ASSERT_FALSE(future1->attach(&m_flush_handler));
- ASSERT_FALSE(future2->attach(&flush_handler));
- ASSERT_FALSE(future3->attach(&m_flush_handler));
+ auto flush_handler = std::make_shared<FlushHandler>();
+ ASSERT_FALSE(future1->attach(m_flush_handler));
+ ASSERT_FALSE(future2->attach(flush_handler));
+ ASSERT_FALSE(future3->attach(m_flush_handler));
C_SaferCond cond;
future3->flush(&cond);
- ASSERT_EQ(1U, m_flush_handler.flushes);
- ASSERT_EQ(1U, flush_handler.flushes);
+ ASSERT_EQ(1U, m_flush_handler->flushes);
+ ASSERT_EQ(1U, flush_handler->flushes);
future3->safe(0);
ASSERT_FALSE(future3->is_complete());
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future1 = create_future(234, 123, 456);
- journal::FutureImplPtr future2 = create_future(234, 124, 457,
- future1);
- ASSERT_FALSE(future1->attach(&m_flush_handler));
- ASSERT_FALSE(future2->attach(&m_flush_handler));
+ auto future1 = create_future(234, 123, 456);
+ auto future2 = create_future(234, 124, 457, future1);
+ ASSERT_FALSE(future1->attach(m_flush_handler));
+ ASSERT_FALSE(future2->attach(m_flush_handler));
future1->set_flush_in_progress();
ASSERT_TRUE(future1->is_flush_in_progress());
future1->flush(NULL);
- ASSERT_EQ(0U, m_flush_handler.flushes);
+ ASSERT_EQ(0U, m_flush_handler->flushes);
future1->safe(0);
}
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 123, 456);
+ auto future = create_future(234, 123, 456);
future->safe(-EIO);
C_SaferCond cond;
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 1, 456);
+ auto future = create_future(234, 1, 456);
C_SaferCond cond;
future->wait(&cond);
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future = create_future(234, 1, 456);
+ auto future = create_future(234, 1, 456);
future->safe(-EEXIST);
C_SaferCond cond;
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future1 = create_future(234, 123, 456);
- journal::FutureImplPtr future2 = create_future(234, 124, 457,
- future1);
+ auto future1 = create_future(234, 123, 456);
+ auto future2 = create_future(234, 124, 457, future1);
future1->safe(-EIO);
future2->safe(-EEXIST);
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
- journal::FutureImplPtr future1 = create_future(234, 123, 456);
- journal::FutureImplPtr future2 = create_future(234, 124, 457,
- future1);
+ auto future1 = create_future(234, 123, 456);
+ auto future2 = create_future(234, 124, 457, future1);
future2->safe(-EEXIST);
future1->safe(-EIO);
RadosTestFixture::TearDown();
}
- journal::JournalMetadataPtr create_metadata(const std::string &oid,
- const std::string &client_id,
- double commit_interval = 0.1,
- int max_concurrent_object_sets = 0) {
- journal::JournalMetadataPtr metadata = RadosTestFixture::create_metadata(
+ auto create_metadata(const std::string &oid,
+ const std::string &client_id,
+ double commit_interval = 0.1,
+ int max_concurrent_object_sets = 0) {
+ auto metadata = RadosTestFixture::create_metadata(
oid, client_id, commit_interval, max_concurrent_object_sets);
m_metadata_list.push_back(metadata);
metadata->add_listener(&m_listener);
return metadata;
}
- typedef std::list<journal::JournalMetadataPtr> MetadataList;
+ typedef std::list<ceph::ref_t<journal::JournalMetadata>> MetadataList;
MetadataList m_metadata_list;
};
TEST_F(TestJournalMetadata, JournalDNE) {
std::string oid = get_temp_oid();
- journal::JournalMetadataPtr metadata1 = create_metadata(oid, "client1");
+ auto metadata1 = create_metadata(oid, "client1");
ASSERT_EQ(-ENOENT, init_metadata(metadata1));
}
ASSERT_EQ(0, create(oid, 14, 2));
ASSERT_EQ(0, client_register(oid, "client1", ""));
- journal::JournalMetadataPtr metadata1 = create_metadata(oid, "client1");
+ auto metadata1 = create_metadata(oid, "client1");
ASSERT_EQ(0, init_metadata(metadata1));
- journal::JournalMetadataPtr metadata2 = create_metadata(oid, "client2");
+ auto metadata2 = create_metadata(oid, "client2");
ASSERT_EQ(-ENOENT, init_metadata(metadata2));
}
ASSERT_EQ(0, create(oid, 14, 2));
ASSERT_EQ(0, client_register(oid, "client1", ""));
- journal::JournalMetadataPtr metadata1 = create_metadata(oid, "client1", 600);
+ auto metadata1 = create_metadata(oid, "client1", 600);
ASSERT_EQ(0, init_metadata(metadata1));
- journal::JournalMetadataPtr metadata2 = create_metadata(oid, "client1");
+ auto metadata2 = create_metadata(oid, "client1");
ASSERT_EQ(0, init_metadata(metadata2));
ASSERT_TRUE(wait_for_update(metadata2));
ASSERT_EQ(0, create(oid, 14, 2));
ASSERT_EQ(0, client_register(oid, "client1", ""));
- journal::JournalMetadataPtr metadata1 = create_metadata(oid, "client1");
+ auto metadata1 = create_metadata(oid, "client1");
ASSERT_EQ(0, init_metadata(metadata1));
ASSERT_TRUE(wait_for_update(metadata1));
ASSERT_EQ(0, client_register(oid, "client2", "laggy"));
int max_concurrent_object_sets = 100;
- journal::JournalMetadataPtr metadata =
+ auto metadata =
create_metadata(oid, "client1", 0.1, max_concurrent_object_sets);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid, "client1", ""));
- journal::JournalMetadataPtr metadata = create_metadata(oid, "client1");
+ auto metadata = create_metadata(oid, "client1");
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
: entries_available(false), complete(false),
complete_result(0) {}
- void get() override {}
- void put() override {}
-
void handle_entries_available() override {
std::lock_guard locker{lock};
entries_available = true;
RadosTestFixture::TearDown();
}
- journal::JournalMetadataPtr create_metadata(const std::string &oid) {
+ auto create_metadata(const std::string &oid) {
return RadosTestFixture::create_metadata(oid, "client", 0.1,
max_fetch_bytes);
}
}
journal::JournalPlayer *create_player(const std::string &oid,
- const journal::JournalMetadataPtr &metadata) {
+ const ceph::ref_t<journal::JournalMetadata>& metadata) {
journal::JournalPlayer *player(new journal::JournalPlayer(
m_ioctx, oid + ".", metadata, &m_replay_hander, nullptr));
m_players.push_back(player);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
ASSERT_EQ(0, metadata->set_active_set(2));
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
ASSERT_EQ(0, metadata->set_active_set(2));
metadata->set_minimum_set(2);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, commit_position));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, {}));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
ASSERT_EQ(0, this->client_register(oid));
ASSERT_EQ(0, this->client_commit(oid, {}));
- journal::JournalMetadataPtr metadata = this->create_metadata(oid);
+ auto metadata = this->create_metadata(oid);
ASSERT_EQ(0, this->init_metadata(metadata));
journal::JournalPlayer *player = this->create_player(oid, metadata);
using JournalRecorderPtr = std::unique_ptr<journal::JournalRecorder,
std::function<void(journal::JournalRecorder*)>>;
JournalRecorderPtr create_recorder(
- const std::string &oid, const journal::JournalMetadataPtr &metadata) {
+ const std::string &oid, const ceph::ref_t<journal::JournalMetadata>& metadata) {
JournalRecorderPtr recorder{
new journal::JournalRecorder(m_ioctx, oid + ".", metadata, 0),
[](journal::JournalRecorder* recorder) {
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
JournalRecorderPtr recorder = create_recorder(oid, metadata);
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_EQ(0U, metadata->get_active_set());
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_EQ(0U, metadata->get_active_set());
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
JournalRecorderPtr recorder = create_recorder(oid, metadata);
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
JournalRecorderPtr recorder = create_recorder(oid, metadata);
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_EQ(0U, metadata->get_active_set());
RadosTestFixture::TearDown();
}
- int append_payload(journal::JournalMetadataPtr metadata,
+ int append_payload(const ceph::ref_t<journal::JournalMetadata>& metadata,
const std::string &oid, uint64_t object_num,
const std::string &payload, uint64_t *commit_tid) {
int r = append(oid + "." + stringify(object_num), create_payload(payload));
return r;
}
- journal::JournalMetadataPtr create_metadata(const std::string &oid) {
- journal::JournalMetadataPtr metadata = RadosTestFixture::create_metadata(
- oid);
+ auto create_metadata(const std::string &oid) {
+ auto metadata = RadosTestFixture::create_metadata(oid);
m_metadata_list.push_back(metadata);
metadata->add_listener(&m_listener);
return metadata;
}
journal::JournalTrimmer *create_trimmer(const std::string &oid,
- const journal::JournalMetadataPtr &metadata) {
+ const ceph::ref_t<journal::JournalMetadata>& metadata) {
journal::JournalTrimmer *trimmer(new journal::JournalTrimmer(
m_ioctx, oid + ".", metadata));
m_trimmers.push_back(trimmer);
return m_ioctx.operate(oid, &op);
}
- typedef std::list<journal::JournalMetadataPtr> MetadataList;
+ typedef std::list<ceph::ref_t<journal::JournalMetadata>> MetadataList;
MetadataList m_metadata_list;
std::list<journal::JournalTrimmer*> m_trimmers;
};
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
ASSERT_EQ(0, client_register(oid));
ASSERT_EQ(0, client_register(oid, "client2", "slow client"));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
ASSERT_EQ(0, create(oid, 12, 2));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
ASSERT_EQ(0, client_register(oid));
ASSERT_EQ(0, client_register(oid, "client2", "other client"));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ASSERT_TRUE(wait_for_update(metadata));
#include "test/journal/RadosTestFixture.h"
template <typename T>
-class TestObjectPlayer : public RadosTestFixture {
+class TestObjectPlayer : public RadosTestFixture, public T {
public:
- static const uint32_t max_fetch_bytes = T::max_fetch_bytes;
-
- journal::ObjectPlayerPtr create_object(const std::string &oid,
- uint8_t order) {
- journal::ObjectPlayerPtr object(new journal::ObjectPlayer(
+ auto create_object(const std::string &oid, uint8_t order) {
+ auto object = ceph::make_ref<journal::ObjectPlayer>(
m_ioctx, oid + ".", 0, *m_timer, m_timer_lock, order,
- max_fetch_bytes));
+ T::max_fetch_bytes);
return object;
}
- int fetch(journal::ObjectPlayerPtr object_player) {
+ int fetch(const ceph::ref_t<journal::ObjectPlayer>& object_player) {
while (true) {
C_SaferCond ctx;
object_player->set_refetch_state(
return 0;
}
- int watch_and_wait_for_entries(journal::ObjectPlayerPtr object_player,
+ int watch_and_wait_for_entries(const ceph::ref_t<journal::ObjectPlayer>& object_player,
journal::ObjectPlayer::Entries *entries,
size_t count) {
for (size_t i = 0; i < 50; ++i) {
template <uint32_t _max_fetch_bytes>
struct TestObjectPlayerParams {
- static const uint32_t max_fetch_bytes = _max_fetch_bytes;
+ static inline const uint32_t max_fetch_bytes = _max_fetch_bytes;
};
typedef ::testing::Types<TestObjectPlayerParams<0>,
encode(entry2, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_LE(0, this->fetch(object));
journal::ObjectPlayer::Entries entries;
encode(entry2, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 12);
+ auto object = this->create_object(oid, 12);
ASSERT_LE(0, this->fetch(object));
journal::ObjectPlayer::Entries entries;
encode(entry2, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_LE(0, this->fetch(object));
journal::ObjectPlayer::Entries entries;
bufferlist bl;
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_EQ(0, this->fetch(object));
ASSERT_TRUE(object->empty());
encode(entry2, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_EQ(-EBADMSG, this->fetch(object));
journal::ObjectPlayer::Entries entries;
encode(entry1, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_LE(0, this->fetch(object));
journal::ObjectPlayer::Entries entries;
encode(entry2, bl);
ASSERT_EQ(0, this->append(this->get_object_name(oid), bl));
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
ASSERT_LE(0, this->fetch(object));
journal::ObjectPlayer::Entries entries;
TYPED_TEST(TestObjectPlayer, Watch) {
std::string oid = this->get_temp_oid();
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
C_SaferCond cond1;
object->watch(&cond1, 0.1);
TYPED_TEST(TestObjectPlayer, Unwatch) {
std::string oid = this->get_temp_oid();
- journal::ObjectPlayerPtr object = this->create_object(oid, 14);
+ auto object = this->create_object(oid, 14);
C_SaferCond watch_ctx;
object->watch(&watch_ctx, 600);
}
}
}
- journal::ObjectRecorderPtr create_object(const std::string& oid,
- uint8_t order,
- ceph::mutex* lock) {
- journal::ObjectRecorderPtr object(new journal::ObjectRecorder(
+ auto create_object(std::string_view oid, uint8_t order, ceph::mutex* lock) {
+ auto object = ceph::make_ref<journal::ObjectRecorder>(
m_ioctx, oid, 0, lock, m_work_queue, &m_handler,
- order, m_max_in_flight_appends));
+ order, m_max_in_flight_appends);
{
std::lock_guard locker{*lock};
object->set_append_batch_options(m_flush_interval,
double m_flush_age = 600;
uint64_t m_max_in_flight_appends = 0;
using ObjectRecorders =
- std::list<std::pair<journal::ObjectRecorderPtr, ceph::mutex*>>;
+ std::list<std::pair<ceph::ref_t<journal::ObjectRecorder>, ceph::mutex*>>;
ObjectRecorders m_object_recorders;
Handler m_handler;
};
journal::AppendBuffer create_append_buffer(uint64_t tag_tid, uint64_t entry_tid,
const std::string &payload) {
- journal::FutureImplPtr future(new journal::FutureImpl(tag_tid, entry_tid,
- 456));
- future->init(journal::FutureImplPtr());
+ auto future = ceph::make_ref<journal::FutureImpl>(tag_tid, entry_tid, 456);
+ future->init(ceph::ref_t<journal::FutureImpl>());
bufferlist bl;
bl.append(payload);
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 0, 0, 0, 0);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 2, 0, 0, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 0, 10, 0, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 0, 0, 0.1, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 12, &lock);
+ auto object = flusher.create_object(oid, 12, &lock);
std::string payload(2048, '1');
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 0, 10, 0, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 0, 10, 0, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock = ceph::make_mutex("object_recorder_lock");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue, 2, 0, 0, -1);
- journal::ObjectRecorderPtr object = flusher.create_object(oid, 24, &lock);
+ auto object = flusher.create_object(oid, 24, &lock);
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
"payload");
std::string oid = get_temp_oid();
ASSERT_EQ(0, create(oid));
ASSERT_EQ(0, client_register(oid));
- journal::JournalMetadataPtr metadata = create_metadata(oid);
+ auto metadata = create_metadata(oid);
ASSERT_EQ(0, init_metadata(metadata));
ceph::mutex lock1 = ceph::make_mutex("object_recorder_lock_1");
ceph::mutex lock2 = ceph::make_mutex("object_recorder_lock_2");
ObjectRecorderFlusher flusher(m_ioctx, m_work_queue);
- journal::ObjectRecorderPtr object1 = flusher.create_object(oid, 12, &lock1);
+ auto object1 = flusher.create_object(oid, 12, &lock1);
std::string payload(1 << 11, '1');
journal::AppendBuffer append_buffer1 = create_append_buffer(234, 123,
ASSERT_TRUE(flusher.wait_for_overflow());
- journal::ObjectRecorderPtr object2 = flusher.create_object(oid, 12, &lock2);
+ auto object2 = flusher.create_object(oid, 12, &lock2);
journal::AppendBuffer append_buffer3 = create_append_buffer(456, 123,
payload);
on_finish(on_finish) {
}
- void get() override {
- }
- void put() override {
- }
-
void handle_entries_available() override {
while (true) {
journal::ReplayEntry replay_entry;
: entries_available(false), complete(false) {
}
- void get() override {
- }
- void put() override {
- }
-
void handle_entries_available() override {
std::lock_guard locker{lock};
entries_available = true;
SessionFilter filter;
std::stringstream ss;
filter.parse({"id=123"}, &ss);
- Session *a = new Session(nullptr);;
- Session *b = new Session(nullptr);;
+ auto a = ceph::make_ref<Session>(nullptr);;
+ auto b = ceph::make_ref<Session>(nullptr);;
a->info.inst.name.parse("client.123");
b->info.inst.name.parse("client.456");
ASSERT_TRUE(filter.match(*a, [](client_t c) -> bool {return false;}));
ASSERT_FALSE(filter.match(*b, [](client_t c) -> bool {return false;}));
- a->put();
- b->put();
}
TEST(MDSSessionFilter, StateEquality)
SessionFilter filter;
std::stringstream ss;
filter.parse({"state=closing"}, &ss);
- Session *a = new Session(nullptr);
+ auto a = ceph::make_ref<Session>(nullptr);
a->set_state(Session::STATE_CLOSING);
- Session *b = new Session(nullptr);
+ auto b = ceph::make_ref<Session>(nullptr);
b->set_state(Session::STATE_OPENING);
ASSERT_TRUE(filter.match(*a, [](client_t c) -> bool {return false;}));
ASSERT_FALSE(filter.match(*b, [](client_t c) -> bool {return false;}));
- a->put();
- b->put();
}
TEST(MDSSessionFilter, AuthEquality)
SessionFilter filter;
std::stringstream ss;
filter.parse({"auth_name=rhubarb"}, &ss);
- Session *a = new Session(nullptr);
+ auto a = ceph::make_ref<Session>(nullptr);
a->info.auth_name.set_id("rhubarb");
- Session *b = new Session(nullptr);
+ auto b = ceph::make_ref<Session>(nullptr);
b->info.auth_name.set_id("custard");
ASSERT_TRUE(filter.match(*a, [](client_t c) -> bool {return false;}));
ASSERT_FALSE(filter.match(*b, [](client_t c) -> bool {return false;}));
- a->put();
- b->put();
}
TEST(MDSSessionFilter, MetadataEquality)
int r = filter.parse({"client_metadata.root=/rhubarb"}, &ss);
ASSERT_EQ(r, 0);
client_metadata_t meta;
- Session *a = new Session(nullptr);
+ auto a = ceph::make_ref<Session>(nullptr);
meta.kv_map = {{"root", "/rhubarb"}};
a->set_client_metadata(meta);
- Session *b = new Session(nullptr);
+ auto b = ceph::make_ref<Session>(nullptr);
meta.kv_map = {{"root", "/custard"}};
b->set_client_metadata(meta);
ASSERT_TRUE(filter.match(*a, [](client_t c) -> bool {return false;}));
ASSERT_FALSE(filter.match(*b, [](client_t c) -> bool {return false;}));
- a->put();
- b->put();
}
TEST(MDSSessionFilter, ReconnectingEquality)
std::stringstream ss;
int r = filter.parse({"reconnecting=true"}, &ss);
ASSERT_EQ(r, 0);
- Session *a = new Session(nullptr);
+ auto a = ceph::make_ref<Session>(nullptr);
ASSERT_TRUE(filter.match(*a, [](client_t c) -> bool {return true;}));
ASSERT_FALSE(filter.match(*a, [](client_t c) -> bool {return false;}));
- a->put();
}
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::Collection coll(&store, oc, bc, coll_t());
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Blob b;
b.shared_blob = new BlueStore::SharedBlob(nullptr);
b.shared_blob->get(); // hack to avoid dtor from running
b.dirty_blob().allocated_test(
bluestore_pextent_t(bluestore_pextent_t::INVALID_OFFSET, 0x8000));
b.dirty_blob().allocated_test(bluestore_pextent_t(0x4071f000, 0x5000));
- b.get_ref(&coll, 0, 0x1200);
- b.get_ref(&coll, 0xae00, 0x4200);
+ b.get_ref(coll.get(), 0, 0x1200);
+ b.get_ref(coll.get(), 0xae00, 0x4200);
ASSERT_EQ(0x5400u, b.get_referenced_bytes());
cout << b << std::endl;
PExtentVector r;
- ASSERT_FALSE(b.put_ref(&coll, 0, 0x1200, &r));
+ ASSERT_FALSE(b.put_ref(coll.get(), 0, 0x1200, &r));
ASSERT_EQ(0x4200u, b.get_referenced_bytes());
cout << " r " << r << std::endl;
cout << b << std::endl;
r.clear();
- ASSERT_TRUE(b.put_ref(&coll, 0xae00, 0x4200, &r));
+ ASSERT_TRUE(b.put_ref(coll.get(), 0xae00, 0x4200, &r));
ASSERT_EQ(0u, b.get_referenced_bytes());
cout << " r " << r << std::endl;
cout << b << std::endl;
g_ceph_context, "lru", NULL);
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
{
BlueStore::Blob B;
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Blob B;
B.shared_blob = new BlueStore::SharedBlob(nullptr);
B.shared_blob->get(); // hack to avoid dtor from running
g_ceph_context, "lru", NULL);
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
{
BlueStore::Blob L, R;
L.shared_blob = new BlueStore::SharedBlob(coll.get());
g_ceph_context, "lru", NULL);
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
bufferlist bl, bl2;
{
BlueStore::Blob B;
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
BlueStore::BlobRef br(new BlueStore::Blob);
g_ceph_context, "lru", NULL);
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
BlueStore::BlobRef b(new BlueStore::Blob);
BlueStore::BufferCacheShard *bc = BlueStore::BufferCacheShard::create(
g_ceph_context, "lru", NULL);
-BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
BlueStore::BlobRef b1(new BlueStore::Blob);
g_ceph_context, "lru", NULL);
BlueStore store(g_ceph_context, "", 4096);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
*/
{
BlueStore store(g_ceph_context, "", 0x10000);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
*/
{
BlueStore store(g_ceph_context, "", 0x10000);
- BlueStore::CollectionRef coll(new BlueStore::Collection(&store, oc, bc, coll_t()));
+ auto coll = ceph::make_ref<BlueStore::Collection>(&store, oc, bc, coll_t());
BlueStore::Onode onode(coll.get(), ghobject_t(), "");
BlueStore::ExtentMap em(&onode);
JournalPlayer *journal;
explicit ReplayHandler(JournalPlayer *_journal) : journal(_journal) {}
- void get() override {}
- void put() override {}
-
void handle_entries_available() override {
journal->handle_replay_ready();
}
class BaseRequest : public RefCountedObject {
public:
BaseRequest(const std::string& name, CephContext *cct, Context *on_finish)
- : RefCountedObject(cct, 1), m_name(name), m_cct(cct),
+ : RefCountedObject(cct), m_name(name), m_cct(cct),
m_on_finish(on_finish) {
}
struct ReplayHandler : public ::journal::ReplayHandler {
ImageReplayer<I> *replayer;
ReplayHandler(ImageReplayer<I> *replayer) : replayer(replayer) {}
- void get() override {}
- void put() override {}
void handle_entries_available() override {
replayer->handle_replay_ready();
projects / ceph.git / commitdiff