add_executable(ceph_test_cfuse_cache_invalidate
test_cfuse_cache_invalidate.cc
)
+ target_link_libraries(ceph_test_cfuse_cache_invalidate
+ ceph-common
+ )
endif(WITH_FUSE)
if(${WITH_CEPHFS})
return 0;
}
--it;
- assert(it != db->db.end());
+ ceph_assert(it != db->db.end());
ready = true;
return 0;
}
return 0;
}
- assert(it != db->db.end());
+ ceph_assert(it != db->db.end());
ready = true;
return 0;
ready = false;
return 0;
}
- assert(it != db->db.end());
+ ceph_assert(it != db->db.end());
ready = true;
return 0;
}
for (map<int, KeyValueDB::Iterator>::iterator i = iterators.begin();
i != iterators.end();
++i) {
- assert(i->second->valid());
- assert(i->second->key() == iterators.rbegin()->second->key());
+ ceph_assert(i->second->valid());
+ ceph_assert(i->second->key() == iterators.rbegin()->second->key());
bufferlist r = i->second->value();
bufferlist l = iterators.rbegin()->second->value();
i->second->next();
for (map<int, KeyValueDB::Iterator>::iterator i = iterators.begin();
i != iterators.end();
++i) {
- assert(!i->second->valid());
+ ceph_assert(!i->second->valid());
}
}
return 0;
for (int j = 0; j < NUM_COPIES; ++j) {
t->set(prefix_gen(j), to_set);
}
- assert(!db->submit_transaction(t));
+ ceph_assert(!db->submit_transaction(t));
}
return 0;
}
string strpath(path);
std::cerr << "Using path: " << strpath << std::endl;
KeyValueDB *store = KeyValueDB::create(g_ceph_context, "leveldb", strpath);
- assert(!store->create_and_open(std::cerr));
+ ceph_assert(!store->create_and_open(std::cerr));
db.reset(store);
verify(db.get());
boost::scoped_ptr<KeyValueDBMemory> mock;
void SetUp() override {
- assert(!store_path.empty());
+ ceph_assert(!store_path.empty());
KeyValueDB *db_ptr = KeyValueDB::create(g_ceph_context, "leveldb", store_path);
- assert(!db_ptr->create_and_open(std::cerr));
+ ceph_assert(!db_ptr->create_and_open(std::cerr));
db.reset(db_ptr);
mock.reset(new KeyValueDBMemory());
}
cerr << "using path " << strpath << std::endl;
KeyValueDB *store = KeyValueDB::create(g_ceph_context, "leveldb", strpath);
- assert(!store->create_and_open(cerr));
+ ceph_assert(!store->create_and_open(cerr));
db.reset(new DBObjectMap(g_ceph_context, store));
tester.db = db.get();
string num_to_key(unsigned i) {
char buf[100];
int ret = snprintf(buf, sizeof(buf), "%010u", i);
- assert(ret > 0);
+ ceph_assert(ret > 0);
return string(buf, ret);
}
snprintf(cmd, sizeof(cmd), "echo ABC > %s", FILENAME);
EXPECT_EQ(0, ::system(cmd));
fd = ::open(FILENAME, O_RDONLY);
- assert(fd >= 0);
+ ceph_assert(fd >= 0);
}
void TearDown() override {
::close(fd);
std::cout << "a.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1138817026u);
}
- assert(buffer::get_cached_crc() == 0 + base_cached);
+ ceph_assert(buffer::get_cached_crc() == 0 + base_cached);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(0);
std::cout << "a.crc32c(0) (again) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1138817026u);
}
- assert(buffer::get_cached_crc() == 1 + base_cached);
+ ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
{
utime_t start = ceph_clock_now();
std::cout << "a.crc32c(5) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 3239494520u);
}
- assert(buffer::get_cached_crc() == 1 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 1 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 1 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(5);
std::cout << "a.crc32c(5) (again) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 3239494520u);
}
- assert(buffer::get_cached_crc() == 1 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 2 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 2 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = blb.crc32c(0);
std::cout << "b.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2481791210u);
}
- assert(buffer::get_cached_crc() == 1 + base_cached);
+ ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
{
utime_t start = ceph_clock_now();
uint32_t r = blb.crc32c(0);
std::cout << "b.crc32c(0) (again)= " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2481791210u);
}
- assert(buffer::get_cached_crc() == 2 + base_cached);
+ ceph_assert(buffer::get_cached_crc() == 2 + base_cached);
bufferlist ab;
ab.push_back(a);
std::cout << "ab.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2988268779u);
}
- assert(buffer::get_cached_crc() == 3 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 3 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
bufferlist ac;
ac.push_back(a);
ac.push_back(c);
std::cout << "ac.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2988268779u);
}
- assert(buffer::get_cached_crc() == 4 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 4 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
bufferlist ba;
ba.push_back(b);
std::cout << "ba.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 169240695u);
}
- assert(buffer::get_cached_crc() == 5 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 4 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 5 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 4 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = ba.crc32c(5);
std::cout << "ba.crc32c(5) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1265464778u);
}
- assert(buffer::get_cached_crc() == 5 + base_cached);
- assert(buffer::get_cached_crc_adjusted() == 6 + base_cached_adjusted);
+ ceph_assert(buffer::get_cached_crc() == 5 + base_cached);
+ ceph_assert(buffer::get_cached_crc_adjusted() == 6 + base_cached_adjusted);
cout << "crc cache hits (same start) = " << buffer::get_cached_crc() << std::endl;
cout << "crc cache hits (adjusted) = " << buffer::get_cached_crc_adjusted() << std::endl;
#include "include/compat.h"
#include "include/coredumpctl.h"
-//#undef assert
-//#define assert(foo) if (!(foo)) abort();
-
#include "include/CompatSet.h"
#include "gtest/gtest.h"
add_executable(unittest_prioritized_queue
test_prioritized_queue.cc
)
+target_link_libraries(unittest_prioritized_queue ceph-common)
add_ceph_unittest(unittest_prioritized_queue)
# unittest_mclock_priority_queue
add_executable(unittest_weighted_priority_queue
test_weighted_priority_queue.cc
)
+target_link_libraries(unittest_weighted_priority_queue ceph-common)
add_ceph_unittest(unittest_weighted_priority_queue)
# unittest_mutex_debug
add_executable(unittest_async_shared_mutex test_async_shared_mutex.cc)
add_ceph_unittest(unittest_async_shared_mutex)
-target_link_libraries(unittest_async_shared_mutex Boost::system)
+target_link_libraries(unittest_async_shared_mutex ceph-common Boost::system)
bool test_object_contents()
{
ObjectContents c, d;
- assert(!c.exists());
+ ceph_assert(!c.exists());
c.debug(std::cerr);
c.write(10, 10, 10);
- assert(c.exists());
- assert(c.size() == 20);
+ ceph_assert(c.exists());
+ ceph_assert(c.size() == 20);
c.debug(std::cerr);
bufferlist bl;
++iter) {
bl.append(*iter);
}
- assert(bl.length() == 20);
+ ceph_assert(bl.length() == 20);
bufferlist bl2;
for (unsigned i = 0; i < 8; ++i) bl2.append(bl[i]);
bl2.append(*iter);
}
for (unsigned i = 12; i < 20; ++i) bl2.append(bl[i]);
- assert(bl2.length() == 20);
+ ceph_assert(bl2.length() == 20);
for (ObjectContents::Iterator iter3 = c.get_iterator();
iter.valid();
++iter) {
- assert(bl2[iter3.get_pos()] == *iter3);
+ ceph_assert(bl2[iter3.get_pos()] == *iter3);
}
- assert(bl2[0] == '\0');
- assert(bl2[7] == '\0');
+ ceph_assert(bl2[0] == '\0');
+ ceph_assert(bl2[7] == '\0');
interval_set<uint64_t> to_clone;
to_clone.insert(5, 10);
d.clone_range(c, to_clone);
- assert(d.size() == 15);
+ ceph_assert(d.size() == 15);
c.debug(std::cerr);
d.debug(std::cerr);
iter2.seek_to(5);
for (uint64_t i = 5; i < 15; ++i, ++iter2) {
std::cerr << "i is " << i << std::endl;
- assert(iter2.get_pos() == i);
- assert(*iter2 == bl2[i]);
+ ceph_assert(iter2.get_pos() == i);
+ ceph_assert(*iter2 == bl2[i]);
}
return true;
}
Iterator &operator++() {
++pos;
if (iter != parent->seeds.end() && pos >= iter->first) {
- assert(pos == iter->first);
+ ceph_assert(pos == iter->first);
current_state = iter->second;
++iter;
}
max_multiple,
max,
0);
- assert(valid);
+ ceph_assert(valid);
auto getter = [&]() {
std::random_device rd;
total_observed_total += total;
total_observations++;
in_queue.pop_front();
- assert(total <= max);
+ ceph_assert(total <= max);
g.unlock();
std::this_thread::sleep_for(
ptr1 = std::shared_ptr<int>();
std::shared_ptr<int> res = registry.lookup(key1);
- assert(res);
- assert(res == ptr2);
- assert(*res == 500);
+ ceph_assert(res);
+ ceph_assert(res == ptr2);
+ ceph_assert(*res == 500);
}
{
SharedPtrRegistryTest registry;
ptr1 = std::shared_ptr<int>();
std::shared_ptr<int> res = registry.lookup(key1);
- assert(res);
- assert(res == ptr2);
- assert(*res == 500);
+ ceph_assert(res);
+ ceph_assert(res == ptr2);
+ ceph_assert(*res == 500);
}
}
g_conf().set_val("compressor_zlib_isal", "false");
g_ceph_context->_conf.apply_changes(nullptr);
} else {
- assert(0 == "bad option");
+ ceph_assert(0 == "bad option");
}
}
cout << "[plugin " << plugin << " (" << GetParam() << ")]" << std::endl;
item = 2;
c.insert_item(g_ceph_context, item, weight, "osd.2", loc);
- assert(c.add_simple_rule("rule1", "r11", "host", "",
+ ceph_assert(c.add_simple_rule("rule1", "r11", "host", "",
"firstn", pg_pool_t::TYPE_ERASURE) >= 0);
int id = c.get_item_id("b1");
weight_set.size = 1;
weight_set.weights = &weights;
int maxbuckets = c.get_max_buckets();
- assert(maxbuckets > 0);
+ ceph_assert(maxbuckets > 0);
crush_choose_arg choose_args[maxbuckets];
memset(choose_args, '\0', sizeof(crush_choose_arg) * maxbuckets);
choose_args[-1-id].ids_size = 0;
loc["root"] = "default";
c.insert_item(g_ceph_context, item, weight, "osd.2", loc);
- assert(c.add_simple_rule("rule1", "r11", "host", "",
+ ceph_assert(c.add_simple_rule("rule1", "r11", "host", "",
"firstn", pg_pool_t::TYPE_ERASURE) >= 0);
ASSERT_TRUE(c.name_exists("default"));
ASSERT_TRUE(c.name_exists("r11"));
int ret;
int ruleno = 0;
ret = c->add_rule(ruleno, 4, 123, 1, 20);
- assert(ret == ruleno);
+ ceph_assert(ret == ruleno);
ret = c->set_rule_step(ruleno, 0, CRUSH_RULE_SET_CHOOSELEAF_TRIES, 10, 0);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = c->set_rule_step(ruleno, 1, CRUSH_RULE_TAKE, rootno, 0);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = c->set_rule_step(ruleno, 2, CRUSH_RULE_CHOOSELEAF_INDEP, CRUSH_CHOOSE_N, 1);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = c->set_rule_step(ruleno, 3, CRUSH_RULE_EMIT, 0, 0);
- assert(ret == 0);
+ ceph_assert(ret == 0);
c->set_rule_name(ruleno, "data");
c->finalize();
PK11Context *ectx;
ectx = PK11_CreateContextBySymKey(mechanism, op, key, param);
- assert(ectx);
+ ceph_assert(ectx);
incopy = in; // it's a shallow copy!
in_buf = (unsigned char*)incopy.c_str();
std::vector<Collection>& collections,
uint64_t count)
{
- assert(count > 0);
+ ceph_assert(count > 0);
collections.reserve(count);
const int split_bits = cbits(count - 1);
Engine::~Engine()
{
- assert(!ref_count);
+ ceph_assert(!ref_count);
}
struct Object {
// fill attrs if any
if (o->oi_attr_len_high) {
- assert(o->oi_attr_len_high >= o->oi_attr_len_low);
+ ceph_assert(o->oi_attr_len_high >= o->oi_attr_len_low);
// fill with the garbage as we do not care of the actual content...
job->one_for_all_data.set_length(
ceph::util::generate_random_number(
attrset["_"] = job->one_for_all_data;
}
if (o->snapset_attr_len_high) {
- assert(o->snapset_attr_len_high >= o->snapset_attr_len_low);
+ ceph_assert(o->snapset_attr_len_high >= o->snapset_attr_len_low);
job->one_for_all_data.set_length(
ceph::util::generate_random_number
(o->snapset_attr_len_low, o->snapset_attr_len_high));
}
if (o->_fastinfo_omap_len_high) {
- assert(o->_fastinfo_omap_len_high >= o->_fastinfo_omap_len_low);
+ ceph_assert(o->_fastinfo_omap_len_high >= o->_fastinfo_omap_len_low);
// fill with the garbage as we do not care of the actual content...
job->one_for_all_data.set_length(
ceph::util::generate_random_number(
}
if (o->pglog_omap_len_high) {
- assert(o->pglog_omap_len_high >= o->pglog_omap_len_low);
+ ceph_assert(o->pglog_omap_len_high >= o->pglog_omap_len_low);
snprintf(ver_key, sizeof(ver_key),
"0000000011.%020llu", (unsigned long long)pglog_ver_cnt);
// fill with the garbage as we do not care of the actual content...
}
if (o->pglog_dup_omap_len_high) {
//insert dup
- assert(o->pglog_dup_omap_len_high >= o->pglog_dup_omap_len_low);
+ ceph_assert(o->pglog_dup_omap_len_high >= o->pglog_dup_omap_len_low);
for( auto i = pglog_trim_tail; i < pglog_trim_head; ++i) {
snprintf(ver_key, sizeof(ver_key),
"dup_0000000011.%020llu", (unsigned long long)i);
struct MockFuture {
static MockFuture *s_instance;
static MockFuture &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
struct MockReplayEntry {
static MockReplayEntry *s_instance;
static MockReplayEntry &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
struct MockJournaler {
static MockJournaler *s_instance;
static MockJournaler &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
++refs;
}
void put() override {
- assert(refs > 0);
+ ceph_assert(refs > 0);
--refs;
}
void flush(const journal::FutureImplPtr &future) override {
Mutex::Locker l(ops_in_flight_lock);
for (int i = 0; i < ops; i++) {
- assert(ops_in_flight <= max_ops_in_flight);
+ ceph_assert(ops_in_flight <= max_ops_in_flight);
if (ops_in_flight == max_ops_in_flight) {
int err = op_avail.Wait(ops_in_flight_lock);
if (err < 0) {
ceph_abort();
return err;
}
- assert(ops_in_flight < max_ops_in_flight);
+ ceph_assert(ops_in_flight < max_ops_in_flight);
}
cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" << i + 1 << " / "
<< ops << std::endl;
#include <thread>
#include <atomic>
+#include "include/assert.h"
+
/* in ms -- 1 minute */
#define MAX_WAIT (60 * 1000)
break;
default:
// Bad command
- assert(false);
+ ceph_assert(false);
}
if (ret != -EAGAIN)
break;
json_spirit::mValue root;
[[maybe_unused]] bool json_parse_success = json_spirit::read(out, root);
- assert(json_parse_success);
+ ceph_assert(json_parse_success);
json_spirit::mObject root_obj = root.get_obj();
json_spirit::mObject pgmap = root_obj["pgmap"].get_obj();
json_spirit::mArray pgs_by_state = pgmap["pgs_by_state"].get_array();
+ string("\",\"var\": \"pg_num\",\"format\": \"json\"}");
bufferlist outbl;
int r = cluster.mon_command(cmd, inbl, &outbl, NULL);
- assert(r >= 0);
+ ceph_assert(r >= 0);
string outstr(outbl.c_str(), outbl.length());
json_spirit::Value v;
if (!json_spirit::read(outstr, v)) {
TEST_F(LibRadosTwoPoolsPP, HitSetWrite) {
int num_pg = _get_pg_num(cluster, pool_name);
- assert(num_pg > 0);
+ ceph_assert(num_pg > 0);
// make it a tier
bufferlist inbl;
#if 0
TEST_F(LibRadosTierECPP, HitSetWrite) {
int num_pg = _get_pg_num(cluster, pool_name);
- assert(num_pg > 0);
+ ceph_assert(num_pg > 0);
// enable hitset tracking for this pool
bufferlist inbl;
{
std::cout << __func__ << " from " << notifier_gid << " notify_id " << notify_id
<< " cookie " << cookie << std::endl;
- assert(notifier_gid > 0);
+ ceph_assert(notifier_gid > 0);
auto thiz = reinterpret_cast<LibRadosWatchNotify*>(arg);
- assert(thiz);
+ ceph_assert(thiz);
thiz->notify_cookies.insert(cookie);
thiz->notify_bl.clear();
thiz->notify_bl.append((char*)data, data_len);
int err)
{
std::cout << __func__ << " cookie " << cookie << " err " << err << std::endl;
- assert(cookie > 1000);
+ ceph_assert(cookie > 1000);
auto thiz = reinterpret_cast<LibRadosWatchNotify*>(arg);
- assert(thiz);
+ ceph_assert(thiz);
thiz->notify_err = err;
}
void handle_error(uint64_t cookie, int err) override {
std::cout << __func__ << " cookie " << cookie
<< " err " << err << std::endl;
- assert(cookie > 1000);
+ ceph_assert(cookie > 1000);
notify->notify_err = err;
}
};
impl->get();
client = reinterpret_cast<RadosClient*>(impl);
- assert(client != NULL);
+ ceph_assert(client != NULL);
}
Rados::~Rados() {
AioCompletionImpl *c;
int r = rados_aio_create_completion(cb_arg, cb_complete, cb_safe,
reinterpret_cast<void**>(&c));
- assert(r == 0);
+ ceph_assert(r == 0);
return new AioCompletion(c);
}
}
void TestClassHandler::open_all_classes() {
- assert(m_class_handles.empty());
+ ceph_assert(m_class_handles.empty());
const char* env = getenv("CEPH_LIB");
std::string CEPH_LIB(env ? env : "lib");
}
TestIoCtxImpl::~TestIoCtxImpl() {
- assert(m_pending_ops == 0);
+ ceph_assert(m_pending_ops == 0);
}
void TestObjectOperationImpl::get() {
auto& object_handlers = pool->file_handlers[locator];
auto it = object_handlers.find(object_handler);
- assert(it == object_handlers.end());
+ ceph_assert(it == object_handlers.end());
object_handlers.insert(object_handler);
return 0;
m_transaction_cond.Wait(m_lock);
}
auto result = m_transactions.insert(locator);
- assert(result.second);
+ ceph_assert(result.second);
}
void TestMemCluster::transaction_finish(const ObjectLocator& locator) {
Mutex::Locker locker(m_lock);
size_t count = m_transactions.erase(locator);
- assert(count == 1);
+ ceph_assert(count == 1);
m_transaction_cond.Signal();
}
TestCluster::ObjectLocator locator(get_namespace(), oid);
TestMemCluster::Files::iterator it = m_pool->files.find(locator);
- assert(it != m_pool->files.end());
+ ceph_assert(it != m_pool->files.end());
if (*it->second.rbegin() == file) {
TestMemCluster::ObjectHandlers object_handlers;
TestMemCluster::SharedFile TestMemIoCtxImpl::get_file(
const std::string &oid, bool write, const SnapContext &snapc) {
- assert(m_pool->file_lock.is_locked() || m_pool->file_lock.is_wlocked());
- assert(!write || m_pool->file_lock.is_wlocked());
+ ceph_assert(m_pool->file_lock.is_locked() || m_pool->file_lock.is_wlocked());
+ ceph_assert(!write || m_pool->file_lock.is_wlocked());
TestMemCluster::SharedFile file;
TestMemCluster::Files::iterator it = m_pool->files.find(
if (get_snap_read() == CEPH_NOSNAP) {
if (!file->exists) {
- assert(it->second.size() > 1);
+ ceph_assert(it->second.size() > 1);
return TestMemCluster::SharedFile();
}
return file;
TestWatchNotify::SharedWatcher TestWatchNotify::get_watcher(
int64_t pool_id, const std::string& nspace, const std::string& oid) {
- assert(m_lock.is_locked());
+ ceph_assert(m_lock.is_locked());
auto it = m_file_watchers.find({pool_id, nspace, oid});
if (it == m_file_watchers.end()) {
}
void TestWatchNotify::maybe_remove_watcher(SharedWatcher watcher) {
- assert(m_lock.is_locked());
+ ceph_assert(m_lock.is_locked());
// TODO
if (watcher->watch_handles.empty() && watcher->notify_handles.empty()) {
const bufferlist &bl) {
CephContext *cct = rados_client->cct();
- assert(m_lock.is_locked());
+ ceph_assert(m_lock.is_locked());
SharedWatcher watcher = get_watcher(pool_id, nspace, oid);
if (!watcher) {
ldout(cct, 1) << "oid=" << oid << ": not found" << dendl;
ldout(cct, 20) << "oid=" << oid << ", notify_id=" << notify_id << dendl;
- assert(m_lock.is_locked());
+ ceph_assert(m_lock.is_locked());
SharedWatcher watcher = get_watcher(pool_id, nspace, oid);
- assert(watcher);
+ ceph_assert(watcher);
NotifyHandles::iterator it = watcher->notify_handles.find(notify_id);
if (it == watcher->notify_handles.end()) {
rbd_internal
rbd_types
osdc
+ ceph-common
global
${UNITTEST_LIBS}
radostest)
$<TARGET_OBJECTS:libradostest_obj>
$<TARGET_OBJECTS:common_texttable_obj>)
target_link_libraries(ceph_test_librbd_api
+ ceph-common
librbd
librados
${UNITTEST_LIBS})
const std::string &image_id,
librados::snap_t snap_id, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
librbd::MockTestImageCtx *src_parent_image_ctx,
librbd::MockTestImageCtx *dst_image_ctx, const SnapMap &snap_map,
uint64_t object_number, bool flatten, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
Mutex::Locker locker(s_instance->lock);
s_instance->snap_map = &snap_map;
s_instance->object_contexts[object_number] = on_finish;
Context* on_finish = nullptr;
static CloseRequest* s_instance;
static CloseRequest* create(MockTestImageCtx *image_ctx, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static OpenRequest* s_instance;
static OpenRequest* create(MockTestImageCtx *image_ctx,
bool skip_open_parent, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static void aio_read(MockTestImageCtx *ictx, AioCompletion *c,
Extents &&image_extents, ReadResult &&read_result,
int op_flags, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_read(c, image_extents);
}
MOCK_METHOD2(aio_read, void(AioCompletion *, const Extents&));
Return(true)));
} else {
expect.WillOnce(DoAll(WithArg<6>(Invoke([&mock_image_ctx, snap_id, state](Context *ctx) {
- assert(mock_image_ctx.image_ctx->snap_lock.is_locked());
- assert(mock_image_ctx.image_ctx->object_map_lock.is_wlocked());
+ ceph_assert(mock_image_ctx.image_ctx->snap_lock.is_locked());
+ ceph_assert(mock_image_ctx.image_ctx->object_map_lock.is_wlocked());
mock_image_ctx.image_ctx->object_map->aio_update<Context>(
snap_id, 0, 1, state, boost::none, {}, ctx);
})),
uint64_t size,
const librbd::ParentSpec &parent_spec,
uint64_t parent_overlap, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const librbd::ParentSpec &parent_spec,
uint64_t parent_overlap,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
uint64_t size,
const librbd::ParentSpec &parent_spec,
uint64_t parent_overlap, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
bool acquire_lock_refresh,
bool skip_open_parent, Context *on_finish) {
EXPECT_TRUE(acquire_lock_refresh);
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
rbd_image_t image;
int ret;
- assert(!ctx->name && !ctx->image &&
+ ceph_assert(!ctx->name && !ctx->image &&
!ctx->krbd_name && ctx->krbd_fd < 0);
ret = rbd_open(ioctx, name, &image, NULL);
{
int ret;
- assert(ctx->name && ctx->image);
+ ceph_assert(ctx->name && ctx->image);
ret = rbd_close(ctx->image);
if (ret < 0) {
};
ret = rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_FEATURES,
features);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_ORDER,
*order);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_UNIT,
stripe_unit);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_COUNT,
stripe_count);
- assert(ret == 0);
+ ceph_assert(ret == 0);
ret = rbd_snap_set(ctx->image, src_snapname);
if (ret < 0) {
{
int ret;
- assert(ctx->krbd_name && ctx->krbd_fd >= 0);
+ ceph_assert(ctx->krbd_name && ctx->krbd_fd >= 0);
if (close(ctx->krbd_fd) < 0) {
ret = -errno;
{
int ret;
- assert(size % truncbdy == 0);
+ ceph_assert(size % truncbdy == 0);
/*
* When krbd detects a size change, it calls revalidate_disk(),
{
int r;
- assert(ctx->krbd_name && ctx->krbd_fd >= 0);
+ ceph_assert(ctx->krbd_name && ctx->krbd_fd >= 0);
if (close(ctx->krbd_fd) < 0) {
r = -errno;
{
int r;
- assert(ctx->krbd_name && ctx->krbd_fd >= 0);
+ ceph_assert(ctx->krbd_name && ctx->krbd_fd >= 0);
if (close(ctx->krbd_fd) < 0) {
r = -errno;
{
int ret;
- assert(size % truncbdy == 0);
+ ceph_assert(size % truncbdy == 0);
ret = __ggate_flush(ctx, false);
if (ret < 0) {
clone_imagename(imagename, sizeof(imagename), num_clones);
clone_imagename(lastimagename, sizeof(lastimagename),
num_clones - 1);
- assert(strcmp(lastimagename, ctx.name) == 0);
+ ceph_assert(strcmp(lastimagename, ctx.name) == 0);
ret = ops->clone(&ctx, "snap", imagename, &order, stripe_unit,
stripe_count);
newsize = 0;
}
- assert(newsize != (uint64_t)file_size);
+ ceph_assert(newsize != (uint64_t)file_size);
prt("truncating image %s from 0x%llx (overlap 0x%llx) to 0x%llx\n",
ctx.name, file_size, overlap, newsize);
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
static MockTestImageCtx* create(const std::string &image_name,
const std::string &image_id,
librados::snap_t snap_id, IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
bool skip_mirror_enable,
ContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static RefreshRequest* create(MockTestImageCtx &image_ctx,
bool acquiring_lock, bool skip_open_parent,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
ProgressContext &prog_ctx,
ContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string &non_primary_global_image_id,
MockContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
const ParentInfo &parent_md,
const MigrationInfo &migration_info,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static bool is_refresh_required(MockRefreshImageCtx &mock_image_ctx,
const ParentInfo& parent_md,
const MigrationInfo &migration_info) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance->is_refresh_required();
}
static ImageDispatchSpec* create_flush_request(
librbd::MockRefreshImageCtx &image_ctx, AioCompletion *aio_comp,
FlushSource flush_source, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_comp = aio_comp;
return s_instance;
}
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
static DetachChildRequest *s_instance;
static DetachChildRequest *create(MockTestImageCtx &image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
cls::rbd::SnapshotNamespace sn,
std::string name,
uint64_t id, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static TrimRequest *create(MockTestImageCtx &image_ctx, Context *on_finish,
uint64_t original_size, uint64_t new_size,
ProgressContext &prog_ctx) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static RemoveRequest *create(IoCtx &ioctx, const std::string &imageid,
const std::string &client_id,
ContextWQ *op_work_queue, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static DisableRequest *create(MockTestImageCtx *image_ctx, bool force,
bool remove, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static ListWatchersRequest *create(MockTestImageCtx &image_ctx, int flags,
std::list<obj_watch_t> *watchers,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
librbd::MockTestImageCtx &image_ctx, AioCompletion *aio_comp,
Extents &&image_extents, bufferlist &&bl, int op_flags,
const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_comp = aio_comp;
return s_instance;
}
static ImageDispatchSpec* create_flush_request(
librbd::MockTestImageCtx &image_ctx, AioCompletion *aio_comp,
FlushSource flush_source, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_comp = aio_comp;
return s_instance;
}
Mutex *lock, ImageClientMeta *client_meta,
uint64_t *tag_tid, journal::TagData *tag_data,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
client_meta->tag_class = 456;
tag_data->mirror_uuid = Journal<>::ORPHAN_MIRROR_UUID;
*tag_tid = 567;
static void aio_write(MockReplayImageCtx *ictx, AioCompletion *c,
Extents &&image_extents, bufferlist &&bl,
int op_flags, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_write(c, image_extents, bl, op_flags);
}
static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c,
Extents&& image_extents, bool skip_partial_discard,
const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_discard(c, image_extents, skip_partial_discard);
}
MOCK_METHOD1(aio_flush, void(AioCompletion *c));
static void aio_flush(MockReplayImageCtx *ictx, AioCompletion *c,
FlushSource, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_flush(c);
}
static void aio_writesame(MockReplayImageCtx *ictx, AioCompletion *c,
Extents&& image_extents, bufferlist &&bl,
int op_flags, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_writesame(c, image_extents, bl, op_flags);
}
Extents &&image_extents, bufferlist &&cmp_bl,
bufferlist &&bl, uint64_t *mismatch_offset,
int op_flags, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_compare_and_write(c, image_extents, cmp_bl, bl,
mismatch_offset, op_flags);
}
uint64_t tag_class, TagData &tag_data,
const std::string &client_id,
ContextWQ *op_work_queue, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static RemoveRequest* create(IoCtx &ioctx, const std::string &image_id,
const std::string &client_id,
ContextWQ *op_work_queue, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
EXPECT_EQ(cct->_conf.get_val<int64_t>("rbd_blacklist_expire_seconds"),
(int)blacklist_expire_seconds);
EXPECT_FALSE(force_break_lock);
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static GetLockerRequest* create(librados::IoCtx& ioctx,
const std::string& oid, bool exclusive,
Locker *locker, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->locker = locker;
s_instance->on_finish = on_finish;
return s_instance;
static GetLockerRequest* create(librados::IoCtx& ioctx,
const std::string& oid, bool exclusive,
Locker *locker, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->locker = locker;
s_instance->on_finish = on_finish;
return s_instance;
static Journal *s_instance;
static void is_tag_owner(librbd::MockTestImageCtx *, bool *is_primary,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->is_tag_owner(is_primary, on_finish);
}
const std::string &image_id,
const std::string &global_image_id,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->notify_image_updated(mirror_image_state, image_id,
global_image_id, on_finish);
}
static PromoteRequest *s_instance;
static PromoteRequest *create(librbd::MockTestImageCtx *, bool force,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
MOCK_METHOD0(destroy, void());
struct MockJournal {
static MockJournal *s_instance;
static MockJournal *get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
static InvalidateRequest<I>* create(I &image_ctx, uint64_t snap_id,
bool force, Context *on_finish) {
- assert(!s_requests.empty());
+ ceph_assert(!s_requests.empty());
InvalidateRequest<I>* req = s_requests.front();
req->snap_id = snap_id;
req->force = force;
public:
static LockRequest *s_instance;
static LockRequest *create(MockObjectMapImageCtx &image_ctx, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
if (r < 0) {
expect.WillOnce(Return(r));
} else {
- assert(object_map);
+ ceph_assert(object_map);
object_map->set_crc_enabled(false);
bufferlist bl;
static SetFlagsRequest *create(MockOperationImageCtx *image_ctx, uint64_t flags,
uint64_t mask, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string &client_id,
MockContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static DisableRequest *create(MockOperationImageCtx *image_ctx, bool force,
bool remove, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
Context *on_finish = nullptr;
static RemoveRequest *create(MockOperationImageCtx *image_ctx, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static SetFlagsRequest *create(MockOperationImageCtx *image_ctx, uint64_t flags,
uint64_t mask, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string &client_id,
MockContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
Context *on_finish = nullptr;
static EnableRequest *create(MockOperationImageCtx *image_ctx, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
Context *on_finish = nullptr;
static CreateRequest *create(MockOperationImageCtx *image_ctx, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static ImageDispatchSpec* create_flush_request(
MockImageCtx &image_ctx, AioCompletion *aio_comp,
FlushSource flush_source, const ZTracer::Trace &parent_trace) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->aio_comp = aio_comp;
return s_instance;
}
static TrimRequest *create(MockImageCtx &image_ctx, Context *on_finish,
uint64_t original_size, uint64_t new_size,
ProgressContext &prog_ctx) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static DetachChildRequest *s_instance;
static DetachChildRequest *create(MockImageCtx &image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
uint64_t new_size, bool allow_shrink,
ProgressContext &prog_ctx, uint64_t journal_op_tid,
bool disable_journal) {
- assert(s_instance != nullptr);
- assert(journal_op_tid == 0);
- assert(disable_journal);
+ ceph_assert(s_instance != nullptr);
+ ceph_assert(journal_op_tid == 0);
+ ceph_assert(disable_journal);
s_instance->on_finish = on_finish;
return s_instance;
}
}
RWLock::RLocker owner_locker(ictx.owner_lock);
- assert(ictx.exclusive_lock != nullptr);
+ ceph_assert(ictx.exclusive_lock != nullptr);
return ictx.exclusive_lock->is_lock_owner() ? 0 : -EINVAL;
}
thread writer([&image1](){
librbd::image_info_t info;
int r = image1.stat(info, sizeof(info));
- assert(r == 0);
+ ceph_assert(r == 0);
bufferlist bl;
bl.append("foo");
for (unsigned i = 0; i < info.num_objs; ++i) {
r = image1.write((1 << info.order) * i, bl.length(), bl);
- assert(r == (int) bl.length());
+ ceph_assert(r == (int) bl.length());
}
});
writer.join();
rados_ioctx_destroy(ioctx);
}
-// poorman's assert()
+// poorman's ceph_assert()
namespace ceph {
void __ceph_assert_fail(const char *assertion, const char *file, int line,
const char *func) {
const ObjectNumber &object_number, const SnapSeqs &snap_seqs,
ProgressContext *prog_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static MetadataCopyRequest* create(librbd::MockTestImageCtx *src_image_ctx,
librbd::MockTestImageCtx *dst_image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
librados::snap_t snap_id_end, bool flatten,
ContextWQ *work_queue, SnapSeqs *snap_seqs,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static T* create(MockExclusiveLockImageCtx &image_ctx,
Context *on_lock_unlock, Context *on_finish) {
- assert(!s_requests.empty());
+ ceph_assert(!s_requests.empty());
T* req = s_requests.front();
req->on_lock_unlock = on_lock_unlock;
req->on_finish = on_finish;
struct MockReplay {
static MockReplay *s_instance;
static MockReplay &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
struct MockRemove {
static MockRemove *s_instance;
static MockRemove &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
struct MockCreate {
static MockCreate *s_instance;
static MockCreate &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
Mutex *lock, journal::ImageClientMeta *client_meta,
uint64_t *tag_tid, journal::TagData *tag_data,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->tag_data = tag_data;
s_instance->on_finish = on_finish;
return s_instance;
static ObjectDispatch* create(MockJournalImageCtx* image_ctx,
Journal<MockJournalImageCtx>* journal) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
}
~TestMockJournal() override {
- assert(m_commit_contexts.empty());
+ ceph_assert(m_commit_contexts.empty());
}
Mutex m_lock;
static T* create(librados::IoCtx& ioctx, MockImageWatcher *watcher,
ContextWQ *work_queue, const std::string& oid,
const std::string& cookie, Context *on_finish) {
- assert(!s_requests.empty());
+ ceph_assert(!s_requests.empty());
T* req = s_requests.front();
req->on_finish = on_finish;
s_requests.pop_front();
static GetLockerRequest* create(librados::IoCtx& ioctx,
const std::string& oid, bool exclusive,
Locker *locker, Context *on_finish) {
- assert(0 == "unexpected call");
+ ceph_assert(0 == "unexpected call");
}
void send() {
- assert(0 == "unexpected call");
+ ceph_assert(0 == "unexpected call");
}
};
bool exclusive, bool blacklist_locker,
uint32_t blacklist_expire_seconds,
bool force_break_lock, Context *on_finish) {
- assert(0 == "unexpected call");
+ ceph_assert(0 == "unexpected call");
}
void send() {
- assert(0 == "unexpected call");
+ ceph_assert(0 == "unexpected call");
}
};
static RefreshRequest *create(MockTestImageCtx &image_ctx,
ceph::BitVector<2u> *object_map,
uint64_t snap_id, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
s_instance->object_map = object_map;
return s_instance;
static UnlockRequest *s_instance;
static UnlockRequest *create(MockTestImageCtx &image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const boost::optional<uint8_t> ¤t_state,
const ZTracer::Trace &parent_trace,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
s_instance->construct(snap_id, start_object_no, end_object_no, new_state,
current_state);
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
// wait for recovery unwatch/watch
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
// wait for recovery unwatch/watch
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
// wait for recovery unwatch/watch
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
ASSERT_EQ(0, unregister_ctx.wait());
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
ASSERT_EQ(0, unregister_ctx.wait());
mock_image_watcher.register_watch(®ister_ctx);
ASSERT_EQ(0, register_ctx.wait());
- assert(m_watch_ctx != nullptr);
+ ceph_assert(m_watch_ctx != nullptr);
m_watch_ctx->handle_error(0, -ESHUTDOWN);
ASSERT_EQ(0, unregister_ctx.wait());
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->construct(image_name, image_id);
return s_instance;
}
struct xio_reg_mem *mp = m->get_mp();
int e = xio_mempool_alloc(xio_msgr_mpool, size, mp);
- assert(e == 0);
+ ceph_assert(e == 0);
p = mp->addr;
m->set_rdma_hook(xio_hook_func);
}
}
const string& get(unsigned r, unsigned c) const {
- assert(r < row.size());
- assert(c < row[r].size());
+ ceph_assert(r < row.size());
+ ceph_assert(c < row[r].size());
return row[r][c];
}
};
std::string public_msgr_type = cct->_conf->ms_public_type.empty() ? cct->_conf.get_val<std::string>("ms_type") : cct->_conf->ms_public_type;
msg = Messenger::create(cct, public_msgr_type, entity_name_t::CLIENT(-1),
"test-mon-msg", 0, 0);
- assert(msg != NULL);
+ ceph_assert(msg != NULL);
msg->set_default_policy(Messenger::Policy::lossy_client(0));
dout(0) << __func__ << " starting messenger at "
<< msg->get_myaddr() << dendl;
int init_monc() {
dout(1) << __func__ << dendl;
- assert(msg != NULL);
+ ceph_assert(msg != NULL);
int err = monc.build_initial_monmap();
if (err < 0) {
derr << __func__ << " error building monmap: "
}
messenger.reset(Messenger::create_client_messenger(cct, "stubclient"));
- assert(messenger.get() != NULL);
+ ceph_assert(messenger.get() != NULL);
messenger->set_default_policy(
Messenger::Policy::lossy_client(CEPH_FEATURE_OSDREPLYMUX));
<< messenger->get_myaddr() << dendl;
objecter.reset(new Objecter(cct, messenger.get(), &monc, NULL, 0, 0));
- assert(objecter.get() != NULL);
+ ceph_assert(objecter.get() != NULL);
objecter->set_balanced_budget();
monc.set_messenger(messenger.get());
monc.shutdown();
return err;
}
- assert(!monc.get_fsid().is_zero());
+ ceph_assert(!monc.get_fsid().is_zero());
monc.wait_auth_rotating(30.0);
if (pgs.count(pgid) == 0) {
derr << __func__
<< " pgid " << pgid << " not on our map" << dendl;
- assert(0 == "pgid not on our map");
+ ceph_assert(0 == "pgid not on our map");
}
pg_stat_t &s = pgs[pgid];
mstats->pg_stat[pgid] = s;
void modify_pg(pg_t pgid) {
dout(10) << __func__ << " pg " << pgid << dendl;
- assert(pgs.count(pgid) > 0);
+ ceph_assert(pgs.count(pgid) > 0);
pg_stat_t &s = pgs[pgid];
utime_t now = ceph_clock_now();
++it;
++pgs_at;
}
- assert(it != pgs.end());
+ ceph_assert(it != pgs.end());
dout(20) << __func__
<< " pg at pos " << at << ": " << it->first << dendl;
modify_pg(it->first);
}
void handle_pg_create(MOSDPGCreate *m) {
- assert(m != NULL);
+ ceph_assert(m != NULL);
if (m->epoch < osdmap.get_epoch()) {
std::cout << __func__ << " epoch " << m->epoch << " < "
<< osdmap.get_epoch() << "; dropping" << std::endl;
<< dendl;
dout(0) << monc.get_monmap() << dendl;
}
- assert(m->fsid == monc.get_fsid());
+ ceph_assert(m->fsid == monc.get_fsid());
epoch_t first = m->get_first();
epoch_t last = m->get_last();
derr << "osd." << whoami << "::" << __func__
<< "** ERROR: applying incremental: "
<< cpp_strerror(err) << dendl;
- assert(0 == "error applying incremental");
+ ceph_assert(0 == "error applying incremental");
}
}
dout(30) << __func__ << "\nosdmap:\n";
}
void usage() {
- assert(our_name != NULL);
+ ceph_assert(our_name != NULL);
std::cout << "usage: " << our_name
<< " <--stub-id ID> [--stub-id ID...]"
}
void _process_finish(Message *m) override { }
void _clear() override {
- assert(messages.empty());
+ ceph_assert(messages.empty());
}
} op_wq;
sa.sin_port = htons(port);
char addr[] = "127.0.0.1";
int r = inet_pton(AF_INET, addr, &sa.sin_addr);
- assert(r == 1);
+ ceph_assert(r == 1);
int connect_sd = ::socket(AF_INET, SOCK_STREAM, 0);
if (connect_sd >= 0) {
r = connect(connect_sd, (struct sockaddr*)&sa, sizeof(sa));
- assert(r == 0);
+ ceph_assert(r == 0);
int t = 0;
do {
lderr(g_ceph_context) << __func__ << " conn: " << m->get_connection() << " session " << s << " count: " << s->count << dendl;
if (is_server) {
if (loopback)
- assert(m->get_source().is_osd());
+ ceph_assert(m->get_source().is_osd());
else
reply_message(m);
} else if (loopback) {
- assert(m->get_source().is_client());
+ ceph_assert(m->get_source().is_client());
}
m->put();
Mutex::Locker l(lock);
msgr->bind(bind_addr);
msgr->add_dispatcher_head(&dispatcher);
- assert(msgr);
+ ceph_assert(msgr);
msgr->set_default_policy(srv_policy);
available_servers.insert(msgr);
msgr->start();
}
msgr->add_dispatcher_head(&dispatcher);
- assert(msgr);
+ ceph_assert(msgr);
msgr->set_default_policy(cli_policy);
available_clients.insert(msgr);
msgr->start();
usleep(500);
lock.Lock();
}
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
boost::uniform_int<> choose(0, available_connections.size() - 1);
int index = choose(rng);
map<ConnectionRef, pair<Messenger*, Messenger*> >::iterator i = available_connections.begin();
if (i++ % 50 == 0)
print_internal_state(true);
if (timeout_us < 0)
- assert(0 == " loop time exceed 5 mins, it looks we stuck into some problems!");
+ ceph_assert(0 == " loop time exceed 5 mins, it looks we stuck into some problems!");
}
for (set<Messenger*>::iterator it = available_servers.begin();
it != available_servers.end(); ++it) {
uint64_t handle;
WatchNotifyTestCtx ctx;
ret = ioctx.watch(obj_name, 0, &handle, &ctx);
- assert(!ret);
+ ceph_assert(!ret);
bufferlist bl2;
ret = ioctx.notify(obj_name, 0, bl2);
- assert(!ret);
+ ceph_assert(!ret);
TestAlarm alarm;
sem_wait(&sem);
ioctx.unwatch(obj_name, handle);
AllocTracker(uint64_t capacity, uint64_t alloc_unit)
: u1(0, capacity)
{
- assert(alloc_unit >= 0x100);
- assert(capacity <= (uint64_t(1) << 48)); // we use 5 octets (bytes 1 - 5) to store
+ ceph_assert(alloc_unit >= 0x100);
+ ceph_assert(capacity <= (uint64_t(1) << 48)); // we use 5 octets (bytes 1 - 5) to store
// offset to save the required space.
// This supports capacity up to 281 TB
bool push(uint64_t offs, uint32_t len)
{
- assert((len & 0xff) == 0);
- assert((offs & 0xff) == 0);
- assert((offs & 0xffff000000000000) == 0);
+ ceph_assert((len & 0xff) == 0);
+ ceph_assert((offs & 0xff) == 0);
+ ceph_assert((offs & 0xffff000000000000) == 0);
if (head + 1 == tail)
return false;
default:
cout << "bad op " << op << std::endl;
- assert(0 == "bad op");
+ ceph_assert(0 == "bad op");
}
return ok;
}
for (uint64_t i = offset;
i < offset + len;
++i, ++iter) {
- assert(iter.valid());
+ ceph_assert(iter.valid());
to_write.append(*iter);
}
out->t->write(coll_t(obj.first),
OutTransaction *out) {
Mutex::Locker l(lock);
std::cerr << "CloningRange " << from << " to " << to << std::endl;
- assert(from.first == to.first);
+ ceph_assert(from.first == to.first);
ObjectContents from_contents = get_current_content(from);
ObjectContents to_contents = get_current_content(to);
if (!from_contents.exists()) {
OutTransaction *out) {
Mutex::Locker l(lock);
std::cerr << "Cloning " << from << " to " << to << std::endl;
- assert(from.first == to.first);
+ ceph_assert(from.first == to.first);
if (from.second == to.second) {
return;
}
auto bp = bl.cbegin();
pair<uint64_t, bufferlist> val;
decode(val, bp);
- assert(seq_to_key(val.first) == iter->key());
+ ceph_assert(seq_to_key(val.first) == iter->key());
bp = val.second.begin();
return ObjectContents(bp);
}
auto bp = got.begin()->second.cbegin();
decode(val, bp);
bp = val.second.begin();
- assert(val.first == version);
+ ceph_assert(val.first == version);
return ObjectContents(bp);
}
uint64_t seq) {
Mutex::Locker l(lock);
ObjStatus status = get_obj_status(obj, db);
- assert(status.last_committed < seq);
+ ceph_assert(status.last_committed < seq);
status.last_committed = seq;
KeyValueDB::Transaction t = db->get_transaction();
clear_obsolete(obj, status, db, t);
Mutex::Locker l(lock);
std::cerr << "Applied " << obj << " version " << seq << std::endl;
ObjStatus status = get_obj_status(obj, db);
- assert(status.last_applied < seq);
+ ceph_assert(status.last_applied < seq);
status.set_last_applied(seq, restart_seq);
KeyValueDB::Transaction t = db->get_transaction();
clear_obsolete(obj, status, db, t);
if (m_collections.empty())
return NULL;
- assert((size_t) pos < m_collections_ids.size());
+ ceph_assert((size_t) pos < m_collections_ids.size());
coll_t cid = m_collections_ids[pos];
coll_entry_t *entry = m_collections[cid];
while (len > 0) {
size_t next_len = strlen(buf);
ret.push_back(string(buf, buf + next_len));
- assert(len >= (int)(next_len + 1));
+ ceph_assert(len >= (int)(next_len + 1));
buf += (next_len + 1);
len -= (next_len + 1);
}
const char *file = FILENAME;
::unlink(file);
int fd = ::open(file, O_CREAT|O_RDWR|O_TRUNC, 0700);
- assert(fd >= 0);
+ ceph_assert(fd >= 0);
std::size_t existing_xattrs = get_xattrs(fd).size();
char buf[800];
const char *file = FILENAME;
::unlink(file);
int fd = ::open(file, O_CREAT|O_RDWR|O_TRUNC, 0700);
- assert(fd >= 0);
+ ceph_assert(fd >= 0);
std::size_t existing_xattrs = get_xattrs(fd).size();
::close(fd);
bufferlist r2;
r = state->store->read(state->ch, hoid, 0, state->contents[hoid].data.length(), r2);
- assert(bl_eq(state->contents[hoid].data, r2));
+ ceph_assert(bl_eq(state->contents[hoid].data, r2));
state->cond.Signal();
}
};
r = state->store->read(
state->ch, noid, 0,
state->contents[noid].data.length(), r2);
- assert(bl_eq(state->contents[noid].data, r2));
+ ceph_assert(bl_eq(state->contents[noid].data, r2));
state->cond.Signal();
}
};
--(state->in_flight);
bufferlist r2;
r = state->store->read(state->ch, noid, 0, state->contents[noid].data.length(), r2);
- assert(bl_eq(state->contents[noid].data, r2));
+ ceph_assert(bl_eq(state->contents[noid].data, r2));
state->cond.Signal();
}
};
vector<ghobject_t> objects;
int r = store->collection_list(ch, ghobject_t(), ghobject_t::get_max(),
10, &objects, 0);
- assert(r >= 0);
+ ceph_assert(r >= 0);
if (objects.empty())
break;
ObjectStore::Transaction t;
}
} else {
bufferlist value;
- assert(dstdata.length() > dstoff);
+ ceph_assert(dstdata.length() > dstoff);
dstdata.copy(0, dstoff, value);
value.append(bl);
if (value.length() < dstdata.length())
}
} else {
bufferlist value;
- assert(data.length() > offset);
+ ceph_assert(data.length() > offset);
data.copy(0, offset, value);
value.append(bl);
if (value.length() < data.length())
size_t max_len = expected.length() - offset;
if (len > max_len)
len = max_len;
- assert(len == result.length());
+ ceph_assert(len == result.length());
ASSERT_EQ(len, result.length());
expected.copy(offset, len, bl);
ASSERT_EQ(r, (int)len);
ch.reset();
store->umount();
int r = store->fsck(deep);
- assert(r == 0 || r == -EOPNOTSUPP);
+ ceph_assert(r == 0 || r == -EOPNOTSUPP);
store->mount();
ch = store->open_collection(cid);
}
cerr << "- " << *p << std::endl;
//cerr << " objects_set: " << objects_set << std::endl;
//cerr << " available_set: " << available_objects << std::endl;
- assert(0 == "badness");
+ ceph_assert(0 == "badness");
}
ASSERT_EQ(objects_set.size(), available_objects.size());
struct stat buf;
int r = store->stat(ch, hoid, &buf);
ASSERT_EQ(0, r);
- assert((uint64_t)buf.st_size == expected);
+ ceph_assert((uint64_t)buf.st_size == expected);
ASSERT_TRUE((uint64_t)buf.st_size == expected);
{
Mutex::Locker locker(lock);
void StoreTestFixture::SetVal(ConfigProxy& _conf, const char* key, const char* val)
{
- assert(!conf || conf == &_conf);
+ ceph_assert(!conf || conf == &_conf);
conf = &_conf;
std::string skey(key);
std::string prev_val;
void StoreTestFixture::PopSettings(size_t pos)
{
if (conf) {
- assert(pos == 0 || pos <= saved_settings.size()); // for sanity
+ ceph_assert(pos == 0 || pos <= saved_settings.size()); // for sanity
while(pos < saved_settings.size())
{
auto& e = saved_settings.top();
string fn = "ceph_test_bluefs.tmp.block." + stringify(getpid())
+ "." + stringify(++n);
int fd = ::open(fn.c_str(), O_CREAT|O_RDWR|O_TRUNC, 0644);
- assert(fd >= 0);
+ ceph_assert(fd >= 0);
int r = ::ftruncate(fd, size);
- assert(r >= 0);
+ ceph_assert(r >= 0);
::close(fd);
return fn;
}
if (string(args[0]) == string("new")) start_new = true;
KeyValueDB *_db = KeyValueDB::create(g_ceph_context, "leveldb", db_path);
- assert(!_db->create_and_open(std::cerr));
+ ceph_assert(!_db->create_and_open(std::cerr));
boost::scoped_ptr<KeyValueDB> db(_db);
boost::scoped_ptr<ObjectStore> store(new FileStore(cct.get(), store_path,
store_dev));
if (start_new) {
std::cerr << "mkfs" << std::endl;
- assert(!store->mkfs());
+ ceph_assert(!store->mkfs());
ObjectStore::Transaction t;
- assert(!store->mount());
+ ceph_assert(!store->mount());
ch = store->create_new_collection(coll);
t.create_collection(coll, 0);
store->queue_transaction(ch, std::move(t));
} else {
- assert(!store->mount());
+ ceph_assert(!store->mount());
ch = store->open_collection(coll);
}
#define dout_prefix *_dout << "test_idempotent_sequence "
void usage(const char *name, std::string command = "") {
- assert(name != NULL);
+ ceph_assert(name != NULL);
std::string more = "cmd <args...>";
std::string diff = "diff <filestoreA> <journalA> <filestoreB> <journalB>";
dout(0) << "Writing " << cfg.size
<< " in blocks of " << cfg.block_size << dendl;
- assert(starting_offset < cfg.size);
- assert(starting_offset % cfg.block_size == 0);
+ ceph_assert(starting_offset < cfg.size);
+ ceph_assert(starting_offset % cfg.block_size == 0);
ObjectStore::CollectionHandle ch = os->open_collection(cid);
- assert(ch);
+ ceph_assert(ch);
for (int i = 0; i < cfg.repeats; ++i) {
uint64_t offset = starting_offset;
ObjectStore::Transaction t;
t.touch(cid, oids[i]);
int r = os->queue_transaction(ch, std::move(t));
- assert(r == 0);
+ ceph_assert(r == 0);
}
} else {
oids.emplace_back(hobject_t(sobject_t("osbench", CEPH_NOSNAP)));
ObjectStore::Transaction t;
t.touch(cid, oids.back());
int r = os->queue_transaction(ch, std::move(t));
- assert(r == 0);
+ ceph_assert(r == 0);
}
// run the worker threads
Mutex::Locker l(thread_is_free_lock);
for (int i = 0; i < objects; i++) {
- assert(busythreads_count <= threads);
+ ceph_assert(busythreads_count <= threads);
//wait for a writer to be free
if (busythreads_count == threads) {
int err = thread_is_free.Wait(thread_is_free_lock);
- assert(busythreads_count < threads);
+ ceph_assert(busythreads_count < threads);
if (err < 0) {
return err;
}
int main(int argc, char **argv)
{
// test basic function scope behavior
- assert(func_scope_val == 0);
+ ceph_assert(func_scope_val == 0);
func_scope();
- assert(func_scope_val == 8);
+ ceph_assert(func_scope_val == 8);
// shared mem for exit tests
shared_val = (int*)mmap(NULL, sizeof(int),
PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
- assert(shared_val != MAP_FAILED);
+ ceph_assert(shared_val != MAP_FAILED);
// test normal exit returning from main
*shared_val = 0;
int pid = fork();
- assert(pid >= 0);
+ ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
- assert(ret == pid); // should be our child
- assert(status == 0);
- assert(*shared_val == MAIN_SCOPE_VAL);
+ ceph_assert(ret == pid); // should be our child
+ ceph_assert(status == 0);
+ ceph_assert(*shared_val == MAIN_SCOPE_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits by returning from main. The parent checks the value after the
// child exits via the memory map.
- assert(*shared_val == 0);
+ ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = MAIN_SCOPE_VAL;
main_scope_mgr.add_callback(main_scope_cb, new_val);
// test exit via exit()
*shared_val = 0;
pid = fork();
- assert(pid >= 0);
+ ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
- assert(ret == pid); // should be our child
- assert(WEXITSTATUS(status) == 3);
- assert(*shared_val == EXIT_FUNC_VAL);
+ ceph_assert(ret == pid); // should be our child
+ ceph_assert(WEXITSTATUS(status) == 3);
+ ceph_assert(*shared_val == EXIT_FUNC_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits via exit().
- assert(*shared_val == 0);
+ ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = EXIT_FUNC_VAL;
exit_func_mgr.add_callback(exit_func_cb, new_val);
EXPECT_EQ(0, exists);
std::string pathname_1("PATH_1/" + mangled_name_1);
auto retvalue = ::creat(pathname_1.c_str(), 0600);
- assert(retvalue > 2);
+ ceph_assert(retvalue > 2);
EXPECT_EQ(0, ::close(retvalue));
EXPECT_EQ(0, created(hoid, pathname_1.c_str()));
mangled_name.clear();
exists = 666;
auto retvalue = ::creat(pathname.c_str(), 0600);
- assert(retvalue > 2);
+ ceph_assert(retvalue > 2);
EXPECT_EQ(0, ::close(retvalue));
EXPECT_EQ(0, created(hoid, pathname.c_str()));
EXPECT_EQ(0, get_mangled_name(path, hoid, &mangled_name, &exists));
uint64_t segment_length = round_up(
rand() % (max_append_size - min_append_size),
alignment) + min_append_size;
- assert(segment_length >= min_append_size);
+ ceph_assert(segment_length >= min_append_size);
if (segment_length + pos > limit) {
segment_length = limit - pos;
}
if (alignment)
- assert(segment_length % alignment == 0);
+ ceph_assert(segment_length % alignment == 0);
out.insert(std::pair<uint64_t, uint64_t>(pos, segment_length));
pos += segment_length;
}
bool include = false;
while (pos < limit) {
uint64_t segment_length = (rand() % (max_stride_size - min_stride_size)) + min_stride_size;
- assert(segment_length < max_stride_size);
- assert(segment_length >= min_stride_size);
+ ceph_assert(segment_length < max_stride_size);
+ ceph_assert(segment_length >= min_stride_size);
if (segment_length + pos > limit) {
segment_length = limit - pos;
}
void ObjectDesc::iterator::adjust_stack() {
while (!stack.empty() && pos >= stack.front().second.next) {
- assert(pos == stack.front().second.next);
+ ceph_assert(pos == stack.front().second.next);
size = stack.front().second.size;
current = stack.front().first;
stack.pop_front();
}
}
- assert(off <= to_check.length());
+ ceph_assert(off <= to_check.length());
pos = extiter.first;
objiter.seek(pos);
for (iterator i = get_iterator(in); !i.end(); ++i) {
bl.append(*i);
}
- assert(bl.length() < big_max_len);
+ ceph_assert(bl.length() < big_max_len);
return bl;
}
};
}
uint64_t next(uint64_t pos) {
- assert(!covers(pos));
+ ceph_assert(!covers(pos));
return ranges.starts_after(pos) ? ranges.start_after(pos) : size;
}
uint64_t valid_till(uint64_t pos) {
- assert(covers(pos));
+ ceph_assert(covers(pos));
return ranges.contains(pos) ?
ranges.end_after(pos) :
std::numeric_limits<uint64_t>::max();
void adjust_stack();
iterator &operator++() {
- assert(cur_valid_till >= pos);
+ ceph_assert(cur_valid_till >= pos);
++pos;
if (pos >= cur_valid_till) {
adjust_stack();
ceph_abort();
}
while (pos < _pos) {
- assert(cur_valid_till >= pos);
+ ceph_assert(cur_valid_till >= pos);
uint64_t next = std::min(_pos - pos, cur_valid_till - pos);
pos += next;
if (pos >= cur_valid_till) {
- assert(pos == cur_valid_till);
+ ceph_assert(pos == cur_valid_till);
adjust_stack();
}
}
- assert(pos == _pos);
+ ceph_assert(pos == _pos);
}
bufferlist gen_bl_advance(uint64_t s) {
bufferlist ret;
while (s > 0) {
- assert(cur_valid_till >= pos);
+ ceph_assert(cur_valid_till >= pos);
uint64_t next = std::min(s, cur_valid_till - pos);
if (current != layers.end() && pos < size) {
ret.append(current->iter.gen_bl_advance(next));
}
pos += next;
- assert(next <= s);
+ ceph_assert(next <= s);
s -= next;
if (pos >= cur_valid_till) {
- assert(cur_valid_till == pos);
+ ceph_assert(cur_valid_till == pos);
adjust_stack();
}
}
bool check_bl_advance(bufferlist &bl, uint64_t *error_at = nullptr) {
uint64_t off = 0;
while (off < bl.length()) {
- assert(cur_valid_till >= pos);
+ ceph_assert(cur_valid_till >= pos);
uint64_t next = std::min(bl.length() - off, cur_valid_till - pos);
bufferlist to_check;
pos += next;
off += next;
- assert(off <= bl.length());
+ ceph_assert(off <= bl.length());
if (pos >= cur_valid_till) {
- assert(cur_valid_till == pos);
+ ceph_assert(cur_valid_till == pos);
adjust_stack();
}
}
- assert(off == bl.length());
+ ceph_assert(off == bl.length());
return true;
}
};
stringstream hostpid;
hostpid << hostname_cstr << getpid() << "-";
prefix = hostpid.str();
- assert(!initialized);
+ ceph_assert(!initialized);
initialized = true;
return 0;
}
void loop(TestOpGenerator *gen)
{
- assert(initialized);
+ ceph_assert(initialized);
list<TestOp*> inflight;
state_lock.Lock();
}
TestWatchContext *watch(const string &oid) {
- assert(!watches.count(oid));
+ ceph_assert(!watches.count(oid));
return (watches[oid] = new TestWatchContext);
}
void unwatch(const string &oid) {
- assert(watches.count(oid));
+ ceph_assert(watches.count(oid));
delete watches[oid];
watches.erase(oid);
}
void remove_object(const string &oid)
{
- assert(!get_watch_context(oid));
+ ceph_assert(!get_watch_context(oid));
ObjectDesc new_obj;
pool_obj_cont[current_snap].erase(oid);
pool_obj_cont[current_snap].insert(pair<string,ObjectDesc>(oid, new_obj));
void remove_snap(int snap)
{
map<int, map<string,ObjectDesc> >::iterator next_iter = pool_obj_cont.find(snap);
- assert(next_iter != pool_obj_cont.end());
+ ceph_assert(next_iter != pool_obj_cont.end());
map<int, map<string,ObjectDesc> >::iterator current_iter = next_iter++;
- assert(current_iter != pool_obj_cont.end());
+ ceph_assert(current_iter != pool_obj_cont.end());
map<string,ObjectDesc> ¤t = current_iter->second;
map<string,ObjectDesc> &next = next_iter->second;
for (map<string,ObjectDesc>::iterator i = current.begin();
void roll_back(const string &oid, int snap)
{
- assert(!get_watch_context(oid));
+ ceph_assert(!get_watch_context(oid));
ObjectDesc contents;
find_object(oid, &contents, snap);
contents.dirty = true;
0;
bool requires;
int r = context->io_ctx.pool_requires_alignment2(&requires);
- assert(r == 0);
+ ceph_assert(r == 0);
uint64_t alignment = 0;
if (requires) {
r = context->io_ctx.pool_required_alignment2(&alignment);
- assert(r == 0);
- assert(alignment != 0);
+ ceph_assert(r == 0);
+ ceph_assert(alignment != 0);
}
cont_gen = new AppendGenerator(
prev_length,
++i, ++tid) {
gen_pos.seek(i->first);
bufferlist to_write = gen_pos.gen_bl_advance(i->second);
- assert(to_write.length() == i->second);
- assert(to_write.length() > 0);
+ ceph_assert(to_write.length() == i->second);
+ ceph_assert(to_write.length() > 0);
std::cout << num << ": writing " << context->prefix+oid
<< " from " << i->first
<< " to " << i->first + i->second << " tid " << tid << std::endl;
void _finish(CallbackInfo *info) override
{
- assert(info);
+ ceph_assert(info);
context->state_lock.Lock();
uint64_t tid = info->id;
}
last_acked_tid = tid;
- assert(!done);
+ ceph_assert(!done);
waiting_on--;
if (waiting_on == 0) {
uint64_t version = 0;
for (set<librados::AioCompletion *>::iterator i = waiting.begin();
i != waiting.end();
) {
- assert((*i)->is_complete());
+ ceph_assert((*i)->is_complete());
if (int err = (*i)->get_return_value()) {
cerr << "Error: oid " << oid << " write returned error code "
<< err << std::endl;
cerr << "Error: racing read on " << oid << " returned version "
<< rcompletion->get_version64() << " rather than version "
<< version << std::endl;
- assert(0 == "racing read got wrong version");
+ ceph_assert(0 == "racing read got wrong version");
}
{
ObjectDesc old_value;
- assert(context->find_object(oid, &old_value, -1));
+ ceph_assert(context->find_object(oid, &old_value, -1));
if (old_value.deleted())
std::cout << num << ": left oid " << oid << " deleted" << std::endl;
else
++i, ++tid) {
gen_pos.seek(i->first);
bufferlist to_write = gen_pos.gen_bl_advance(i->second);
- assert(to_write.length() == i->second);
- assert(to_write.length() > 0);
+ ceph_assert(to_write.length() == i->second);
+ ceph_assert(to_write.length() > 0);
std::cout << num << ": writing " << context->prefix+oid
<< " from " << i->first
<< " to " << i->first + i->second << " tid " << tid << std::endl;
void _finish(CallbackInfo *info) override
{
- assert(info);
+ ceph_assert(info);
context->state_lock.Lock();
uint64_t tid = info->id;
}
last_acked_tid = tid;
- assert(!done);
+ ceph_assert(!done);
waiting_on--;
if (waiting_on == 0) {
uint64_t version = 0;
for (set<librados::AioCompletion *>::iterator i = waiting.begin();
i != waiting.end();
) {
- assert((*i)->is_complete());
+ ceph_assert((*i)->is_complete());
if (int err = (*i)->get_return_value()) {
cerr << "Error: oid " << oid << " writesame returned error code "
<< err << std::endl;
cerr << "Error: racing read on " << oid << " returned version "
<< rcompletion->get_version64() << " rather than version "
<< version << std::endl;
- assert(0 == "racing read got wrong version");
+ ceph_assert(0 == "racing read got wrong version");
}
{
ObjectDesc old_value;
- assert(context->find_object(oid, &old_value, -1));
+ ceph_assert(context->find_object(oid, &old_value, -1));
if (old_value.deleted())
std::cout << num << ": left oid " << oid << " deleted" << std::endl;
else
context->oid_in_use.insert(oid);
context->oid_not_in_use.erase(oid);
- assert(context->find_object(oid, &old_value, snap));
+ ceph_assert(context->find_object(oid, &old_value, snap));
if (old_value.deleted())
std::cout << num << ": expect deleted" << std::endl;
else
TestWatchContext *ctx = context->get_watch_context(oid);
context->state_lock.Unlock();
if (ctx) {
- assert(old_value.exists);
+ ceph_assert(old_value.exists);
TestAlarm alarm;
std::cerr << num << ": about to start" << std::endl;
ctx->start();
if (balance_reads)
flags |= librados::OPERATION_BALANCE_READS;
- assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[0], &op,
+ ceph_assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[0], &op,
flags, NULL));
waiting_on++;
for (uint32_t i = 1; i < 3; ++i) {
librados::ObjectReadOperation pipeline_op;
_do_read(pipeline_op, i);
- assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[i], &pipeline_op, 0));
+ ceph_assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[i], &pipeline_op, 0));
waiting_on++;
}
void _finish(CallbackInfo *info) override
{
Mutex::Locker l(context->state_lock);
- assert(!done);
- assert(waiting_on > 0);
+ ceph_assert(!done);
+ ceph_assert(waiting_on > 0);
if (--waiting_on) {
return;
}
int retval = completions[0]->get_return_value();
for (vector<librados::AioCompletion *>::iterator it = completions.begin();
it != completions.end(); ++it) {
- assert((*it)->is_complete());
+ ceph_assert((*it)->is_complete());
uint64_t version = (*it)->get_version64();
int err = (*it)->get_return_value();
if (err != retval) {
} else if (version != old_value.version) {
cerr << num << ": oid " << oid << " version is " << version
<< " and expected " << old_value.version << std::endl;
- assert(version == old_value.version);
+ ceph_assert(version == old_value.version);
}
}
if (!retval) {
cerr << num << ": Error: did not find header attr, has_contents: "
<< old_value.has_contents()
<< std::endl;
- assert(!old_value.has_contents());
+ ceph_assert(!old_value.has_contents());
}
} else {
headerbl = iter->second;
}
if (old_value.deleted()) {
std::cout << num << ": expect deleted" << std::endl;
- assert(0 == "expected deleted");
+ ceph_assert(0 == "expected deleted");
} else {
std::cout << num << ": expect " << old_value.most_recent() << std::endl;
}
cerr << num << ": oid " << oid << " header does not match, old size: "
<< old_value.header.length() << " new size " << header.length()
<< std::endl;
- assert(old_value.header == header);
+ ceph_assert(old_value.header == header);
}
if (omap.size() != old_value.attrs.size()) {
cerr << num << ": oid " << oid << " omap.size() is " << omap.size()
<< " and old is " << old_value.attrs.size() << std::endl;
- assert(omap.size() == old_value.attrs.size());
+ ceph_assert(omap.size() == old_value.attrs.size());
}
if (omap_keys.size() != old_value.attrs.size()) {
cerr << num << ": oid " << oid << " omap.size() is " << omap_keys.size()
<< " and old is " << old_value.attrs.size() << std::endl;
- assert(omap_keys.size() == old_value.attrs.size());
+ ceph_assert(omap_keys.size() == old_value.attrs.size());
}
}
if (xattrs.size() != old_value.attrs.size()) {
cerr << num << ": oid " << oid << " xattrs.size() is " << xattrs.size()
<< " and old is " << old_value.attrs.size() << std::endl;
- assert(xattrs.size() == old_value.attrs.size());
+ ceph_assert(xattrs.size() == old_value.attrs.size());
}
for (map<string, ContDesc>::iterator iter = old_value.attrs.begin();
iter != old_value.attrs.end();
iter->second);
if (!context->no_omap) {
map<string, bufferlist>::iterator omap_iter = omap.find(iter->first);
- assert(omap_iter != omap.end());
- assert(bl.length() == omap_iter->second.length());
+ ceph_assert(omap_iter != omap.end());
+ ceph_assert(bl.length() == omap_iter->second.length());
bufferlist::iterator k = bl.begin();
for(bufferlist::iterator l = omap_iter->second.begin();
!k.end() && !l.end();
++k, ++l) {
- assert(*l == *k);
+ ceph_assert(*l == *k);
}
}
map<string, bufferlist>::iterator xattr_iter = xattrs.find(iter->first);
- assert(xattr_iter != xattrs.end());
- assert(bl.length() == xattr_iter->second.length());
+ ceph_assert(xattr_iter != xattrs.end());
+ ceph_assert(bl.length() == xattr_iter->second.length());
bufferlist::iterator k = bl.begin();
for (bufferlist::iterator j = xattr_iter->second.begin();
!k.end() && !j.end();
++j, ++k) {
- assert(*j == *k);
+ ceph_assert(*j == *k);
}
}
if (!context->no_omap) {
i != omap_requested_keys.end();
++i) {
if (!omap_returned_values.count(*i))
- assert(!old_value.attrs.count(*i));
+ ceph_assert(!old_value.attrs.count(*i));
if (!old_value.attrs.count(*i))
- assert(!omap_returned_values.count(*i));
+ ceph_assert(!omap_returned_values.count(*i));
}
for (map<string, bufferlist>::iterator i = omap_returned_values.begin();
i != omap_returned_values.end();
++i) {
- assert(omap_requested_keys.count(i->first));
- assert(omap.count(i->first));
- assert(old_value.attrs.count(i->first));
- assert(i->second == omap[i->first]);
+ ceph_assert(omap_requested_keys.count(i->first));
+ ceph_assert(omap.count(i->first));
+ ceph_assert(old_value.attrs.count(i->first));
+ ceph_assert(i->second == omap[i->first]);
}
}
}
cerr << "snap_create returned " << ret << std::endl;
ceph_abort();
}
- assert(!context->io_ctx.snap_lookup(snapname.c_str(), &snap));
+ ceph_assert(!context->io_ctx.snap_lookup(snapname.c_str(), &snap));
} else {
- assert(!context->io_ctx.selfmanaged_snap_create(&snap));
+ ceph_assert(!context->io_ctx.selfmanaged_snap_create(&snap));
}
context->state_lock.Lock();
if (context->pool_snaps) {
string snapname;
- assert(!context->io_ctx.snap_get_name(snap, &snapname));
- assert(!context->io_ctx.snap_remove(snapname.c_str()));
+ ceph_assert(!context->io_ctx.snap_get_name(snap, &snapname));
+ ceph_assert(!context->io_ctx.snap_remove(snapname.c_str()));
} else {
- assert(!context->io_ctx.selfmanaged_snap_remove(snap));
+ ceph_assert(!context->io_ctx.selfmanaged_snap_remove(snap));
vector<uint64_t> snapset(context->snaps.size());
int j = 0;
uint64_t tid = info->id;
cout << num << ": finishing rollback tid " << tid
<< " to " << context->prefix + oid << std::endl;
- assert((int)(info->id) > last_finished);
+ ceph_assert((int)(info->id) > last_finished);
last_finished = info->id;
int r;
if (info->id == 0) {
// copy_from
- assert(comp->is_complete());
+ ceph_assert(comp->is_complete());
cout << num << ": finishing copy_from to " << context->prefix + oid << std::endl;
if ((r = comp->get_return_value())) {
if (r == -ENOENT && src_value.deleted()) {
ceph_abort();
}
} else {
- assert(!version || comp->get_version64() == version);
+ ceph_assert(!version || comp->get_version64() == version);
version = comp->get_version64();
context->update_object_version(oid, comp->get_version64());
}
} else if (info->id == 1) {
// racing read
- assert(comp_racing_read->is_complete());
+ ceph_assert(comp_racing_read->is_complete());
cout << num << ": finishing copy_from racing read to " << context->prefix + oid << std::endl;
if ((r = comp_racing_read->get_return_value())) {
if (!(r == -ENOENT && src_value.deleted())) {
<< r << std::endl;
}
} else {
- assert(comp_racing_read->get_return_value() == 0);
- assert(!version || comp_racing_read->get_version64() == version);
+ ceph_assert(comp_racing_read->get_return_value() == 0);
+ ceph_assert(!version || comp_racing_read->get_version64() == version);
version = comp_racing_read->get_version64();
}
}
TestWatchContext *ctx = context->get_watch_context(oid);
context->state_lock.Unlock();
if (ctx) {
- assert(old_value.exists);
+ ceph_assert(old_value.exists);
TestAlarm alarm;
std::cerr << num << ": about to start" << std::endl;
ctx->start();
if (balance_reads)
flags |= librados::OPERATION_BALANCE_READS;
- assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[0], &op,
+ ceph_assert(!context->io_ctx.aio_operate(context->prefix+oid, completions[0], &op,
flags, NULL));
waiting_on++;
_do_read(op, tgt_offset, length, 1);
- assert(!context->io_ctx.aio_operate(context->prefix+tgt_oid, completions[1], &op,
+ ceph_assert(!context->io_ctx.aio_operate(context->prefix+tgt_oid, completions[1], &op,
flags, NULL));
waiting_on++;
void _finish(CallbackInfo *info) override
{
Mutex::Locker l(context->state_lock);
- assert(!done);
- assert(waiting_on > 0);
+ ceph_assert(!done);
+ ceph_assert(waiting_on > 0);
if (--waiting_on) {
return;
}
context->find_object(tgt_oid, &tgt_value);
for (int i = 0; i < 2; i++) {
- assert(completions[i]->is_complete());
+ ceph_assert(completions[i]->is_complete());
int err = completions[i]->get_return_value();
if (err != retval) {
cerr << num << ": Error: oid " << oid << " read returned different error codes: "
if (!retval) {
if (old_value.deleted()) {
std::cout << num << ": expect deleted" << std::endl;
- assert(0 == "expected deleted");
+ ceph_assert(0 == "expected deleted");
} else {
std::cout << num << ": expect " << old_value.most_recent() << std::endl;
}
Mutex::Locker l(context->state_lock);
if (info->id == 0) {
- assert(comp->is_complete());
+ ceph_assert(comp->is_complete());
cout << num << ": finishing copy op to oid " << oid << std::endl;
if ((r = comp->get_return_value())) {
cerr << "Error: oid " << oid << " write returned error code "
Mutex::Locker l(context->state_lock);
if (info->id == 0) {
- assert(comp->is_complete());
+ ceph_assert(comp->is_complete());
cout << num << ": finishing set_chunk to oid " << oid << std::endl;
if ((r = comp->get_return_value())) {
if (r == -ENOENT && src_value.deleted()) {
Mutex::Locker l(context->state_lock);
if (info->id == 0) {
- assert(comp->is_complete());
+ ceph_assert(comp->is_complete());
cout << num << ": finishing set_redirect to oid " << oid << std::endl;
if ((r = comp->get_return_value())) {
if (r == -ENOENT && src_value.deleted()) {
op.tier_promote();
int r = context->io_ctx.aio_operate(context->prefix+oid, completion,
&op);
- assert(!r);
+ ceph_assert(!r);
}
void _finish(CallbackInfo *info) override
{
context->state_lock.Lock();
- assert(!done);
- assert(completion->is_complete());
+ ceph_assert(!done);
+ ceph_assert(completion->is_complete());
ObjectDesc oid_value;
context->find_object(oid, &oid_value);
if (r == 0) {
// sucess
} else {
- assert(0 == "shouldn't happen");
+ ceph_assert(0 == "shouldn't happen");
}
context->update_object_version(oid, completion->get_version64());
context->find_object(oid, &oid_value);
comp1 = context->rados.aio_create_completion((void*) cb_arg, NULL,
&write_callback);
int r = context->io_ctx.hit_set_list(hash, comp1, &ls);
- assert(r == 0);
+ ceph_assert(r == 0);
}
void _finish(CallbackInfo *info) override {
comp2 = context->rados.aio_create_completion((void*) cb_arg, NULL,
&write_callback);
r = context->io_ctx.hit_set_get(hash, comp2, p->second, &bl);
- assert(r == 0);
+ ceph_assert(r == 0);
}
} else {
int r = comp2->get_return_value();
<< std::endl;
} else {
// FIXME: we could verify that we did in fact race with a trim...
- assert(r == -ENOENT);
+ ceph_assert(r == -ENOENT);
}
done = true;
}
op.undirty();
int r = context->io_ctx.aio_operate(context->prefix+oid, completion,
&op, 0);
- assert(!r);
+ ceph_assert(!r);
}
void _finish(CallbackInfo *info) override
{
context->state_lock.Lock();
- assert(!done);
- assert(completion->is_complete());
+ ceph_assert(!done);
+ ceph_assert(completion->is_complete());
context->oid_in_use.erase(oid);
context->oid_not_in_use.insert(oid);
context->update_object_version(oid, completion->get_version64());
op.is_dirty(&dirty, NULL);
int r = context->io_ctx.aio_operate(context->prefix+oid, completion,
&op, 0);
- assert(!r);
+ ceph_assert(!r);
if (snap >= 0) {
context->io_ctx.snap_set_read(0);
void _finish(CallbackInfo *info) override
{
context->state_lock.Lock();
- assert(!done);
- assert(completion->is_complete());
+ ceph_assert(!done);
+ ceph_assert(completion->is_complete());
context->oid_in_use.erase(oid);
context->oid_not_in_use.insert(oid);
- assert(context->find_object(oid, &old_value, snap));
+ ceph_assert(context->find_object(oid, &old_value, snap));
int r = completion->get_return_value();
if (r == 0) {
cout << num << ": " << (dirty ? "dirty" : "clean") << std::endl;
- assert(!old_value.deleted());
- assert(dirty == old_value.dirty);
+ ceph_assert(!old_value.deleted());
+ ceph_assert(dirty == old_value.dirty);
} else {
cout << num << ": got " << r << std::endl;
- assert(r == -ENOENT);
- assert(old_value.deleted());
+ ceph_assert(r == -ENOENT);
+ ceph_assert(old_value.deleted());
}
context->kick();
done = true;
}
int r = context->io_ctx.aio_operate(context->prefix+oid, completion,
&op, flags, NULL);
- assert(!r);
+ ceph_assert(!r);
if (snap >= 0) {
context->io_ctx.snap_set_read(0);
void _finish(CallbackInfo *info) override
{
context->state_lock.Lock();
- assert(!done);
- assert(completion->is_complete());
+ ceph_assert(!done);
+ ceph_assert(completion->is_complete());
context->oid_flushing.erase(oid);
context->oid_not_flushing.insert(oid);
int r = completion->get_return_value();
if (r == 0) {
context->update_object_version(oid, 0, snap);
} else if (r == -EBUSY) {
- assert(can_fail);
+ ceph_assert(can_fail);
} else if (r == -EINVAL) {
// caching not enabled?
} else if (r == -ENOENT) {
// may have raced with a remove?
} else {
- assert(0 == "shouldn't happen");
+ ceph_assert(0 == "shouldn't happen");
}
context->kick();
done = true;
int r = context->io_ctx.aio_operate(context->prefix+oid, completion,
&op, librados::OPERATION_IGNORE_CACHE,
NULL);
- assert(!r);
+ ceph_assert(!r);
if (snap >= 0) {
context->io_ctx.snap_set_read(0);
void _finish(CallbackInfo *info) override
{
context->state_lock.Lock();
- assert(!done);
- assert(completion->is_complete());
+ ceph_assert(!done);
+ ceph_assert(completion->is_complete());
int r = completion->get_return_value();
cout << num << ": got " << cpp_strerror(r) << std::endl;
} else if (r == -ENOENT) {
// may have raced with a remove?
} else {
- assert(0 == "shouldn't happen");
+ ceph_assert(0 == "shouldn't happen");
}
context->kick();
done = true;
pg_pool_t empty;
// make an ec pool
uint64_t pool_id = ++new_pool_inc.new_pool_max;
- assert(pool_id == my_ec_pool);
+ ceph_assert(pool_id == my_ec_pool);
pg_pool_t *p = new_pool_inc.get_new_pool(pool_id, &empty);
p->size = 3;
p->set_pg_num(64);
new_pool_inc.new_pool_names[pool_id] = "ec";
// and a replicated pool
pool_id = ++new_pool_inc.new_pool_max;
- assert(pool_id == my_rep_pool);
+ ceph_assert(pool_id == my_rep_pool);
p = new_pool_inc.get_new_pool(pool_id, &empty);
p->size = 3;
p->set_pg_num(64);
multiset<uint64_t> latencies;
void begin(TestOp *in)
{
- assert(!inflight.count(in));
+ ceph_assert(!inflight.count(in));
inflight[in] = gettime();
}
void end(TestOp *in)
{
- assert(inflight.count(in));
+ ceph_assert(inflight.count(in));
uint64_t curtime = gettime();
latencies.insert(curtime - inflight[in]);
inflight.erase(in);
proc_replica_log(
oinfo, olog, omissing, pg_shard_t(1, shard_id_t(0)));
- assert(oinfo.last_update >= log.tail);
+ ceph_assert(oinfo.last_update >= log.tail);
if (!tcase.base.empty()) {
ASSERT_EQ(tcase.base.rbegin()->version, oinfo.last_update);
TestOp *gen_op(RadosTestContext &context, TestOpType type)
{
string oid, oid2;
- assert(context.oid_not_in_use.size());
+ ceph_assert(context.oid_not_in_use.size());
switch (type) {
case TEST_OP_READ:
const ZTracer::Trace &parent_trace,
Context *onfinish)
{
- assert(snapid == CEPH_NOSNAP);
+ ceph_assert(snapid == CEPH_NOSNAP);
C_DelayRead *wrapper = new C_DelayRead(this, m_cct, onfinish, m_lock, oid,
off, len, pbl, m_delay_ns);
m_finisher->queue(wrapper, len);
const ZTracer::Trace &parent_trace,
Context *oncommit)
{
- assert(snapc.seq == 0);
+ ceph_assert(snapc.seq == 0);
C_DelayWrite *wrapper = new C_DelayWrite(this, m_cct, oncommit, m_lock, oid,
off, len, bl, m_delay_ns);
m_finisher->queue(wrapper, 0);
const bufferlist& data_bl)
{
dout(1) << "writing " << oid << " " << off << "~" << len << dendl;
- assert(len == data_bl.length());
+ ceph_assert(len == data_bl.length());
bufferlist& obj_bl = object_data[oid];
bufferlist new_obj_bl;
// ensure size, or set it if new object
: m_op(op), m_outstanding(outstanding) {}
void finish(int r) override {
m_op->done++;
- assert(*m_outstanding > 0);
+ ceph_assert(*m_outstanding > 0);
(*m_outstanding)--;
}
};
lock.Lock();
int r = obc.readx(rd, &object_set, completion);
lock.Unlock();
- assert(r >= 0);
+ ceph_assert(r >= 0);
if ((uint64_t)r == length)
completion->complete(r);
else
- assert(r == 0);
+ ceph_assert(r == 0);
} else {
ObjectCacher::OSDWrite *wr = obc.prepare_write(snapc, bl,
ceph::real_time::min(), 0,
lock.Lock();
int r = obc.readx(back_half_rd, &object_set, &backreadcond);
lock.Unlock();
- assert(r >= 0);
+ ceph_assert(r >= 0);
if (r == 0) {
std::cout << "Waiting to read data into cache" << std::endl;
r = backreadcond.wait();
}
- assert(r == 1<<21);
+ ceph_assert(r == 1<<21);
/* Read the whole object in,
* verify we have to wait for it to complete,
lock.Lock();
r = obc.readx(whole_rd, &object_set, &frontreadcond);
// we cleared out the cache by reading back half, it shouldn't pass immediately!
- assert(r == 0);
+ ceph_assert(r == 0);
std::cout << "Data (correctly) not available without fetching" << std::endl;
ObjectCacher::OSDWrite *verify_wr = obc.prepare_write(snapc, ones_bl,
for (int i = 1<<18; i < 1<<22; i+=1<<18) {
bufferlist ones_maybe;
ones_maybe.substr_of(readbl, i, ones_bl.length());
- assert(0 == memcmp(ones_maybe.c_str(), ones_bl.c_str(), ones_bl.length()));
+ ceph_assert(0 == memcmp(ones_maybe.c_str(), ones_bl.c_str(), ones_bl.length()));
}
bufferlist ones_maybe;
ones_maybe.substr_of(readbl, (1<<18)+(1<<16), ones_bl.length());
- assert(0 == memcmp(ones_maybe.c_str(), ones_bl.c_str(), ones_bl.length()));
+ ceph_assert(0 == memcmp(ones_maybe.c_str(), ones_bl.c_str(), ones_bl.length()));
std::cout << "validated that data is 0xff where it should be" << std::endl;
librbd::ProgressContext &progress_ctx,
ContextWQ *work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
EXPECT_TRUE(image_name.empty());
EXPECT_TRUE(force);
EXPECT_TRUE(remove_from_trash);
static SnapshotPurgeRequest *create(librados::IoCtx &io_ctx,
const std::string &image_id,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->construct(image_id);
s_instance->on_finish = on_finish;
return s_instance;
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
const std::string &image_id,
const char *snap, librados::IoCtx& p,
bool read_only) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
std::string *mirror_uuid,
ContextWQ *work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->get_tag_owner(image_id, mirror_uuid, on_finish);
}
static void notify_image_added(librados::IoCtx&, const std::string& image_id,
const cls::rbd::TrashImageSpec& spec,
Context *ctx) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->notify_image_added(image_id, spec, ctx);
}
const std::string &client_id,
const std::string &mirror_uuid,
ContextWQ *op_work_queue, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
const std::string& image_id,
const cls::rbd::TrashImageSpec& trash_image_spec,
Context* on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->construct(image_id, trash_image_spec);
s_instance->on_finish = on_finish;
return s_instance;
struct MockTrashWatcher {
static MockTrashWatcher *s_instance;
static MockTrashWatcher &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
}
static TrashWatcher<MockTestImageCtx> &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
if (policy_type == "none" || policy_type == "simple") {
m_policy = image_map::SimplePolicy::create(m_local_io_ctx);
} else {
- assert(false);
+ ceph_assert(false);
}
m_policy->init({});
template <>
std::string generate_image_id<MockTestImageCtx>(librados::IoCtx&) {
- assert(!s_image_id.empty());
+ ceph_assert(!s_image_id.empty());
return s_image_id;
}
librbd::journal::MirrorPeerClientMeta *client_meta, ContextWQ *work_queue,
InstanceWatcher<librbd::MockTestImageCtx> *instance_watcher,
Context *on_finish, ProgressContext *progress_ctx) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
ImageSync() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~ImageSync() {
static CloseImageRequest* create(librbd::MockTestImageCtx **image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = image_ctx;
s_instance->on_finish = on_finish;
s_instance->construct(*image_ctx);
}
CloseImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~CloseImageRequest() {
const std::string &local_image_id,
librbd::MockTestImageCtx *remote_image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
s_instance->construct(local_image_id);
return s_instance;
}
CreateImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~CreateImageRequest() {
static IsPrimaryRequest* create(librbd::MockTestImageCtx *image_ctx,
bool *primary, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->primary = primary;
s_instance->on_finish = on_finish;
return s_instance;
}
IsPrimaryRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~IsPrimaryRequest() {
librbd::MockTestImageCtx **image_ctx,
const std::string &image_id,
bool read_only, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = image_ctx;
s_instance->on_finish = on_finish;
s_instance->construct(io_ctx, image_id);
}
OpenImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~OpenImageRequest() {
const std::string &local_image_id,
ContextWQ *work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = local_image_ctx;
s_instance->on_finish = on_finish;
s_instance->construct(local_io_ctx, local_image_id);
}
OpenLocalImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~OpenLocalImageRequest() {
bool skip_mirror_enable,
MockContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
EXPECT_FALSE(non_primary_global_image_id.empty());
EXPECT_FALSE(primary_mirror_uuid.empty());
EXPECT_FALSE(skip_mirror_enable);
const std::string &primary_mirror_uuid,
MockContextWQ *op_work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
s_instance->construct();
return s_instance;
static CloseImageRequest* create(librbd::MockTestImageCtx **image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->construct(*image_ctx);
s_instance->on_finish = on_finish;
return s_instance;
}
CloseImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~CloseImageRequest() {
librbd::MockTestImageCtx **image_ctx,
const std::string &image_id,
bool read_only, Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = image_ctx;
s_instance->on_finish = on_finish;
s_instance->construct(io_ctx, image_id);
}
OpenImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~OpenImageRequest() {
const std::string& global_image_id,
std::string* image_id,
Context* on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_id = image_id;
s_instance->on_finish = on_finish;
return s_instance;
const std::string& global_image_id,
std::string* image_id,
Context* on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_id = image_id;
s_instance->on_finish = on_finish;
return s_instance;
uint64_t size = 0;
image.size(&size);
- assert(size != 0);
+ ceph_assert(size != 0);
vector<uint64_t> thread_offset;
uint64_t i;
void handle(const InstanceIds& instance_ids, Instance* instance) {
std::unique_lock<std::mutex> locker(lock);
for (auto& instance_id : instance_ids) {
- assert(instance->count > 0);
+ ceph_assert(instance->count > 0);
--instance->count;
instance->ids.insert(instance_id);
static LoadRequest *create(librados::IoCtx &ioctx,
std::map<std::string, cls::rbd::MirrorImageMap> *image_map,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_map = image_map;
s_instance->on_finish = on_finish;
return s_instance;
std::map<std::string, cls::rbd::MirrorImageMap> &&update_mapping,
std::set<std::string> &&global_image_ids,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
static void trash_move(librados::IoCtx& local_io_ctx,
const std::string& global_image_id, bool resync,
MockContextWQ* work_queue, Context* on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->trash_move(global_image_id, resync, on_finish);
}
std::string *tag_owner,
MockContextWQ *work_queue,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->local_image_id = local_image_id;
s_instance->local_image_name = local_image_name;
s_instance->tag_owner = tag_owner;
cls::journal::ClientState *client_state,
librbd::journal::MirrorPeerClientMeta *client_meta,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->remote_mirror_uuid = remote_mirror_uuid;
s_instance->remote_image_id = remote_image_id;
s_instance->remote_journaler = remote_journaler;
librbd::journal::MirrorPeerClientMeta *client_meta,
Context *on_finish, bool *do_resync,
rbd::mirror::ProgressContext *progress_ctx = nullptr) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = local_image_ctx;
s_instance->on_finish = on_finish;
s_instance->do_resync = do_resync;
}
BootstrapRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~BootstrapRequest() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
static CloseImageRequest* create(librbd::MockTestImageCtx **image_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ctx = image_ctx;
s_instance->on_finish = on_finish;
return s_instance;
}
CloseImageRequest() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~CloseImageRequest() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
const std::string &local_mirror_uuid,
librbd::journal::MirrorPeerClientMeta *client_meta,
MockContextWQ *work_queue) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
}
EventPreprocessor() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~EventPreprocessor() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
static ReplayStatusFormatter* create(::journal::MockJournalerProxy *journaler,
const std::string &mirror_uuid) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
}
ReplayStatusFormatter() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~ReplayStatusFormatter() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
bool flatten, const librbd::deep_copy::ObjectNumber &object_number,
ContextWQ *work_queue, SnapSeqs *snap_seqs, ProgressContext *prog_ctx,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
journal::MockJournaler *journaler,
librbd::journal::MirrorPeerClientMeta *client_meta,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
return s_instance;
}
journal::MockJournaler *journaler,
librbd::journal::MirrorPeerClientMeta *client_meta,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->on_finish = on_finish;
s_instance->sync_complete = sync_complete;
return s_instance;
InstanceWatcher<librbd::MockTestImageCtx> *instance_watcher,
RadosRef local, const std::string &local_mirror_uuid, int64_t local_pool_id,
const std::string &global_image_id) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->global_image_id = global_image_id;
return s_instance;
}
ImageReplayer() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
virtual ~ImageReplayer() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
EXPECT_CALL(*mock_threads.timer, add_event_after(_, _))
.WillOnce(DoAll(
WithArg<1>(Invoke([this, &mock_threads, timer_ctx](Context *ctx) {
- assert(mock_threads.timer_lock.is_locked());
+ ceph_assert(mock_threads.timer_lock.is_locked());
if (timer_ctx != nullptr) {
*timer_ctx = ctx;
mock_threads.timer_cond.SignalOne();
managed_lock::Mode mode,
bool blacklist_on_break_lock,
uint32_t blacklist_expire_seconds) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
ManagedLock() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~ManagedLock() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
static ImageSyncThrottler* s_instance;
static ImageSyncThrottler *create() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
ImageSyncThrottler() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
virtual ~ImageSyncThrottler() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
struct MockManagedLock {
static MockManagedLock *s_instance;
static MockManagedLock &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
static MirrorStatusWatcher *create(librados::IoCtx &io_ctx,
ContextWQ *work_queue) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
MirrorStatusWatcher() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~MirrorStatusWatcher() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
librados::IoCtx &ioctx,
const std::string& instance_id,
instances::Listener&) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return s_instance;
}
Instances() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~Instances() {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
static MockListener* s_instance;
MockListener() {
- assert(s_instance == nullptr);
+ ceph_assert(s_instance == nullptr);
s_instance = this;
}
~MockListener() override {
- assert(s_instance == this);
+ ceph_assert(s_instance == this);
s_instance = nullptr;
}
struct MockMirroringWatcher {
static MockMirroringWatcher *s_instance;
static MockMirroringWatcher &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
}
static MirroringWatcher<MockTestImageCtx> &get_instance() {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
return *s_instance;
}
static RefreshImagesRequest *create(librados::IoCtx &io_ctx,
ImageIds *image_ids,
Context *on_finish) {
- assert(s_instance != nullptr);
+ ceph_assert(s_instance != nullptr);
s_instance->image_ids = image_ids;
s_instance->on_finish = on_finish;
return s_instance;
auto i = bl_buffers.begin();
while (bl_len > 0)
{
- assert(i != bl_buffers.end());
+ ceph_assert(i != bl_buffers.end());
off_t len = std::min<off_t>(bl_len, i->length());
sink.append(*i, 0, len);
bl_len -= len;
usr2 = true;
break;
default:
- assert(0 == "unexpected signal");
+ ceph_assert(0 == "unexpected signal");
}
}
std::string get_temp_pool_name(const char* prefix)
{
- assert(prefix);
+ ceph_assert(prefix);
char hostname[80];
int ret = 0;
ret = gethostname(hostname, sizeof(hostname));
- assert(!ret);
+ ceph_assert(!ret);
char poolname[256];
ret = snprintf(poolname, sizeof(poolname),
"%s.%s-%d", prefix, hostname, getpid());
- assert(ret > 0);
- assert((unsigned int)ret < sizeof(poolname));
+ ceph_assert(ret > 0);
+ ceph_assert((unsigned int)ret < sizeof(poolname));
return poolname;
}
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
-#include <assert.h>
+
+#include "include/assert.h"
#define REGION 1048576
int main(int argc, char *argv[]) {
int i = 0;
while(!done) {
printf("writing %d\n", i++);
- assert(pwrite(fd, buf, REGION, 0) == REGION);
+ ceph_assert(pwrite(fd, buf, REGION, 0) == REGION);
int status;
int ret = waitpid(p, &status, WNOHANG);
- assert(ret >= 0);
+ ceph_assert(ret >= 0);
if (ret > 0) {
done = 1;
}
}
printf("reading\n");
- assert(pread(fd, buf, REGION, 0) == REGION);
+ ceph_assert(pread(fd, buf, REGION, 0) == REGION);
close(fd);
}
auto p = bl.begin();
auto sum = std::accumulate(segments.begin(), segments.end(), 0u);
- assert(sum != 0u);
+ ceph_assert(sum != 0u);
for (auto i : segments) {
buffer::ptr seg;
p.copy_deep(bl.length() * i / sum, seg);
while (true) {
utime_t now = ceph_clock_now();
int r = ::pwrite(fd, fn, strlen(fn), 0);
- assert(r >= 0);
+ ceph_assert(r >= 0);
utime_t lat = ceph_clock_now();
lat -= now;
utime_t oldmin;
cond.Signal();
return 0;
}
- assert(!queue.empty());
- assert(!paused);
+ ceph_assert(!queue.empty());
+ ceph_assert(!paused);
ops.swap(queue);
cond.Signal();
}
- assert(!ops.empty());
+ ceph_assert(!ops.empty());
for (list<Op>::iterator i = ops.begin();
i != ops.end();
}
void choose_random_snaps(int num, set<snapid_t> *snaps) {
- assert(snaps);
- assert(!snap_to_hobject.empty());
+ ceph_assert(snaps);
+ ceph_assert(!snap_to_hobject.empty());
for (int i = 0; i < num || snaps->empty(); ++i) {
snaps->insert(rand_choose(snap_to_hobject)->first);
}
i != snaps.end();
++i) {
map<snapid_t, set<hobject_t> >::iterator j = snap_to_hobject.find(*i);
- assert(j != snap_to_hobject.end());
+ ceph_assert(j != snap_to_hobject.end());
j->second.insert(obj);
}
{
while (mapper->get_next_objects_to_trim(
snap->first, rand() % 5 + 1, &hoids) == 0) {
for (auto &&hoid: hoids) {
- assert(!hoid.is_max());
- assert(hobjects.count(hoid));
+ ceph_assert(!hoid.is_max());
+ ceph_assert(hobjects.count(hoid));
hobjects.erase(hoid);
map<hobject_t, set<snapid_t>>::iterator j =
hobject_to_snap.find(hoid);
- assert(j->second.count(snap->first));
+ ceph_assert(j->second.count(snap->first));
set<snapid_t> old_snaps(j->second);
j->second.erase(snap->first);
}
hoids.clear();
}
- assert(hobjects.empty());
+ ceph_assert(hobjects.empty());
snap_to_hobject.erase(snap);
}
++i) {
map<snapid_t, set<hobject_t> >::iterator j =
snap_to_hobject.find(*i);
- assert(j->second.count(obj->first));
+ ceph_assert(j->second.count(obj->first));
j->second.erase(obj->first);
}
{
rand_choose(hobject_to_snap);
set<snapid_t> snaps;
int r = mapper->get_snaps(obj->first, &snaps);
- assert(r == 0);
+ ceph_assert(r == 0);
ASSERT_EQ(snaps, obj->second);
}
};
bufferlist enc_out;
std::string error;
if (key.encrypt(g_ceph_context, enc_in, enc_out, &error) < 0) {
- assert(!error.empty());
+ ceph_assert(!error.empty());
dout(0) << "couldn't encode! error " << error << dendl;
exit(1);
}
dec_in = enc_out;
if (key.decrypt(g_ceph_context, dec_in, dec_out, &error) < 0) {
- assert(!error.empty());
+ ceph_assert(!error.empty());
dout(0) << "couldn't decode! error " << error << dendl;
exit(1);
}
// start up network
int whoami = mc.monmap.get_rank(args[0]);
- assert(whoami >= 0);
+ ceph_assert(whoami >= 0);
ostringstream ss;
ss << mc.monmap.get_addr(whoami);
std::string sss(ss.str());
store_dev));
std::cerr << "mkfs starting" << std::endl;
- assert(!store->mkfs());
- assert(!store->mount());
+ ceph_assert(!store->mkfs());
+ ceph_assert(!store->mount());
std::cerr << "mounted" << std::endl;
std::cerr << "attrsize\tnumattrs\ttranssize\tops\ttime" << std::endl;
projects / ceph.git / commitdiff