kv: Use ceph_assert for asserts.

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

diff --git a/src/kv/KeyValueDB.h b/src/kv/KeyValueDB.h
index e8d7aced708a41b9d74677c26728010cb3626a7a..0f5c509726d3171727b7305c4dee7bf90f8f62b3 100644 (file)
--- a/src/kv/KeyValueDB.h
+++ b/src/kv/KeyValueDB.h
@@ -142,7 +142,7 @@ public:
       const std::string &prefix,   ///< [in] Prefix/CF ==> MUST match some established merge operator
       const std::string &key,      ///< [in] Key to be merged
       const bufferlist  &value     ///< [in] value to be merged into key
-    ) { assert(0 == "Not implemented"); }
+    ) { ceph_assert(0 == "Not implemented"); }
 
     virtual ~TransactionImpl() {}
   };

diff --git a/src/kv/KineticStore.cc b/src/kv/KineticStore.cc
index 682f3f1cf0d43955451fcedaad8d7bdd3dce7534..95c76380e042c28812432e5e8efbfd05d57c78d0 100644 (file)
--- a/src/kv/KineticStore.cc
+++ b/src/kv/KineticStore.cc
@@ -47,7 +47,7 @@ int KineticStore::_test_init(CephContext *c)
 int KineticStore::open(ostream &out, const vector<ColumnFamily>& cfs)
 {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, false);
 }
@@ -55,7 +55,7 @@ int KineticStore::open(ostream &out, const vector<ColumnFamily>& cfs)
 int KineticStore::create_and_open(ostream &out, const vector<ColumnFamily>& cfs)
 {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, true);
 }
@@ -128,7 +128,7 @@ int KineticStore::submit_transaction(KeyValueDB::Transaction t)
                                 record);
       dout(30) << "kinetic after put of " << it->key << dendl;
     } else {
-      assert(it->type == KINETIC_OP_DELETE);
+      ceph_assert(it->type == KINETIC_OP_DELETE);
       dout(30) << "kinetic before delete" << dendl;
       status = kinetic_conn->Delete(it->key, "",
                                    kinetic::WriteMode::IGNORE_VERSION);

diff --git a/src/kv/LevelDBStore.cc b/src/kv/LevelDBStore.cc
index c2ba32686bb195165729590b1e140e24e699c19e..214cf77c4120e3c028214d5a362aecd74789bea7 100644 (file)
--- a/src/kv/LevelDBStore.cc
+++ b/src/kv/LevelDBStore.cc
@@ -61,14 +61,14 @@ int LevelDBStore::init(string option_str)
 
 int LevelDBStore::open(ostream &out, const vector<ColumnFamily>& cfs)  {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, false);
 }
 
 int LevelDBStore::create_and_open(ostream &out, const vector<ColumnFamily>& cfs) {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, true);
 }
@@ -93,7 +93,7 @@ int LevelDBStore::load_leveldb_options(bool create_if_missing, leveldb::Options
     filterpolicy.reset(_filterpolicy);
     ldoptions.filter_policy = filterpolicy.get();
 #else
-    assert(0 == "bloom size set but installed leveldb doesn't support bloom filters");
+    ceph_assert(0 == "bloom size set but installed leveldb doesn't support bloom filters");
 #endif
   }
   if (options.compression_enabled)
@@ -323,7 +323,7 @@ int LevelDBStore::get(const string &prefix,
       const string &key,
       bufferlist *out)
 {
-  assert(out && (out->length() == 0));
+  ceph_assert(out && (out->length() == 0));
   utime_t start = ceph_clock_now();
   int r = 0;
   string value, k;

diff --git a/src/kv/MemDB.cc b/src/kv/MemDB.cc
index dac64a45f9dd76373eb980b8c61da2b245ddf30d..649352fd51befc3fe847fbb1f66128d5121140b4 100644 (file)
--- a/src/kv/MemDB.cc
+++ b/src/kv/MemDB.cc
@@ -38,7 +38,7 @@
 static void split_key(const string& raw_key, string *prefix, string *key)
 {
   size_t pos = raw_key.find(KEY_DELIM, 0);
-  assert(pos != std::string::npos);
+  ceph_assert(pos != std::string::npos);
   *prefix = raw_key.substr(0, pos);
   *key = raw_key.substr(pos + 1, raw_key.length());
 }
@@ -177,14 +177,14 @@ int MemDB::do_open(ostream &out, bool create)
 
 int MemDB::open(ostream &out, const vector<ColumnFamily>& cfs) {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, false);
 }
 
 int MemDB::create_and_open(ostream &out, const vector<ColumnFamily>& cfs) {
   if (!cfs.empty()) {
-    assert(0 == "Not implemented");
+    ceph_assert(0 == "Not implemented");
   }
   return do_open(out, true);
 }
