From 8c52b89356d444093ea07290498f47fba2567bb3 Mon Sep 17 00:00:00 2001 From: "Adam C. Emerson" Date: Thu, 23 Aug 2018 11:24:01 -0400 Subject: [PATCH] journal: Use ceph_assert for asserts. Signed-off-by: Adam C. Emerson --- src/journal/Entry.cc | 2 +- src/journal/Future.cc | 2 +- src/journal/FutureImpl.cc | 16 +++---- src/journal/FutureImpl.h | 2 +- src/journal/JournalMetadata.cc | 80 +++++++++++++++++----------------- src/journal/JournalPlayer.cc | 74 +++++++++++++++---------------- src/journal/JournalRecorder.cc | 40 ++++++++--------- src/journal/JournalTrimmer.cc | 10 ++--- src/journal/Journaler.cc | 38 ++++++++-------- src/journal/ObjectPlayer.cc | 32 +++++++------- src/journal/ObjectRecorder.cc | 58 ++++++++++++------------ src/journal/ObjectRecorder.h | 2 +- 12 files changed, 178 insertions(+), 178 deletions(-) diff --git a/src/journal/Entry.cc b/src/journal/Entry.cc index 16a5af113eb4f..48648a872dfc3 100644 --- a/src/journal/Entry.cc +++ b/src/journal/Entry.cc @@ -37,7 +37,7 @@ void Entry::encode(bufferlist &bl) const { uint32_t bl_offset = bl.length(); bl.claim_append(data_bl); encode(crc, bl); - assert(get_fixed_size() + m_data.length() + bl_offset == bl.length()); + ceph_assert(get_fixed_size() + m_data.length() + bl_offset == bl.length()); } void Entry::decode(bufferlist::const_iterator &iter) { diff --git a/src/journal/Future.cc b/src/journal/Future.cc index 144f320522778..c2eaa967ac906 100644 --- a/src/journal/Future.cc +++ b/src/journal/Future.cc @@ -12,7 +12,7 @@ void Future::flush(Context *on_safe) { } void Future::wait(Context *on_safe) { - assert(on_safe != NULL); + ceph_assert(on_safe != NULL); m_future_impl->wait(on_safe); } diff --git a/src/journal/FutureImpl.cc b/src/journal/FutureImpl.cc index e46a3c9cbf372..eac3fc39ba31f 100644 --- a/src/journal/FutureImpl.cc +++ b/src/journal/FutureImpl.cc @@ -67,7 +67,7 @@ FutureImplPtr FutureImpl::prepare_flush(FlushHandlers *flush_handlers) { FutureImplPtr FutureImpl::prepare_flush(FlushHandlers *flush_handlers, Mutex &lock) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (m_flush_state == FLUSH_STATE_NONE) { m_flush_state = FLUSH_STATE_REQUESTED; @@ -80,7 +80,7 @@ FutureImplPtr FutureImpl::prepare_flush(FlushHandlers *flush_handlers, } void FutureImpl::wait(Context *on_safe) { - assert(on_safe != NULL); + ceph_assert(on_safe != NULL); { Mutex::Locker locker(m_lock); if (!m_safe || !m_consistent) { @@ -99,20 +99,20 @@ bool FutureImpl::is_complete() const { int FutureImpl::get_return_value() const { Mutex::Locker locker(m_lock); - assert(m_safe && m_consistent); + ceph_assert(m_safe && m_consistent); return m_return_value; } bool FutureImpl::attach(const FlushHandlerPtr &flush_handler) { Mutex::Locker locker(m_lock); - assert(!m_flush_handler); + ceph_assert(!m_flush_handler); m_flush_handler = flush_handler; return m_flush_state != FLUSH_STATE_NONE; } void FutureImpl::safe(int r) { m_lock.Lock(); - assert(!m_safe); + ceph_assert(!m_safe); m_safe = true; if (m_return_value == 0) { m_return_value = r; @@ -128,7 +128,7 @@ void FutureImpl::safe(int r) { void FutureImpl::consistent(int r) { m_lock.Lock(); - assert(!m_consistent); + ceph_assert(!m_consistent); m_consistent = true; m_prev_future.reset(); if (m_return_value == 0) { @@ -143,8 +143,8 @@ void FutureImpl::consistent(int r) { } void FutureImpl::finish_unlock() { - assert(m_lock.is_locked()); - assert(m_safe && m_consistent); + ceph_assert(m_lock.is_locked()); + ceph_assert(m_safe && m_consistent); Contexts contexts; contexts.swap(m_contexts); diff --git a/src/journal/FutureImpl.h b/src/journal/FutureImpl.h index 1c02c9a2d11e7..f44f0e08913e4 100644 --- a/src/journal/FutureImpl.h +++ b/src/journal/FutureImpl.h @@ -57,7 +57,7 @@ public: } inline void set_flush_in_progress() { Mutex::Locker locker(m_lock); - assert(m_flush_handler); + ceph_assert(m_flush_handler); m_flush_handler.reset(); m_flush_state = FLUSH_STATE_IN_PROGRESS; } diff --git a/src/journal/JournalMetadata.cc b/src/journal/JournalMetadata.cc index 2f53e3da5fecf..f35eccb131fff 100644 --- a/src/journal/JournalMetadata.cc +++ b/src/journal/JournalMetadata.cc @@ -56,7 +56,7 @@ struct C_GetClient : public Context { C_GetClient, &C_GetClient::handle_get_client>); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -115,7 +115,7 @@ struct C_AllocateTag : public Context { out_bl.clear(); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -144,7 +144,7 @@ struct C_AllocateTag : public Context { C_AllocateTag, &C_AllocateTag::handle_tag_create>); int r = ioctx.aio_operate(oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -174,7 +174,7 @@ struct C_AllocateTag : public Context { out_bl.clear(); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -233,7 +233,7 @@ struct C_GetTag : public Context { C_GetTag, &C_GetTag::handle_get_tag>); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -294,7 +294,7 @@ struct C_GetTags : public Context { out_bl.clear(); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -372,7 +372,7 @@ struct C_AssertActiveTag : public Context { C_AssertActiveTag, &C_AssertActiveTag::handle_send>); int r = ioctx.aio_operate(oid, comp, &op, &out_bl); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -419,13 +419,13 @@ JournalMetadata::JournalMetadata(ContextWQ *work_queue, SafeTimer *timer, JournalMetadata::~JournalMetadata() { Mutex::Locker locker(m_lock); - assert(!m_initialized); + ceph_assert(!m_initialized); } void JournalMetadata::init(Context *on_finish) { { Mutex::Locker locker(m_lock); - assert(!m_initialized); + ceph_assert(!m_initialized); m_initialized = true; } @@ -449,7 +449,7 @@ void JournalMetadata::init(Context *on_finish) { librados::AioCompletion *comp = librados::Rados::aio_create_completion( on_finish, nullptr, utils::rados_ctx_callback); int r = m_ioctx.aio_watch(m_oid, comp, &m_watch_handle, &m_watch_ctx); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -477,7 +477,7 @@ void JournalMetadata::shut_down(Context *on_finish) { librados::AioCompletion *comp = librados::Rados::aio_create_completion( on_finish, nullptr, utils::rados_ctx_callback); r = rados.aio_watch_flush(comp); - assert(r == 0); + ceph_assert(r == 0); comp->release(); }); on_finish = new FunctionContext([this, on_finish](int r) { @@ -487,7 +487,7 @@ void JournalMetadata::shut_down(Context *on_finish) { librados::AioCompletion *comp = librados::Rados::aio_create_completion( on_finish, nullptr, utils::rados_ctx_callback); int r = m_ioctx.aio_unwatch(watch_handle, comp); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } else { on_finish->complete(0); @@ -522,7 +522,7 @@ void JournalMetadata::register_client(const bufferlist &data, librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -538,12 +538,12 @@ void JournalMetadata::update_client(const bufferlist &data, librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } void JournalMetadata::unregister_client(Context *on_finish) { - assert(!m_client_id.empty()); + ceph_assert(!m_client_id.empty()); ldout(m_cct, 10) << __func__ << ": " << m_client_id << dendl; librados::ObjectWriteOperation op; @@ -555,7 +555,7 @@ void JournalMetadata::unregister_client(Context *on_finish) { librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -624,7 +624,7 @@ void JournalMetadata::set_minimum_set(uint64_t object_set) { librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); m_minimum_set = object_set; @@ -654,7 +654,7 @@ void JournalMetadata::set_active_set(uint64_t object_set, Context *on_finish) { librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); m_active_set = object_set; @@ -719,7 +719,7 @@ bool JournalMetadata::get_last_allocated_entry_tid(uint64_t tag_tid, return false; } - assert(it->second > 0); + ceph_assert(it->second > 0); *entry_tid = it->second - 1; return true; } @@ -786,7 +786,7 @@ void JournalMetadata::handle_refresh_complete(C_Refresh *refresh, int r) { } Contexts refresh_ctxs; - assert(m_refreshes_in_progress > 0); + ceph_assert(m_refreshes_in_progress > 0); --m_refreshes_in_progress; if (m_refreshes_in_progress == 0) { std::swap(refresh_ctxs, m_refresh_ctxs); @@ -801,10 +801,10 @@ void JournalMetadata::handle_refresh_complete(C_Refresh *refresh, int r) { void JournalMetadata::cancel_commit_task() { ldout(m_cct, 20) << __func__ << dendl; - assert(m_timer_lock->is_locked()); - assert(m_lock.is_locked()); - assert(m_commit_position_ctx != nullptr); - assert(m_commit_position_task_ctx != nullptr); + ceph_assert(m_timer_lock->is_locked()); + ceph_assert(m_lock.is_locked()); + ceph_assert(m_commit_position_ctx != nullptr); + ceph_assert(m_commit_position_task_ctx != nullptr); m_timer->cancel_event(m_commit_position_task_ctx); m_commit_position_task_ctx = NULL; } @@ -812,9 +812,9 @@ void JournalMetadata::cancel_commit_task() { void JournalMetadata::schedule_commit_task() { ldout(m_cct, 20) << __func__ << dendl; - assert(m_timer_lock->is_locked()); - assert(m_lock.is_locked()); - assert(m_commit_position_ctx != nullptr); + ceph_assert(m_timer_lock->is_locked()); + ceph_assert(m_lock.is_locked()); + ceph_assert(m_commit_position_ctx != nullptr); if (m_commit_position_task_ctx == nullptr) { m_commit_position_task_ctx = m_timer->add_event_after(m_settings.commit_interval, @@ -823,8 +823,8 @@ void JournalMetadata::schedule_commit_task() { } void JournalMetadata::handle_commit_position_task() { - assert(m_timer_lock->is_locked()); - assert(m_lock.is_locked()); + ceph_assert(m_timer_lock->is_locked()); + ceph_assert(m_lock.is_locked()); ldout(m_cct, 20) << __func__ << ": " << "client_id=" << m_client_id << ", " << "commit_position=" << m_commit_position << dendl; @@ -839,7 +839,7 @@ void JournalMetadata::handle_commit_position_task() { Context* ctx = new FunctionContext([this, commit_position_ctx](int r) { Contexts flush_commit_position_ctxs; m_lock.Lock(); - assert(m_flush_commits_in_progress > 0); + ceph_assert(m_flush_commits_in_progress > 0); --m_flush_commits_in_progress; if (m_flush_commits_in_progress == 0) { std::swap(flush_commit_position_ctxs, m_flush_commit_position_ctxs); @@ -872,17 +872,17 @@ void JournalMetadata::handle_commit_position_task() { auto comp = librados::Rados::aio_create_completion(ctx, nullptr, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } void JournalMetadata::schedule_watch_reset() { - assert(m_timer_lock->is_locked()); + ceph_assert(m_timer_lock->is_locked()); m_timer->add_event_after(1, new C_WatchReset(this)); } void JournalMetadata::handle_watch_reset() { - assert(m_timer_lock->is_locked()); + ceph_assert(m_timer_lock->is_locked()); if (!m_initialized) { return; } @@ -965,8 +965,8 @@ void JournalMetadata::overflow_commit_tid(uint64_t commit_tid, Mutex::Locker locker(m_lock); auto it = m_pending_commit_tids.find(commit_tid); - assert(it != m_pending_commit_tids.end()); - assert(it->second.object_num < object_num); + ceph_assert(it != m_pending_commit_tids.end()); + ceph_assert(it->second.object_num < object_num); ldout(m_cct, 20) << __func__ << ": " << "commit_tid=" << commit_tid << ", " @@ -981,7 +981,7 @@ void JournalMetadata::get_commit_entry(uint64_t commit_tid, Mutex::Locker locker(m_lock); auto it = m_pending_commit_tids.find(commit_tid); - assert(it != m_pending_commit_tids.end()); + ceph_assert(it != m_pending_commit_tids.end()); *object_num = it->second.object_num; *tag_tid = it->second.tag_tid; @@ -997,7 +997,7 @@ void JournalMetadata::committed(uint64_t commit_tid, { Mutex::Locker timer_locker(*m_timer_lock); Mutex::Locker locker(m_lock); - assert(commit_tid > m_commit_position_tid); + ceph_assert(commit_tid > m_commit_position_tid); if (!m_commit_position.object_positions.empty()) { // in-flight commit position update @@ -1008,7 +1008,7 @@ void JournalMetadata::committed(uint64_t commit_tid, } CommitTids::iterator it = m_pending_commit_tids.find(commit_tid); - assert(it != m_pending_commit_tids.end()); + ceph_assert(it != m_pending_commit_tids.end()); CommitEntry &commit_entry = it->second; commit_entry.committed = true; @@ -1079,7 +1079,7 @@ void JournalMetadata::async_notify_update(Context *on_safe) { bufferlist bl; int r = m_ioctx.aio_notify(m_oid, comp, bl, 5000, NULL); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -1132,7 +1132,7 @@ void JournalMetadata::schedule_laggy_clients_disconnect(Context *on_finish) { auto comp = librados::Rados::aio_create_completion( ctx, nullptr, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); }); } diff --git a/src/journal/JournalPlayer.cc b/src/journal/JournalPlayer.cc index 5118021808044..89952e636a439 100644 --- a/src/journal/JournalPlayer.cc +++ b/src/journal/JournalPlayer.cc @@ -79,19 +79,19 @@ JournalPlayer::JournalPlayer(librados::IoCtx &ioctx, } JournalPlayer::~JournalPlayer() { - assert(m_async_op_tracker.empty()); + ceph_assert(m_async_op_tracker.empty()); { Mutex::Locker locker(m_lock); - assert(m_shut_down); - assert(m_fetch_object_numbers.empty()); - assert(!m_watch_scheduled); + ceph_assert(m_shut_down); + ceph_assert(m_fetch_object_numbers.empty()); + ceph_assert(!m_watch_scheduled); } m_replay_handler->put(); } void JournalPlayer::prefetch() { Mutex::Locker locker(m_lock); - assert(m_state == STATE_INIT); + ceph_assert(m_state == STATE_INIT); m_state = STATE_PREFETCH; m_active_set = m_journal_metadata->get_active_set(); @@ -104,7 +104,7 @@ void JournalPlayer::prefetch() { // active set) std::map splay_offset_to_objects; for (auto &position : m_commit_positions) { - assert(splay_offset_to_objects.count(position.first) == 0); + ceph_assert(splay_offset_to_objects.count(position.first) == 0); splay_offset_to_objects[position.first] = position.second.object_number; } @@ -141,7 +141,7 @@ void JournalPlayer::shut_down(Context *on_finish) { ldout(m_cct, 20) << __func__ << dendl; Mutex::Locker locker(m_lock); - assert(!m_shut_down); + ceph_assert(!m_shut_down); m_shut_down = true; m_watch_enabled = false; @@ -184,7 +184,7 @@ bool JournalPlayer::try_pop_front(Entry *entry, uint64_t *commit_tid) { } ObjectPlayerPtr object_player = get_object_player(); - assert(object_player && !object_player->empty()); + ceph_assert(object_player && !object_player->empty()); object_player->front(entry); object_player->pop_front(); @@ -215,7 +215,7 @@ void JournalPlayer::process_state(uint64_t object_number, int r) { ldout(m_cct, 10) << __func__ << ": object_num=" << object_number << ", " << "r=" << r << dendl; - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (r >= 0) { switch (m_state) { case STATE_PREFETCH: @@ -244,7 +244,7 @@ void JournalPlayer::process_state(uint64_t object_number, int r) { int JournalPlayer::process_prefetch(uint64_t object_number) { ldout(m_cct, 10) << __func__ << ": object_num=" << object_number << dendl; - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); uint8_t splay_width = m_journal_metadata->get_splay_width(); uint8_t splay_offset = object_number % splay_width; @@ -256,7 +256,7 @@ int JournalPlayer::process_prefetch(uint64_t object_number) { } bool prefetch_complete = false; - assert(m_object_players.count(splay_offset) == 1); + ceph_assert(m_object_players.count(splay_offset) == 1); ObjectPlayerPtr object_player = m_object_players[splay_offset]; // prefetch in-order since a newer splay object could prefetch first @@ -349,7 +349,7 @@ int JournalPlayer::process_prefetch(uint64_t object_number) { int JournalPlayer::process_playback(uint64_t object_number) { ldout(m_cct, 10) << __func__ << ": object_num=" << object_number << dendl; - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (verify_playback_ready()) { notify_entries_available(); @@ -360,7 +360,7 @@ int JournalPlayer::process_playback(uint64_t object_number) { } bool JournalPlayer::is_object_set_ready() const { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (m_watch_scheduled || !m_fetch_object_numbers.empty()) { ldout(m_cct, 20) << __func__ << ": waiting for in-flight fetch" << dendl; return false; @@ -370,7 +370,7 @@ bool JournalPlayer::is_object_set_ready() const { } bool JournalPlayer::verify_playback_ready() { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); while (true) { if (!is_object_set_ready()) { @@ -379,7 +379,7 @@ bool JournalPlayer::verify_playback_ready() { } ObjectPlayerPtr object_player = get_object_player(); - assert(object_player); + ceph_assert(object_player); uint64_t object_num = object_player->get_object_number(); // Verify is the active object player has another entry available @@ -428,7 +428,7 @@ bool JournalPlayer::verify_playback_ready() { ldout(m_cct, 20) << __func__ << ": " << "object_num=" << object_num << ", " << "entry: " << entry << dendl; - assert(entry.get_tag_tid() == *m_active_tag_tid); + ceph_assert(entry.get_tag_tid() == *m_active_tag_tid); return true; } } else { @@ -473,7 +473,7 @@ bool JournalPlayer::verify_playback_ready() { } void JournalPlayer::prune_tag(uint64_t tag_tid) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ldout(m_cct, 10) << __func__ << ": pruning remaining entries for tag " << tag_tid << dendl; @@ -517,8 +517,8 @@ void JournalPlayer::prune_tag(uint64_t tag_tid) { } void JournalPlayer::prune_active_tag(const boost::optional& tag_tid) { - assert(m_lock.is_locked()); - assert(m_active_tag_tid); + ceph_assert(m_lock.is_locked()); + ceph_assert(m_active_tag_tid); uint64_t active_tag_tid = *m_active_tag_tid; if (tag_tid) { @@ -531,29 +531,29 @@ void JournalPlayer::prune_active_tag(const boost::optional& tag_tid) { } ObjectPlayerPtr JournalPlayer::get_object_player() const { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); SplayedObjectPlayers::const_iterator it = m_object_players.find( m_splay_offset); - assert(it != m_object_players.end()); + ceph_assert(it != m_object_players.end()); return it->second; } ObjectPlayerPtr JournalPlayer::get_object_player(uint64_t object_number) const { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); uint8_t splay_width = m_journal_metadata->get_splay_width(); uint8_t splay_offset = object_number % splay_width; auto splay_it = m_object_players.find(splay_offset); - assert(splay_it != m_object_players.end()); + ceph_assert(splay_it != m_object_players.end()); ObjectPlayerPtr object_player = splay_it->second; - assert(object_player->get_object_number() == object_number); + ceph_assert(object_player->get_object_number() == object_number); return object_player; } void JournalPlayer::advance_splay_object() { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ++m_splay_offset; m_splay_offset %= m_journal_metadata->get_splay_width(); m_watch_step = WATCH_STEP_FETCH_CURRENT; @@ -562,8 +562,8 @@ void JournalPlayer::advance_splay_object() { } bool JournalPlayer::remove_empty_object_player(const ObjectPlayerPtr &player) { - assert(m_lock.is_locked()); - assert(!m_watch_scheduled); + ceph_assert(m_lock.is_locked()); + ceph_assert(!m_watch_scheduled); uint8_t splay_width = m_journal_metadata->get_splay_width(); uint64_t object_set = player->get_object_number() / splay_width; @@ -596,7 +596,7 @@ bool JournalPlayer::remove_empty_object_player(const ObjectPlayerPtr &player) { } void JournalPlayer::fetch(uint64_t object_num) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ObjectPlayerPtr object_player(new ObjectPlayer( m_ioctx, m_object_oid_prefix, object_num, m_journal_metadata->get_timer(), @@ -609,11 +609,11 @@ void JournalPlayer::fetch(uint64_t object_num) { } void JournalPlayer::fetch(const ObjectPlayerPtr &object_player) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); uint64_t object_num = object_player->get_object_number(); std::string oid = utils::get_object_name(m_object_oid_prefix, object_num); - assert(m_fetch_object_numbers.count(object_num) == 0); + ceph_assert(m_fetch_object_numbers.count(object_num) == 0); m_fetch_object_numbers.insert(object_num); ldout(m_cct, 10) << __func__ << ": " << oid << dendl; @@ -628,7 +628,7 @@ void JournalPlayer::handle_fetched(uint64_t object_num, int r) { << ": r=" << r << dendl; Mutex::Locker locker(m_lock); - assert(m_fetch_object_numbers.count(object_num) == 1); + ceph_assert(m_fetch_object_numbers.count(object_num) == 1); m_fetch_object_numbers.erase(object_num); if (m_shut_down) { @@ -644,7 +644,7 @@ void JournalPlayer::handle_fetched(uint64_t object_num, int r) { void JournalPlayer::refetch(bool immediate) { ldout(m_cct, 10) << __func__ << dendl; - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); m_handler_notified = false; // if watching the object, handle the periodic re-fetch @@ -665,7 +665,7 @@ void JournalPlayer::refetch(bool immediate) { void JournalPlayer::schedule_watch(bool immediate) { ldout(m_cct, 10) << __func__ << dendl; - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (m_watch_scheduled) { return; } @@ -727,7 +727,7 @@ void JournalPlayer::schedule_watch(bool immediate) { void JournalPlayer::handle_watch(uint64_t object_num, int r) { ldout(m_cct, 10) << __func__ << ": r=" << r << dendl; Mutex::Locker locker(m_lock); - assert(m_watch_scheduled); + ceph_assert(m_watch_scheduled); m_watch_scheduled = false; if (m_shut_down || r == -ECANCELED) { @@ -761,7 +761,7 @@ void JournalPlayer::handle_watch_assert_active(int r) { ldout(m_cct, 10) << __func__ << ": r=" << r << dendl; Mutex::Locker locker(m_lock); - assert(m_watch_scheduled); + ceph_assert(m_watch_scheduled); m_watch_scheduled = false; if (r == -ESTALE) { @@ -780,7 +780,7 @@ void JournalPlayer::handle_watch_assert_active(int r) { } void JournalPlayer::notify_entries_available() { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); if (m_handler_notified) { return; } @@ -792,7 +792,7 @@ void JournalPlayer::notify_entries_available() { } void JournalPlayer::notify_complete(int r) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); m_handler_notified = true; ldout(m_cct, 10) << __func__ << ": replay complete: r=" << r << dendl; diff --git a/src/journal/JournalRecorder.cc b/src/journal/JournalRecorder.cc index c7d8cd1ac1efb..0cfebe480f4ab 100644 --- a/src/journal/JournalRecorder.cc +++ b/src/journal/JournalRecorder.cc @@ -79,8 +79,8 @@ JournalRecorder::~JournalRecorder() { m_journal_metadata->remove_listener(&m_listener); Mutex::Locker locker(m_lock); - assert(m_in_flight_advance_sets == 0); - assert(m_in_flight_object_closes == 0); + ceph_assert(m_in_flight_advance_sets == 0); + ceph_assert(m_in_flight_object_closes == 0); } Future JournalRecorder::append(uint64_t tag_tid, @@ -105,7 +105,7 @@ Future JournalRecorder::append(uint64_t tag_tid, bufferlist entry_bl; encode(Entry(future->get_tag_tid(), future->get_entry_tid(), payload_bl), entry_bl); - assert(entry_bl.length() <= m_journal_metadata->get_object_size()); + ceph_assert(entry_bl.length() <= m_journal_metadata->get_object_size()); bool object_full = object_ptr->append_unlock({{future, entry_bl}}); if (object_full) { @@ -135,15 +135,15 @@ void JournalRecorder::flush(Context *on_safe) { } ObjectRecorderPtr JournalRecorder::get_object(uint8_t splay_offset) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ObjectRecorderPtr object_recoder = m_object_ptrs[splay_offset]; - assert(object_recoder != NULL); + ceph_assert(object_recoder != NULL); return object_recoder; } void JournalRecorder::close_and_advance_object_set(uint64_t object_set) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); // entry overflow from open object if (m_current_set != object_set) { @@ -153,11 +153,11 @@ void JournalRecorder::close_and_advance_object_set(uint64_t object_set) { // we shouldn't overflow upon append if already closed and we // shouldn't receive an overflowed callback if already closed - assert(m_in_flight_advance_sets == 0); - assert(m_in_flight_object_closes == 0); + ceph_assert(m_in_flight_advance_sets == 0); + ceph_assert(m_in_flight_object_closes == 0); uint64_t active_set = m_journal_metadata->get_active_set(); - assert(m_current_set == active_set); + ceph_assert(m_current_set == active_set); ++m_current_set; ++m_in_flight_advance_sets; @@ -169,9 +169,9 @@ void JournalRecorder::close_and_advance_object_set(uint64_t object_set) { } void JournalRecorder::advance_object_set() { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); - assert(m_in_flight_object_closes == 0); + ceph_assert(m_in_flight_object_closes == 0); ldout(m_cct, 20) << __func__ << ": advance to object set " << m_current_set << dendl; m_journal_metadata->set_active_set(m_current_set, new C_AdvanceObjectSet( @@ -182,7 +182,7 @@ void JournalRecorder::handle_advance_object_set(int r) { Mutex::Locker locker(m_lock); ldout(m_cct, 20) << __func__ << ": r=" << r << dendl; - assert(m_in_flight_advance_sets > 0); + ceph_assert(m_in_flight_advance_sets > 0); --m_in_flight_advance_sets; if (r < 0 && r != -ESTALE) { @@ -196,7 +196,7 @@ void JournalRecorder::handle_advance_object_set(int r) { } void JournalRecorder::open_object_set() { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ldout(m_cct, 10) << __func__ << ": opening object set " << m_current_set << dendl; @@ -209,7 +209,7 @@ void JournalRecorder::open_object_set() { ObjectRecorderPtr object_recorder = it->second; uint64_t object_number = object_recorder->get_object_number(); if (object_number / splay_width != m_current_set) { - assert(object_recorder->is_closed()); + ceph_assert(object_recorder->is_closed()); // ready to close object and open object in active set create_next_object_recorder_unlock(object_recorder); @@ -221,7 +221,7 @@ void JournalRecorder::open_object_set() { } bool JournalRecorder::close_object_set(uint64_t active_set) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); // object recorders will invoke overflow handler as they complete // closing the object to ensure correct order of future appends @@ -259,13 +259,13 @@ ObjectRecorderPtr JournalRecorder::create_object_recorder( void JournalRecorder::create_next_object_recorder_unlock( ObjectRecorderPtr object_recorder) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); 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; - assert(m_object_locks[splay_offset]->is_locked()); + ceph_assert(m_object_locks[splay_offset]->is_locked()); ObjectRecorderPtr new_object_recorder = create_object_recorder( (m_current_set * splay_width) + splay_offset, m_object_locks[splay_offset]); @@ -318,9 +318,9 @@ void JournalRecorder::handle_closed(ObjectRecorder *object_recorder) { 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]; - assert(active_object_recorder->get_object_number() == object_number); + ceph_assert(active_object_recorder->get_object_number() == object_number); - assert(m_in_flight_object_closes > 0); + ceph_assert(m_in_flight_object_closes > 0); --m_in_flight_object_closes; // object closed after advance active set committed @@ -346,7 +346,7 @@ void JournalRecorder::handle_overflow(ObjectRecorder *object_recorder) { 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]; - assert(active_object_recorder->get_object_number() == object_number); + ceph_assert(active_object_recorder->get_object_number() == object_number); ldout(m_cct, 20) << __func__ << ": object " << active_object_recorder->get_oid() << " overflowed" diff --git a/src/journal/JournalTrimmer.cc b/src/journal/JournalTrimmer.cc index 6d3caed03df10..d3289499a090d 100644 --- a/src/journal/JournalTrimmer.cc +++ b/src/journal/JournalTrimmer.cc @@ -43,14 +43,14 @@ JournalTrimmer::JournalTrimmer(librados::IoCtx &ioctx, } JournalTrimmer::~JournalTrimmer() { - assert(m_shutdown); + ceph_assert(m_shutdown); } void JournalTrimmer::shut_down(Context *on_finish) { ldout(m_cct, 20) << __func__ << dendl; { Mutex::Locker locker(m_lock); - assert(!m_shutdown); + ceph_assert(!m_shutdown); m_shutdown = true; } @@ -103,7 +103,7 @@ void JournalTrimmer::committed(uint64_t commit_tid) { } void JournalTrimmer::trim_objects(uint64_t minimum_set) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); ldout(m_cct, 20) << __func__ << ": min_set=" << minimum_set << dendl; if (minimum_set <= m_journal_metadata->get_minimum_set()) { @@ -121,7 +121,7 @@ void JournalTrimmer::trim_objects(uint64_t minimum_set) { } void JournalTrimmer::remove_set(uint64_t object_set) { - assert(m_lock.is_locked()); + ceph_assert(m_lock.is_locked()); m_async_op_tracker.start_op(); uint8_t splay_width = m_journal_metadata->get_splay_width(); @@ -140,7 +140,7 @@ void JournalTrimmer::remove_set(uint64_t object_set) { librados::Rados::aio_create_completion(ctx, NULL, utils::rados_ctx_callback); int r = m_ioctx.aio_remove(oid, comp); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } } diff --git a/src/journal/Journaler.cc b/src/journal/Journaler.cc index 5b580c50005db..65d32de3d1e95 100644 --- a/src/journal/Journaler.cc +++ b/src/journal/Journaler.cc @@ -107,7 +107,7 @@ void Journaler::set_up(ContextWQ *work_queue, SafeTimer *timer, Journaler::~Journaler() { if (m_metadata != nullptr) { - assert(!m_metadata->is_initialized()); + ceph_assert(!m_metadata->is_initialized()); if (!m_initialized) { // never initialized -- ensure any in-flight ops are complete // since we wouldn't expect shut_down to be invoked @@ -116,9 +116,9 @@ Journaler::~Journaler() { m_metadata->put(); m_metadata = nullptr; } - assert(m_trimmer == nullptr); - assert(m_player == nullptr); - assert(m_recorder == nullptr); + ceph_assert(m_trimmer == nullptr); + ceph_assert(m_player == nullptr); + ceph_assert(m_recorder == nullptr); delete m_threads; m_threads = nullptr; @@ -131,7 +131,7 @@ void Journaler::exists(Context *on_finish) const { librados::AioCompletion *comp = librados::Rados::aio_create_completion(on_finish, nullptr, rados_ctx_callback); int r = m_header_ioctx.aio_operate(m_header_oid, comp, &op, nullptr); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -171,13 +171,13 @@ void Journaler::shut_down() { } void Journaler::shut_down(Context *on_finish) { - assert(m_player == nullptr); - assert(m_recorder == nullptr); + ceph_assert(m_player == nullptr); + ceph_assert(m_recorder == nullptr); JournalMetadata *metadata = nullptr; - assert(m_metadata != nullptr); + ceph_assert(m_metadata != nullptr); std::swap(metadata, m_metadata); - assert(metadata != nullptr); + ceph_assert(metadata != nullptr); on_finish = new FunctionContext([metadata, on_finish](int r) { metadata->put(); @@ -234,7 +234,7 @@ void Journaler::create(uint8_t order, uint8_t splay_width, librados::AioCompletion *comp = librados::Rados::aio_create_completion(on_finish, nullptr, rados_ctx_callback); int r = m_header_ioctx.aio_operate(m_header_oid, comp, &op); - assert(r == 0); + ceph_assert(r == 0); comp->release(); } @@ -244,7 +244,7 @@ void Journaler::remove(bool force, Context *on_finish) { librados::AioCompletion *comp = librados::Rados::aio_create_completion( on_finish, nullptr, utils::rados_ctx_callback); r = m_header_ioctx.aio_remove(m_header_oid, comp); - assert(r == 0); + ceph_assert(r == 0); comp->release(); }); @@ -348,7 +348,7 @@ void Journaler::start_live_replay(ReplayHandler *replay_handler, bool Journaler::try_pop_front(ReplayEntry *replay_entry, uint64_t *tag_tid) { - assert(m_player != nullptr); + ceph_assert(m_player != nullptr); Entry entry; uint64_t commit_tid; @@ -371,9 +371,9 @@ void Journaler::stop_replay() { void Journaler::stop_replay(Context *on_finish) { JournalPlayer *player = nullptr; - assert(m_player != nullptr); + ceph_assert(m_player != nullptr); std::swap(player, m_player); - assert(player != nullptr); + ceph_assert(player != nullptr); on_finish = new FunctionContext([player, on_finish](int r) { delete player; @@ -393,7 +393,7 @@ void Journaler::committed(const Future &future) { void Journaler::start_append(int flush_interval, uint64_t flush_bytes, double flush_age) { - assert(m_recorder == nullptr); + ceph_assert(m_recorder == nullptr); // TODO verify active object set >= current replay object set @@ -404,9 +404,9 @@ void Journaler::start_append(int flush_interval, uint64_t flush_bytes, void Journaler::stop_append(Context *on_safe) { JournalRecorder *recorder = nullptr; - assert(m_recorder != nullptr); + ceph_assert(m_recorder != nullptr); std::swap(recorder, m_recorder); - assert(recorder != nullptr); + ceph_assert(recorder != nullptr); on_safe = new FunctionContext([recorder, on_safe](int r) { delete recorder; @@ -434,14 +434,14 @@ void Journaler::flush_append(Context *on_safe) { } void Journaler::create_player(ReplayHandler *replay_handler) { - assert(m_player == nullptr); + ceph_assert(m_player == nullptr); m_player = new JournalPlayer(m_data_ioctx, m_object_oid_prefix, m_metadata, replay_handler); } void Journaler::get_metadata(uint8_t *order, uint8_t *splay_width, int64_t *pool_id) { - assert(m_metadata != nullptr); + ceph_assert(m_metadata != nullptr); *order = m_metadata->get_order(); *splay_width = m_metadata->get_splay_width(); diff --git a/src/journal/ObjectPlayer.cc b/src/journal/ObjectPlayer.cc index 84fa2bfca7f68..cc55674a884da 100644 --- a/src/journal/ObjectPlayer.cc +++ b/src/journal/ObjectPlayer.cc @@ -32,8 +32,8 @@ ObjectPlayer::~ObjectPlayer() { { Mutex::Locker timer_locker(m_timer_lock); Mutex::Locker locker(m_lock); - assert(!m_fetch_in_progress); - assert(m_watch_ctx == nullptr); + ceph_assert(!m_fetch_in_progress); + ceph_assert(m_watch_ctx == nullptr); } } @@ -41,7 +41,7 @@ void ObjectPlayer::fetch(Context *on_finish) { ldout(m_cct, 10) << __func__ << ": " << m_oid << dendl; Mutex::Locker locker(m_lock); - assert(!m_fetch_in_progress); + ceph_assert(!m_fetch_in_progress); m_fetch_in_progress = true; C_Fetch *context = new C_Fetch(this, on_finish); @@ -53,7 +53,7 @@ void ObjectPlayer::fetch(Context *on_finish) { librados::Rados::aio_create_completion(context, utils::rados_ctx_callback, NULL); int r = m_ioctx.aio_operate(m_oid, rados_completion, &op, 0, NULL); - assert(r == 0); + ceph_assert(r == 0); rados_completion->release(); } @@ -63,7 +63,7 @@ void ObjectPlayer::watch(Context *on_fetch, double interval) { Mutex::Locker timer_locker(m_timer_lock); m_watch_interval = interval; - assert(m_watch_ctx == nullptr); + ceph_assert(m_watch_ctx == nullptr); m_watch_ctx = on_fetch; schedule_watch(); @@ -74,7 +74,7 @@ void ObjectPlayer::unwatch() { Context *watch_ctx = nullptr; { Mutex::Locker timer_locker(m_timer_lock); - assert(!m_unwatched); + ceph_assert(!m_unwatched); m_unwatched = true; if (!cancel_watch()) { @@ -91,13 +91,13 @@ void ObjectPlayer::unwatch() { void ObjectPlayer::front(Entry *entry) const { Mutex::Locker locker(m_lock); - assert(!m_entries.empty()); + ceph_assert(!m_entries.empty()); *entry = m_entries.front(); } void ObjectPlayer::pop_front() { Mutex::Locker locker(m_lock); - assert(!m_entries.empty()); + ceph_assert(!m_entries.empty()); auto &entry = m_entries.front(); m_entry_keys.erase({entry.get_tag_tid(), entry.get_entry_tid()}); @@ -119,7 +119,7 @@ int ObjectPlayer::handle_fetch_complete(int r, const bufferlist &bl, } Mutex::Locker locker(m_lock); - assert(m_fetch_in_progress); + ceph_assert(m_fetch_in_progress); m_read_off += bl.length(); m_read_bl.append(bl); m_refetch_state = REFETCH_STATE_REQUIRED; @@ -228,13 +228,13 @@ void ObjectPlayer::clear_invalid_range(uint32_t off, uint32_t len) { } void ObjectPlayer::schedule_watch() { - assert(m_timer_lock.is_locked()); + ceph_assert(m_timer_lock.is_locked()); if (m_watch_ctx == NULL) { return; } ldout(m_cct, 20) << __func__ << ": " << m_oid << " scheduling watch" << dendl; - assert(m_watch_task == nullptr); + ceph_assert(m_watch_task == nullptr); m_watch_task = m_timer.add_event_after( m_watch_interval, new FunctionContext([this](int) { @@ -243,11 +243,11 @@ void ObjectPlayer::schedule_watch() { } bool ObjectPlayer::cancel_watch() { - assert(m_timer_lock.is_locked()); + ceph_assert(m_timer_lock.is_locked()); ldout(m_cct, 20) << __func__ << ": " << m_oid << " cancelling watch" << dendl; if (m_watch_task != nullptr) { bool canceled = m_timer.cancel_event(m_watch_task); - assert(canceled); + ceph_assert(canceled); m_watch_task = nullptr; return true; @@ -256,11 +256,11 @@ bool ObjectPlayer::cancel_watch() { } void ObjectPlayer::handle_watch_task() { - assert(m_timer_lock.is_locked()); + ceph_assert(m_timer_lock.is_locked()); ldout(m_cct, 10) << __func__ << ": " << m_oid << " polling" << dendl; - assert(m_watch_ctx != nullptr); - assert(m_watch_task != nullptr); + ceph_assert(m_watch_ctx != nullptr); + ceph_assert(m_watch_task != nullptr); m_watch_task = nullptr; fetch(new C_WatchFetch(this)); diff --git a/src/journal/ObjectRecorder.cc b/src/journal/ObjectRecorder.cc index 4d79c8969edaa..b54ba9ce8f35a 100644 --- a/src/journal/ObjectRecorder.cc +++ b/src/journal/ObjectRecorder.cc @@ -33,19 +33,19 @@ ObjectRecorder::ObjectRecorder(librados::IoCtx &ioctx, const std::string &oid, m_in_flight_flushes(false), m_aio_scheduled(false) { m_ioctx.dup(ioctx); m_cct = reinterpret_cast(m_ioctx.cct()); - assert(m_handler != NULL); + ceph_assert(m_handler != NULL); } ObjectRecorder::~ObjectRecorder() { - assert(m_append_task == NULL); - assert(m_append_buffers.empty()); - assert(m_in_flight_tids.empty()); - assert(m_in_flight_appends.empty()); - assert(!m_aio_scheduled); + ceph_assert(m_append_task == NULL); + ceph_assert(m_append_buffers.empty()); + ceph_assert(m_in_flight_tids.empty()); + ceph_assert(m_in_flight_appends.empty()); + ceph_assert(!m_aio_scheduled); } bool ObjectRecorder::append_unlock(AppendBuffers &&append_buffers) { - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); FutureImplPtr last_flushed_future; bool schedule_append = false; @@ -101,7 +101,7 @@ void ObjectRecorder::flush(Context *on_safe) { flush_appends(true); } else if (!m_in_flight_appends.empty()) { AppendBuffers &append_buffers = m_in_flight_appends.rbegin()->second; - assert(!append_buffers.empty()); + ceph_assert(!append_buffers.empty()); future = Future(append_buffers.rbegin()->first); } } @@ -117,7 +117,7 @@ void ObjectRecorder::flush(const FutureImplPtr &future) { ldout(m_cct, 20) << __func__ << ": " << m_oid << " flushing " << *future << dendl; - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); 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 @@ -139,10 +139,10 @@ void ObjectRecorder::flush(const FutureImplPtr &future) { break; } } - assert(r_it != m_append_buffers.rend()); + ceph_assert(r_it != m_append_buffers.rend()); auto it = (++r_it).base(); - assert(it != m_append_buffers.end()); + ceph_assert(it != m_append_buffers.end()); ++it; AppendBuffers flush_buffers; @@ -154,10 +154,10 @@ void ObjectRecorder::flush(const FutureImplPtr &future) { void ObjectRecorder::claim_append_buffers(AppendBuffers *append_buffers) { ldout(m_cct, 20) << __func__ << ": " << m_oid << dendl; - assert(m_lock->is_locked()); - assert(m_in_flight_tids.empty()); - assert(m_in_flight_appends.empty()); - assert(m_object_closed || m_overflowed); + ceph_assert(m_lock->is_locked()); + ceph_assert(m_in_flight_tids.empty()); + ceph_assert(m_in_flight_appends.empty()); + ceph_assert(m_object_closed || m_overflowed); append_buffers->splice(append_buffers->end(), m_append_buffers, m_append_buffers.begin(), m_append_buffers.end()); } @@ -171,13 +171,13 @@ bool ObjectRecorder::close() { flush_appends(true); - assert(!m_object_closed); + ceph_assert(!m_object_closed); m_object_closed = true; return (m_in_flight_tids.empty() && !m_in_flight_flushes && !m_aio_scheduled); } void ObjectRecorder::handle_append_task() { - assert(m_timer_lock.is_locked()); + ceph_assert(m_timer_lock.is_locked()); m_append_task = NULL; Mutex::Locker locker(*m_lock); @@ -204,7 +204,7 @@ void ObjectRecorder::schedule_append_task() { bool ObjectRecorder::append(const AppendBuffer &append_buffer, bool *schedule_append) { - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); bool flush_requested = false; if (!m_object_closed && !m_overflowed) { @@ -221,7 +221,7 @@ bool ObjectRecorder::append(const AppendBuffer &append_buffer, } bool ObjectRecorder::flush_appends(bool force) { - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); if (m_object_closed || m_overflowed) { return true; } @@ -249,7 +249,7 @@ void ObjectRecorder::handle_append_flushed(uint64_t tid, int r) { { m_lock->Lock(); auto tid_iter = m_in_flight_tids.find(tid); - assert(tid_iter != m_in_flight_tids.end()); + ceph_assert(tid_iter != m_in_flight_tids.end()); m_in_flight_tids.erase(tid_iter); InFlightAppends::iterator iter = m_in_flight_appends.find(tid); @@ -258,7 +258,7 @@ void ObjectRecorder::handle_append_flushed(uint64_t tid, int r) { m_overflowed = true; } else { // must have seen an overflow on a previous append op - assert(r == -EOVERFLOW && m_overflowed); + ceph_assert(r == -EOVERFLOW && m_overflowed); } // notify of overflow once all in-flight ops are complete @@ -271,9 +271,9 @@ void ObjectRecorder::handle_append_flushed(uint64_t tid, int r) { return; } - assert(iter != m_in_flight_appends.end()); + ceph_assert(iter != m_in_flight_appends.end()); append_buffers.swap(iter->second); - assert(!append_buffers.empty()); + ceph_assert(!append_buffers.empty()); m_in_flight_appends.erase(iter); m_in_flight_flushes = true; @@ -305,8 +305,8 @@ void ObjectRecorder::append_overflowed() { ldout(m_cct, 10) << __func__ << ": " << m_oid << " append overflowed" << dendl; - assert(m_lock->is_locked()); - assert(!m_in_flight_appends.empty()); + ceph_assert(m_lock->is_locked()); + ceph_assert(!m_in_flight_appends.empty()); cancel_append_task(); @@ -335,8 +335,8 @@ void ObjectRecorder::append_overflowed() { } void ObjectRecorder::send_appends(AppendBuffers *append_buffers) { - assert(m_lock->is_locked()); - assert(!append_buffers->empty()); + ceph_assert(m_lock->is_locked()); + ceph_assert(!append_buffers->empty()); for (AppendBuffers::iterator it = append_buffers->begin(); it != append_buffers->end(); ++it) { @@ -388,7 +388,7 @@ void ObjectRecorder::send_appends_aio() { librados::Rados::aio_create_completion(gather_ctx->new_sub(), nullptr, utils::rados_ctx_callback); int r = m_ioctx.aio_operate(m_oid, rados_completion, &op); - assert(r == 0); + ceph_assert(r == 0); rados_completion->release(); { @@ -415,7 +415,7 @@ void ObjectRecorder::send_appends_aio() { } void ObjectRecorder::notify_handler_unlock() { - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); if (m_object_closed) { m_lock->Unlock(); m_handler->closed(this); diff --git a/src/journal/ObjectRecorder.h b/src/journal/ObjectRecorder.h index 88632b2180af4..fd4e88ffafca3 100644 --- a/src/journal/ObjectRecorder.h +++ b/src/journal/ObjectRecorder.h @@ -58,7 +58,7 @@ public: void claim_append_buffers(AppendBuffers *append_buffers); bool is_closed() const { - assert(m_lock->is_locked()); + ceph_assert(m_lock->is_locked()); return (m_object_closed && m_in_flight_appends.empty()); } bool close(); -- 2.39.5