journal: Use ceph_assert for asserts.

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/journal/Entry.cc b/src/journal/Entry.cc
index 16a5af113eb4fd6c78086057e6bf985bc2161bfd..48648a872dfc3ec36a6eae2a68c27b1703306f84 100644 (file)
--- 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 144f32052277878856db969f8c95cdca18537bb4..c2eaa967ac90675d79852977ac60dcfee519cca7 100644 (file)
--- 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 e46a3c9cbf3723b04603e2425148f294d8304a82..eac3fc39ba31f228f5ca2af5a2100b374f19f683 100644 (file)
--- 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 1c02c9a2d11e76feb998b3665d2e98d95a4fd636..f44f0e08913e42eeb6149016a586437c2eae7888 100644 (file)
--- 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 2f53e3da5fecf5f1079a74fa618eb4277a88f629..f35eccb131fff2b67880193815ed851e586dfafe 100644 (file)
--- 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 511802180804448f90269c30e219c46f23222176..89952e636a439274c273bf427d980babb61e4637 100644 (file)
--- 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<uint8_t, uint64_t> 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<uint64_t>& 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<uint64_t>& 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 c7d8cd1ac1efb9f43cf946932286f2e4415dea99..0cfebe480f4abb89d6aea989cfea8fb4c81d5c3d 100644 (file)
--- 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 6d3caed03df10e260b49c441a679f9a890ad3649..d3289499a090d3ecca0c4db94a5d85f1f143650a 100644 (file)
--- 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 5b580c50005db0111b46b6509f9d16ee816eb563..65d32de3d1e95f93b62cac15693424c438722360 100644 (file)
--- 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 84fa2bfca7f683159d248cae8f8a2d9b61931da9..cc55674a884dacf25265fd485516378014ea6f7f 100644 (file)
--- 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 4d79c8969edaa236fe4193ed9689708bc57fdd03..b54ba9ce8f35a856cb560762112f5da9ce468e28 100644 (file)
--- 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<CephContext*>(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 88632b2180af418332847d8c4f8996711c79e9b6..fd4e88ffafca3a35a69292ebea9a43574b462d4b 100644 (file)
--- 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();