@@ -221,7 +221,7 @@ int MemDB::submit_transaction(KeyValueDB::Transaction t)
       _merge(merge_op);
     } else {
       ms_op_t rm_op = op.second;
-      assert(op.first == MDBTransactionImpl::DELETE);
+      ceph_assert(op.first == MDBTransactionImpl::DELETE);
       _rmkey(rm_op);
     }
   }
@@ -307,7 +307,7 @@ int MemDB::_setkey(ms_op_t &op)
     /*
      * delete and free existing key.
      */
-    assert(m_total_bytes >= bl_old.length());
+    ceph_assert(m_total_bytes >= bl_old.length());
     m_total_bytes -= bl_old.length();
     m_map.erase(key);
   }
@@ -324,7 +324,7 @@ int MemDB::_rmkey(ms_op_t &op)
 
   bufferlist bl_old;
   if (_get(op.first.first, op.first.second, &bl_old)) {
-    assert(m_total_bytes >= bl_old.length());
+    ceph_assert(m_total_bytes >= bl_old.length());
     m_total_bytes -= bl_old.length();
   }
   iterator_seq_no++;
@@ -359,7 +359,7 @@ int MemDB::_merge(ms_op_t &op)
    *  find the operator for this prefix
    */
   std::shared_ptr<MergeOperator> mop = _find_merge_op(prefix);
-  assert(mop);
+  ceph_assert(mop);
 
   /*
    * call the merge operator with value and non value
@@ -383,7 +383,7 @@ int MemDB::_merge(ms_op_t &op)
     bl_old.clear();
   }
 
-  assert((int64_t)m_total_bytes + bytes_adjusted >= 0);
+  ceph_assert((int64_t)m_total_bytes + bytes_adjusted >= 0);
   m_total_bytes += bytes_adjusted;
   iterator_seq_no++;
   return 0;
@@ -468,7 +468,7 @@ bool MemDB::MDBWholeSpaceIteratorImpl::iterator_validate() {
 
   if (this_seq_no != *global_seq_no) {
     auto key = m_key_value.first;
-    assert(!key.empty());
+    ceph_assert(!key.empty());
 
     bool restart_iter = false;
     if (!m_using_btree) {

diff --git a/src/kv/RocksDBStore.cc b/src/kv/RocksDBStore.cc
index b59bb3dfeeae8771c4eec5ba582a97d57154275d..fd02b8315c9213e9b269c4985babb614f68f5276 100644 (file)
--- a/src/kv/RocksDBStore.cc
+++ b/src/kv/RocksDBStore.cc
@@ -153,7 +153,7 @@ int RocksDBStore::set_merge_operator(
   std::shared_ptr<KeyValueDB::MergeOperator> mop)
 {
   // If you fail here, it's because you can't do this on an open database
-  assert(db == nullptr);
+  ceph_assert(db == nullptr);
   merge_ops.push_back(std::make_pair(prefix,mop));
   return 0;
 }
@@ -301,7 +301,7 @@ int RocksDBStore::install_cf_mergeop(
   const string &cf_name,
   rocksdb::ColumnFamilyOptions *cf_opt)
 {
-  assert(cf_opt != nullptr);
+  ceph_assert(cf_opt != nullptr);
   cf_opt->merge_operator.reset();
   for (auto& i : merge_ops) {
     if (i.first == cf_name) {
@@ -570,7 +570,7 @@ int RocksDBStore::do_open(ostream &out, bool create_if_missing,
       }
     }
   }
-  assert(default_cf != nullptr);
+  ceph_assert(default_cf != nullptr);
   
   PerfCountersBuilder plb(g_ceph_context, "rocksdb", l_rocksdb_first, l_rocksdb_last);
   plb.add_u64_counter(l_rocksdb_gets, "get", "Gets");
@@ -1085,7 +1085,7 @@ int RocksDBStore::get(
     const string &key,
     bufferlist *out)
 {
-  assert(out && (out->length() == 0));
+  ceph_assert(out && (out->length() == 0));
   utime_t start = ceph_clock_now();
   int r = 0;
   string value;
@@ -1122,7 +1122,7 @@ int RocksDBStore::get(
   size_t keylen,
   bufferlist *out)
 {
-  assert(out && (out->length() == 0));
+  ceph_assert(out && (out->length() == 0));
   utime_t start = ceph_clock_now();
   int r = 0;
   string value;
@@ -1344,20 +1344,20 @@ RocksDBStore::RocksDBWholeSpaceIteratorImpl::~RocksDBWholeSpaceIteratorImpl()
 int RocksDBStore::RocksDBWholeSpaceIteratorImpl::seek_to_first()
 {
   dbiter->SeekToFirst();
-  assert(!dbiter->status().IsIOError());
+  ceph_assert(!dbiter->status().IsIOError());
   return dbiter->status().ok() ? 0 : -1;
 }
 int RocksDBStore::RocksDBWholeSpaceIteratorImpl::seek_to_first(const string &prefix)
 {
   rocksdb::Slice slice_prefix(prefix);
   dbiter->Seek(slice_prefix);
-  assert(!dbiter->status().IsIOError());
+  ceph_assert(!dbiter->status().IsIOError());
   return dbiter->status().ok() ? 0 : -1;
 }
 int RocksDBStore::RocksDBWholeSpaceIteratorImpl::seek_to_last()
 {
   dbiter->SeekToLast();
-  assert(!dbiter->status().IsIOError());
+  ceph_assert(!dbiter->status().IsIOError());
   return dbiter->status().ok() ? 0 : -1;
 }
 int RocksDBStore::RocksDBWholeSpaceIteratorImpl::seek_to_last(const string &prefix)
@@ -1399,7 +1399,7 @@ int RocksDBStore::RocksDBWholeSpaceIteratorImpl::next()
   if (valid()) {
     dbiter->Next();
   }
-  assert(!dbiter->status().IsIOError());
+  ceph_assert(!dbiter->status().IsIOError());
   return dbiter->status().ok() ? 0 : -1;
 }
 int RocksDBStore::RocksDBWholeSpaceIteratorImpl::prev()
@@ -1407,7 +1407,7 @@ int RocksDBStore::RocksDBWholeSpaceIteratorImpl::prev()
   if (valid()) {
     dbiter->Prev();
   }
-  assert(!dbiter->status().IsIOError());
+  ceph_assert(!dbiter->status().IsIOError());
   return dbiter->status().ok() ? 0 : -1;
 }
 string RocksDBStore::RocksDBWholeSpaceIteratorImpl::key()

diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.cc b/src/kv/rocksdb_cache/BinnedLRUCache.cc
index 19e89141342590d56529dc7790a7716d49acc0d3..217f0c1dcffe4f1fec36333eb5ea70a76fa92a4d 100644 (file)
--- a/src/kv/rocksdb_cache/BinnedLRUCache.cc
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.cc
@@ -91,7 +91,7 @@ void BinnedLRUHandleTable::Resize() {
       count++;
     }
   }
-  assert(elems_ == count);
+  ceph_assert(elems_ == count);
   delete[] list_;
   list_ = new_list;
   length_ = new_length;
@@ -116,7 +116,7 @@ BinnedLRUCacheShard::BinnedLRUCacheShard(size_t capacity, bool strict_capacity_l
 BinnedLRUCacheShard::~BinnedLRUCacheShard() {}
 
 bool BinnedLRUCacheShard::Unref(BinnedLRUHandle* e) {
-  assert(e->refs > 0);
+  ceph_assert(e->refs > 0);
   e->refs--;
   return e->refs == 0;
 }
@@ -129,8 +129,8 @@ void BinnedLRUCacheShard::EraseUnRefEntries() {
     std::lock_guard<std::mutex> l(mutex_);
     while (lru_.next != &lru_) {
       BinnedLRUHandle* old = lru_.next;
-      assert(old->InCache());
-      assert(old->refs ==
+      ceph_assert(old->InCache());
+      ceph_assert(old->refs ==
              1);  // LRU list contains elements which may be evicted
       LRU_Remove(old);
       table_.Remove(old->key(), old->hash);
@@ -184,8 +184,8 @@ size_t BinnedLRUCacheShard::GetHighPriPoolUsage() const {
 }
 
 void BinnedLRUCacheShard::LRU_Remove(BinnedLRUHandle* e) {
-  assert(e->next != nullptr);
-  assert(e->prev != nullptr);
+  ceph_assert(e->next != nullptr);
+  ceph_assert(e->prev != nullptr);
   if (lru_low_pri_ == e) {
     lru_low_pri_ = e->prev;
   }
@@ -194,14 +194,14 @@ void BinnedLRUCacheShard::LRU_Remove(BinnedLRUHandle* e) {
   e->prev = e->next = nullptr;
   lru_usage_ -= e->charge;
   if (e->InHighPriPool()) {
-    assert(high_pri_pool_usage_ >= e->charge);
+    ceph_assert(high_pri_pool_usage_ >= e->charge);
     high_pri_pool_usage_ -= e->charge;
   }
 }
 
 void BinnedLRUCacheShard::LRU_Insert(BinnedLRUHandle* e) {
-  assert(e->next == nullptr);
-  assert(e->prev == nullptr);
+  ceph_assert(e->next == nullptr);
+  ceph_assert(e->prev == nullptr);
   if (high_pri_pool_ratio_ > 0 && e->IsHighPri()) {
     // Inset "e" to head of LRU list.
     e->next = &lru_;
@@ -228,7 +228,7 @@ void BinnedLRUCacheShard::MaintainPoolSize() {
   while (high_pri_pool_usage_ > high_pri_pool_capacity_) {
     // Overflow last entry in high-pri pool to low-pri pool.
     lru_low_pri_ = lru_low_pri_->next;
-    assert(lru_low_pri_ != &lru_);
+    ceph_assert(lru_low_pri_ != &lru_);
     lru_low_pri_->SetInHighPriPool(false);
     high_pri_pool_usage_ -= lru_low_pri_->charge;
   }
@@ -238,8 +238,8 @@ void BinnedLRUCacheShard::EvictFromLRU(size_t charge,
                                  ceph::autovector<BinnedLRUHandle*>* deleted) {
   while (usage_ + charge > capacity_ && lru_.next != &lru_) {
     BinnedLRUHandle* old = lru_.next;
-    assert(old->InCache());
-    assert(old->refs == 1);  // LRU list contains elements which may be evicted
+    ceph_assert(old->InCache());
+    ceph_assert(old->refs == 1);  // LRU list contains elements which may be evicted
     LRU_Remove(old);
     table_.Remove(old->key(), old->hash);
     old->SetInCache(false);
@@ -273,7 +273,7 @@ rocksdb::Cache::Handle* BinnedLRUCacheShard::Lookup(const rocksdb::Slice& key, u
   std::lock_guard<std::mutex> l(mutex_);
   BinnedLRUHandle* e = table_.Lookup(key, hash);
   if (e != nullptr) {
-    assert(e->InCache());
+    ceph_assert(e->InCache());
     if (e->refs == 1) {
       LRU_Remove(e);
     }
@@ -317,7 +317,7 @@ bool BinnedLRUCacheShard::Release(rocksdb::Cache::Handle* handle, bool force_era
       if (usage_ > capacity_ || force_erase) {
         // the cache is full
         // The LRU list must be empty since the cache is full
-        assert(!(usage_ > capacity_) || lru_.next == &lru_);
+        ceph_assert(!(usage_ > capacity_) || lru_.next == &lru_);
         // take this opportunity and remove the item
         table_.Remove(e->key(), e->hash);
         e->SetInCache(false);
@@ -447,7 +447,7 @@ size_t BinnedLRUCacheShard::GetUsage() const {
 
 size_t BinnedLRUCacheShard::GetPinnedUsage() const {
   std::lock_guard<std::mutex> l(mutex_);
-  assert(usage_ >= lru_usage_);
+  ceph_assert(usage_ >= lru_usage_);
   return usage_ - lru_usage_;
 }
 

diff --git a/src/kv/rocksdb_cache/BinnedLRUCache.h b/src/kv/rocksdb_cache/BinnedLRUCache.h
index 81cf06b96542580e936a70bcd36a3ce20d68efe5..94b76b422a97aa6451710a951f80ad69f19152e4 100644 (file)
--- a/src/kv/rocksdb_cache/BinnedLRUCache.h
+++ b/src/kv/rocksdb_cache/BinnedLRUCache.h
@@ -16,6 +16,7 @@
 #include "ShardedCache.h"
 
 #include "common/autovector.h"
+#include "include/assert.h"
 
 namespace rocksdb_cache {
 
@@ -114,7 +115,7 @@ struct BinnedLRUHandle {
   void SetHit() { flags |= 8; }
 
   void Free() {
-    assert((refs == 1 && InCache()) || (refs == 0 && !InCache()));
+    ceph_assert((refs == 1 && InCache()) || (refs == 0 && !InCache()));
     if (deleter) {
       (*deleter)(key(), value);
     }
@@ -142,7 +143,7 @@ class BinnedLRUHandleTable {
       BinnedLRUHandle* h = list_[i];
       while (h != nullptr) {
         auto n = h->next_hash;
-        assert(h->InCache());
+        ceph_assert(h->InCache());
         func(h);
         h = n;
       }