AsyncOpTracker::~AsyncOpTracker() {
Mutex::Locker locker(m_lock);
- assert(m_pending_ops == 0);
+ ceph_assert(m_pending_ops == 0);
}
void AsyncOpTracker::start_op() {
Context *on_finish = nullptr;
{
Mutex::Locker locker(m_lock);
- assert(m_pending_ops > 0);
+ ceph_assert(m_pending_ops > 0);
if (--m_pending_ops == 0) {
std::swap(on_finish, m_on_finish);
}
void AsyncOpTracker::wait_for_ops(Context *on_finish) {
{
Mutex::Locker locker(m_lock);
- assert(m_on_finish == nullptr);
+ ceph_assert(m_on_finish == nullptr);
if (m_pending_ops > 0) {
m_on_finish = on_finish;
return;
set<pair<unsigned,T>> preempt_by_prio; ///< in_progress that can be preempted
void preempt_one() {
- assert(!preempt_by_prio.empty());
+ ceph_assert(!preempt_by_prio.empty());
auto q = in_progress.find(preempt_by_prio.begin()->second);
- assert(q != in_progress.end());
+ ceph_assert(q != in_progress.end());
Reservation victim = q->second;
rdout(10) << __func__ << " preempt " << victim << dendl;
f->queue(victim.preempt);
// choose highest priority queue
auto it = queues.end();
--it;
- assert(!it->second.empty());
+ ceph_assert(!it->second.empty());
if (it->first < min_priority) {
break;
}
Mutex::Locker l(lock);
Reservation r(item, prio, on_reserved, on_preempt);
rdout(10) << __func__ << " queue " << r << dendl;
- assert(!queue_pointers.count(item) &&
+ ceph_assert(!queue_pointers.count(item) &&
!in_progress.count(item));
queues[prio].push_back(r);
queue_pointers.insert(make_pair(item,
size_t length,
const bufferlist &bl,
bufferptr* csum_data) {
- assert(length % csum_block_size == 0);
+ ceph_assert(length % csum_block_size == 0);
size_t blocks = length / csum_block_size;
bufferlist::const_iterator p = bl.begin();
- assert(bl.length() >= length);
+ ceph_assert(bl.length() >= length);
typename Alg::state_t state;
Alg::init(&state);
- assert(csum_data->length() >= (offset + length) / csum_block_size *
+ ceph_assert(csum_data->length() >= (offset + length) / csum_block_size *
sizeof(typename Alg::value_t));
typename Alg::value_t *pv =
const bufferptr& csum_data,
uint64_t *bad_csum=0
) {
- assert(length % csum_block_size == 0);
+ ceph_assert(length % csum_block_size == 0);
bufferlist::const_iterator p = bl.begin();
- assert(bl.length() >= length);
+ ceph_assert(bl.length() >= length);
typename Alg::state_t state;
Alg::init(&state);
~CommandTable()
{
- assert(commands.empty());
+ ceph_assert(commands.empty());
}
T& start_command()
public:
Cond() : waiter_mutex(NULL) {
- [[maybe_unused]] int r = pthread_cond_init(&_c,NULL);
- assert(r == 0);
+ int r = pthread_cond_init(&_c,NULL);
+ ceph_assert(r == 0);
}
virtual ~Cond() {
pthread_cond_destroy(&_c);
int Wait(Mutex &mutex) {
// make sure this cond is used with one mutex only
- assert(waiter_mutex == NULL || waiter_mutex == &mutex);
+ ceph_assert(waiter_mutex == NULL || waiter_mutex == &mutex);
waiter_mutex = &mutex;
- assert(mutex.is_locked());
+ ceph_assert(mutex.is_locked());
mutex._pre_unlock();
int r = pthread_cond_wait(&_c, &mutex._m);
int WaitUntil(Mutex &mutex, utime_t when) {
// make sure this cond is used with one mutex only
- assert(waiter_mutex == NULL || waiter_mutex == &mutex);
+ ceph_assert(waiter_mutex == NULL || waiter_mutex == &mutex);
waiter_mutex = &mutex;
- assert(mutex.is_locked());
+ ceph_assert(mutex.is_locked());
struct timespec ts;
when.to_timespec(&ts);
}
int Signal() {
// make sure signaler is holding the waiter's lock.
- assert(waiter_mutex == NULL ||
+ ceph_assert(waiter_mutex == NULL ||
waiter_mutex->is_locked());
int r = pthread_cond_broadcast(&_c);
}
int SignalOne() {
// make sure signaler is holding the waiter's lock.
- assert(waiter_mutex == NULL ||
+ ceph_assert(waiter_mutex == NULL ||
waiter_mutex->is_locked());
int r = pthread_cond_signal(&_c);
}
int SignalAll() {
// make sure signaler is holding the waiter's lock.
- assert(waiter_mutex == NULL ||
+ ceph_assert(waiter_mutex == NULL ||
waiter_mutex->is_locked());
int r = pthread_cond_broadcast(&_c);
section_iter_t::value_type vt("global", ConfSection());
pair < section_iter_t, bool > vr(sections.insert(vt));
- assert(vr.second);
+ ceph_assert(vr.second);
section_iter_t cur_section = vr.first;
std::string acc;
ceph_abort();
break;
}
- assert(c != '\0'); // We better not go past the end of the input string.
+ ceph_assert(c != '\0'); // We better not go past the end of the input string.
}
}
* @param r The return code that will be provided to the next stage
*/
bool immediate(int stage, int r) {
- assert(!stages_in_flight.count(stage));
- assert(!stages_processing.count(stage));
+ ceph_assert(!stages_in_flight.count(stage));
+ ceph_assert(!stages_processing.count(stage));
stages_in_flight.insert(stage);
stages_processing.insert(stage);
return _continue_function(r, stage);
* @param func The function to use
*/
void set_callback(int stage, stagePtr func) {
- assert(callbacks.find(stage) == callbacks.end());
+ ceph_assert(callbacks.find(stage) == callbacks.end());
callbacks[stage] = func;
}
bool _continue_function(int r, int n) {
set<int>::iterator stage_iter = stages_in_flight.find(n);
- assert(stage_iter != stages_in_flight.end());
- assert(callbacks.count(n));
+ ceph_assert(stage_iter != stages_in_flight.end());
+ ceph_assert(callbacks.count(n));
stagePtr p = callbacks[n];
pair<set<int>::iterator,bool> insert_r = stages_processing.insert(n);
/**
* Clean up.
*/
- virtual ~Continuation() { assert(on_finish == NULL); }
+ virtual ~Continuation() { ceph_assert(on_finish == NULL); }
/**
* Begin running the Continuation.
*/
old_cycles = 0;
while (1) {
if (gettimeofday(&start_time, NULL) != 0) {
- assert(0 == "couldn't read clock");
+ ceph_assert(0 == "couldn't read clock");
}
uint64_t start_cycles = rdtsc();
while (1) {
if (gettimeofday(&stop_time, NULL) != 0) {
- assert(0 == "couldn't read clock");
+ ceph_assert(0 == "couldn't read clock");
}
uint64_t stop_cycles = rdtsc();
micros = (stop_time.tv_usec - start_time.tv_usec) +
Finisher *fin;
public:
C_OnFinisher(Context *c, Finisher *f) : con(c), fin(f) {
- assert(fin != NULL);
- assert(con != NULL);
+ ceph_assert(fin != NULL);
+ ceph_assert(con != NULL);
}
~C_OnFinisher() override {
void JSONFormatter::close_section()
{
- assert(!m_stack.empty());
+ ceph_assert(!m_stack.empty());
finish_pending_string();
struct json_formatter_stack_entry_d& entry = m_stack.back();
void XMLFormatter::close_section()
{
- assert(!m_sections.empty());
+ ceph_assert(!m_sections.empty());
finish_pending_string();
std::string section = m_sections.back();
HeartbeatMap::~HeartbeatMap()
{
- assert(m_workers.empty());
+ ceph_assert(m_workers.empty());
}
heartbeat_handle_d *HeartbeatMap::add_worker(const string& name, pthread_t thread_id)
<< " had suicide timed out after " << h->suicide_grace << dendl;
pthread_kill(h->thread_id, SIGABRT);
sleep(1);
- assert(0 == "hit suicide timeout");
+ ceph_assert(0 == "hit suicide timeout");
}
return healthy;
}
Message *LogClient::_get_mon_log_message()
{
- assert(log_lock.is_locked());
+ ceph_assert(log_lock.is_locked());
if (log_queue.empty())
return NULL;
<< " num " << log_queue.size()
<< " unsent " << num_unsent
<< " sending " << num_send << dendl;
- assert(num_unsent <= log_queue.size());
+ ceph_assert(num_unsent <= log_queue.size());
std::deque<LogEntry>::iterator p = log_queue.begin();
std::deque<LogEntry> o;
while (p->seq <= last_log_sent) {
++p;
- assert(p != log_queue.end());
+ ceph_assert(p != log_queue.end());
}
while (num_send--) {
- assert(p != log_queue.end());
+ ceph_assert(p != log_queue.end());
o.push_back(*p);
last_log_sent = p->seq;
ldout(cct,10) << " will send " << *p << dendl;
void LogClient::_send_to_mon()
{
- assert(log_lock.is_locked());
- assert(is_mon);
- assert(messenger->get_myname().is_mon());
+ ceph_assert(log_lock.is_locked());
+ ceph_assert(is_mon);
+ ceph_assert(messenger->get_myname().is_mon());
ldout(cct,10) << __func__ << " log to self" << dendl;
Message *log = _get_mon_log_message();
messenger->get_loopback_connection()->send_message(log);
}
Mutex::~Mutex() {
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
// helgrind gets confused by condition wakeups leading to mutex destruction
ANNOTATE_BENIGN_RACE_SIZED(&_m, sizeof(_m), "Mutex primitive");
r = pthread_mutex_lock(&_m);
}
- assert(r == 0);
+ ceph_assert(r == 0);
if (lockdep && g_lockdep) _locked();
_post_lock();
_pre_unlock();
if (lockdep && g_lockdep) _will_unlock();
int r = pthread_mutex_unlock(&_m);
- assert(r == 0);
+ ceph_assert(r == 0);
}
void _post_lock() {
if (!recursive) {
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
locked_by = pthread_self();
};
nlock++;
}
void _pre_unlock() {
- assert(nlock > 0);
+ ceph_assert(nlock > 0);
--nlock;
if (!recursive) {
- assert(locked_by == pthread_self());
+ ceph_assert(locked_by == pthread_self());
locked_by = 0;
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
}
}
void Unlock();
int PluginRegistry::remove(const std::string& type, const std::string& name)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
std::map<std::string,std::map<std::string,Plugin*> >::iterator i =
plugins.find(type);
const std::string& name,
Plugin* plugin)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
if (plugins.count(type) &&
plugins[type].count(name)) {
return -EEXIST;
Plugin *PluginRegistry::get(const std::string& type,
const std::string& name)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
Plugin *ret = 0;
std::map<std::string,Plugin*>::iterator j;
int PluginRegistry::load(const std::string &type,
const std::string &name)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
ldout(cct, 1) << __func__ << " " << type << " " << name << dendl;
// std::string fname = cct->_conf->plugin_dir + "/" + type + "/" PLUGIN_PREFIX
{}
int prefork(std::string &err) {
- assert(!forked);
+ ceph_assert(!forked);
int r = ::socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
std::ostringstream oss;
if (r < 0) {
}
int parent_wait(std::string &err_msg) {
- assert(forked);
+ ceph_assert(forked);
int r = -1;
std::ostringstream oss;
}
void daemonize() {
- assert(forked);
+ ceph_assert(forked);
static int r = -1;
int r2 = ::write(fd[1], &r, sizeof(r));
r += r2; // make the compiler shut up about the unused return code from ::write(2).
#ifndef PRIORITY_QUEUE_H
#define PRIORITY_QUEUE_H
+#include "include/assert.h"
+
#include "common/Formatter.h"
#include "common/OpQueue.h"
size++;
}
std::pair<unsigned, T> &front() const {
- assert(!(q.empty()));
- assert(cur != q.end());
+ ceph_assert(!(q.empty()));
+ ceph_assert(cur != q.end());
return cur->second.front();
}
T pop_front() {
- assert(!(q.empty()));
- assert(cur != q.end());
+ ceph_assert(!(q.empty()));
+ ceph_assert(cur != q.end());
T ret = std::move(cur->second.front().second);
cur->second.pop_front();
if (cur->second.empty()) {
return ret;
}
unsigned length() const {
- assert(size >= 0);
+ ceph_assert(size >= 0);
return (unsigned)size;
}
bool empty() const {
}
void remove_queue(unsigned priority) {
- assert(queue.count(priority));
+ ceph_assert(queue.count(priority));
queue.erase(priority);
total_priority -= priority;
- assert(total_priority >= 0);
+ ceph_assert(total_priority >= 0);
}
void distribute_tokens(unsigned cost) {
for (typename SubQueues::const_iterator i = queue.begin();
i != queue.end();
++i) {
- assert(i->second.length());
+ ceph_assert(i->second.length());
total += i->second.length();
}
for (typename SubQueues::const_iterator i = high_queue.begin();
i != high_queue.end();
++i) {
- assert(i->second.length());
+ ceph_assert(i->second.length());
total += i->second.length();
}
return total;
}
bool empty() const final {
- assert(total_priority >= 0);
- assert((total_priority == 0) || !(queue.empty()));
+ ceph_assert(total_priority >= 0);
+ ceph_assert((total_priority == 0) || !(queue.empty()));
return queue.empty() && high_queue.empty();
}
T dequeue() final {
- assert(!empty());
+ ceph_assert(!empty());
if (!(high_queue.empty())) {
T ret = std::move(high_queue.rbegin()->second.front().second);
for (typename SubQueues::iterator i = queue.begin();
i != queue.end();
++i) {
- assert(!(i->second.empty()));
+ ceph_assert(!(i->second.empty()));
if (i->second.front().first < i->second.num_tokens()) {
unsigned cost = i->second.front().first;
i->second.take_tokens(cost);
if (entries.empty()) {
cond.Wait(lock);
};
- assert(!entries.empty());
+ ceph_assert(!entries.empty());
*entry = entries.front();
entries.pop_front();
lock.Unlock();
}
bool is_locked() const {
- assert(track);
+ ceph_assert(track);
return (nrlock > 0) || (nwlock > 0);
}
bool is_wlocked() const {
- assert(track);
+ ceph_assert(track);
return (nwlock > 0);
}
~RWLock() {
// The following check is racy but we are about to destroy
// the object and we assume that there are no other users.
if (track)
- assert(!is_locked());
+ ceph_assert(!is_locked());
pthread_rwlock_destroy(&L);
if (lockdep && g_lockdep) {
lockdep_unregister(id);
if (nwlock > 0) {
nwlock--;
} else {
- assert(nrlock > 0);
+ ceph_assert(nrlock > 0);
nrlock--;
}
}
if (lockdep && this->lockdep && g_lockdep)
id = lockdep_will_unlock(name.c_str(), id);
int r = pthread_rwlock_unlock(&L);
- assert(r == 0);
+ ceph_assert(r == 0);
}
// read
void get_read() const {
if (lockdep && g_lockdep) id = lockdep_will_lock(name.c_str(), id);
int r = pthread_rwlock_rdlock(&L);
- assert(r == 0);
+ ceph_assert(r == 0);
if (lockdep && g_lockdep) id = lockdep_locked(name.c_str(), id);
if (track)
nrlock++;
if (lockdep && this->lockdep && g_lockdep)
id = lockdep_will_lock(name.c_str(), id);
int r = pthread_rwlock_wrlock(&L);
- assert(r == 0);
+ ceph_assert(r == 0);
if (lockdep && this->lockdep && g_lockdep)
id = lockdep_locked(name.c_str(), id);
if (track)
locked = true;
}
void unlock() {
- assert(locked);
+ ceph_assert(locked);
m_lock.unlock();
locked = false;
}
locked = true;
}
void unlock() {
- assert(locked);
+ ceph_assert(locked);
m_lock.unlock();
locked = false;
}
Context(RWLock& l, LockState s) : lock(l), state(s) {}
void get_write() {
- assert(state == Untaken);
+ ceph_assert(state == Untaken);
lock.get_write();
state = TakenForWrite;
}
void get_read() {
- assert(state == Untaken);
+ ceph_assert(state == Untaken);
lock.get_read();
state = TakenForRead;
}
void unlock() {
- assert(state != Untaken);
+ ceph_assert(state != Untaken);
lock.unlock();
state = Untaken;
}
void promote() {
- assert(state == TakenForRead);
+ ceph_assert(state == TakenForRead);
unlock();
get_write();
}
uint64_t dist_next = align_next - readahead_end;
if (dist_prev < readahead_length / 2 && dist_prev < dist_next) {
// we can snap to the previous alignment point by a less than 50% reduction in size
- assert(align_prev > readahead_offset);
+ ceph_assert(align_prev > readahead_offset);
readahead_length = align_prev - readahead_offset;
break;
} else if(dist_next < readahead_length / 2) {
// we can snap to the next alignment point by a less than 50% increase in size
- assert(align_next > readahead_offset);
+ ceph_assert(align_next > readahead_offset);
readahead_length = align_next - readahead_offset;
break;
}
}
void Readahead::inc_pending(int count) {
- assert(count > 0);
+ ceph_assert(count > 0);
m_pending_lock.Lock();
m_pending += count;
m_pending_lock.Unlock();
}
void Readahead::dec_pending(int count) {
- assert(count > 0);
+ ceph_assert(count > 0);
m_pending_lock.Lock();
- assert(m_pending >= count);
+ ceph_assert(m_pending >= count);
m_pending -= count;
if (m_pending == 0) {
std::list<Context *> pending_waiting(std::move(m_pending_waiting));
public:
RefCountedObject(CephContext *c = NULL, int n=1) : nref(n), cct(c) {}
virtual ~RefCountedObject() {
- assert(nref == 0);
+ ceph_assert(nref == 0);
}
const RefCountedObject *get() const {
}
SubProcess::~SubProcess() {
- assert(!is_spawned());
- assert(stdin_pipe_out_fd == -1);
- assert(stdout_pipe_in_fd == -1);
- assert(stderr_pipe_in_fd == -1);
+ ceph_assert(!is_spawned());
+ ceph_assert(stdin_pipe_out_fd == -1);
+ ceph_assert(stdout_pipe_in_fd == -1);
+ ceph_assert(stderr_pipe_in_fd == -1);
}
void SubProcess::add_cmd_args(const char *arg, ...) {
- assert(!is_spawned());
+ ceph_assert(!is_spawned());
va_list ap;
va_start(ap, arg);
}
void SubProcess::add_cmd_arg(const char *arg) {
- assert(!is_spawned());
+ ceph_assert(!is_spawned());
cmd_args.push_back(arg);
}
int SubProcess::get_stdin() const {
- assert(is_spawned());
- assert(stdin_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stdin_op == PIPE);
return stdin_pipe_out_fd;
}
int SubProcess::get_stdout() const {
- assert(is_spawned());
- assert(stdout_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stdout_op == PIPE);
return stdout_pipe_in_fd;
}
int SubProcess::get_stderr() const {
- assert(is_spawned());
- assert(stderr_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stderr_op == PIPE);
return stderr_pipe_in_fd;
}
}
void SubProcess::close_stdin() {
- assert(is_spawned());
- assert(stdin_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stdin_op == PIPE);
close(stdin_pipe_out_fd);
}
void SubProcess::close_stdout() {
- assert(is_spawned());
- assert(stdout_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stdout_op == PIPE);
close(stdout_pipe_in_fd);
}
void SubProcess::close_stderr() {
- assert(is_spawned());
- assert(stderr_op == PIPE);
+ ceph_assert(is_spawned());
+ ceph_assert(stderr_op == PIPE);
close(stderr_pipe_in_fd);
}
void SubProcess::kill(int signo) const {
- assert(is_spawned());
+ ceph_assert(is_spawned());
int ret = ::kill(pid, signo);
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
const std::string SubProcess::err() const {
};
int SubProcess::spawn() {
- assert(!is_spawned());
- assert(stdin_pipe_out_fd == -1);
- assert(stdout_pipe_in_fd == -1);
- assert(stderr_pipe_in_fd == -1);
+ ceph_assert(!is_spawned());
+ ceph_assert(stdin_pipe_out_fd == -1);
+ ceph_assert(stdout_pipe_in_fd == -1);
+ ceph_assert(stderr_pipe_in_fd == -1);
enum { IN = 0, OUT = 1 };
}
void SubProcess::exec() {
- assert(is_child());
+ ceph_assert(is_child());
std::vector<const char *> args;
args.push_back(cmd.c_str());
args.push_back(NULL);
int ret = execvp(cmd.c_str(), (char * const *)&args[0]);
- assert(ret == -1);
+ ceph_assert(ret == -1);
std::cerr << cmd << ": exec failed: " << cpp_strerror(errno) << "\n";
_exit(EXIT_FAILURE);
}
int SubProcess::join() {
- assert(is_spawned());
+ ceph_assert(is_spawned());
close(stdin_pipe_out_fd);
close(stdout_pipe_in_fd);
int status;
while (waitpid(pid, &status, 0) == -1)
- assert(errno == EINTR);
+ ceph_assert(errno == EINTR);
pid = -1;
static void dummy_sighandler(int sig) {}
void SubProcessTimed::exec() {
- assert(is_child());
+ ceph_assert(is_child());
if (timeout <= 0) {
SubProcess::exec();
}
// inserting more items than defined columns is a coding error
- assert(curcol + 1 <= col.size());
+ ceph_assert(curcol + 1 <= col.size());
// get rendered width of item alone
std::ostringstream oss;
void Thread::create(const char *name, size_t stacksize)
{
- assert(strlen(name) < 16);
+ ceph_assert(strlen(name) < 16);
thread_name = name;
int ret = try_create(stacksize);
snprintf(buf, sizeof(buf), "Thread::try_create(): pthread_create "
"failed with error %d", ret);
dout_emergency(buf);
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
}
int Thread::join(void **prval)
{
if (thread_id == 0) {
- assert("join on thread that was never started" == 0);
+ ceph_assert("join on thread that was never started" == 0);
return -EINVAL;
}
snprintf(buf, sizeof(buf), "Thread::join(): pthread_join "
"failed with error %d\n", status);
dout_emergency(buf);
- assert(status == 0);
+ ceph_assert(status == 0);
}
thread_id = 0;
bool _use_perf)
: cct(cct), name(n), max(m), use_perf(_use_perf)
{
- assert(m >= 0);
+ ceph_assert(m >= 0);
if (!use_perf)
return;
Throttle::~Throttle()
{
auto l = uniquely_lock(lock);
- assert(conds.empty());
+ ceph_assert(conds.empty());
}
void Throttle::_reset_max(int64_t m)
auto l = uniquely_lock(lock);
if (m) {
- assert(m > 0);
+ ceph_assert(m > 0);
_reset_max(m);
}
ldout(cct, 10) << "wait" << dendl;
if (0 == max) {
return 0;
}
- assert(c >= 0);
+ ceph_assert(c >= 0);
ldout(cct, 10) << "take " << c << dendl;
{
auto l = uniquely_lock(lock);
return false;
}
- assert(c >= 0);
+ ceph_assert(c >= 0);
ldout(cct, 10) << "get " << c << " (" << count.load() << " -> " << (count.load() + c) << ")" << dendl;
if (logger) {
logger->inc(l_throttle_get_started);
{
auto l = uniquely_lock(lock);
if (m) {
- assert(m > 0);
+ ceph_assert(m > 0);
_reset_max(m);
}
waited = _wait(c, l);
return 0;
}
- assert(c >= 0);
+ ceph_assert(c >= 0);
ldout(cct, 10) << "put " << c << " (" << count.load() << " -> "
<< (count.load()-c) << ")" << dendl;
auto l = uniquely_lock(lock);
if (!conds.empty())
conds.front().notify_one();
// if count goes negative, we failed somewhere!
- assert(count >= c);
+ ceph_assert(count >= c);
count -= c;
if (logger) {
logger->inc(l_throttle_put);
BackoffThrottle::~BackoffThrottle()
{
auto l = uniquely_lock(lock);
- assert(waiters.empty());
+ ceph_assert(waiters.empty());
}
bool BackoffThrottle::set_params(
} else {
break;
}
- assert(ticket == waiters.begin());
+ ceph_assert(ticket == waiters.begin());
delay = _get_delay(c) - (std::chrono::system_clock::now() - start);
}
waiters.pop_front();
uint64_t BackoffThrottle::put(uint64_t c)
{
locker l(lock);
- assert(current >= c);
+ ceph_assert(current >= c);
current -= c;
_kick_waiters();
SimpleThrottle::~SimpleThrottle()
{
auto l = uniquely_lock(m_lock);
- assert(m_current == 0);
- assert(waiters == 0);
+ ceph_assert(m_current == 0);
+ ceph_assert(waiters == 0);
}
void SimpleThrottle::start_op()
OrderedThrottle::~OrderedThrottle() {
auto l = uniquely_lock(m_lock);
- assert(waiters == 0);
+ ceph_assert(waiters == 0);
}
C_OrderedThrottle *OrderedThrottle::start_op(Context *on_finish) {
- assert(on_finish);
+ ceph_assert(on_finish);
auto l = uniquely_lock(m_lock);
uint64_t tid = m_next_tid++;
void OrderedThrottle::end_op(int r) {
auto l = uniquely_lock(m_lock);
- assert(m_current > 0);
+ ceph_assert(m_current > 0);
if (r < 0 && m_ret_val == 0 && (r != -ENOENT || !m_ignore_enoent)) {
m_ret_val = r;
auto l = uniquely_lock(m_lock);
auto it = m_tid_result.find(tid);
- assert(it != m_tid_result.end());
+ ceph_assert(it != m_tid_result.end());
it->second.finished = true;
it->second.ret_val = r;
SafeTimer::~SafeTimer()
{
- assert(thread == NULL);
+ ceph_assert(thread == NULL);
}
void SafeTimer::init()
{
ldout(cct,10) << "shutdown" << dendl;
if (thread) {
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
cancel_all_events();
stopping = true;
cond.Signal();
Context* SafeTimer::add_event_after(double seconds, Context *callback)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
utime_t when = ceph_clock_now();
when += seconds;
Context* SafeTimer::add_event_at(utime_t when, Context *callback)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
ldout(cct,10) << __func__ << " " << when << " -> " << callback << dendl;
if (stopping) {
ldout(cct,5) << __func__ << " already shutdown, event not added" << dendl;
pair < event_lookup_map_t::iterator, bool > rval(events.insert(e_val));
/* If you hit this, you tried to insert the same Context* twice. */
- assert(rval.second);
+ ceph_assert(rval.second);
/* If the event we have just inserted comes before everything else, we need to
* adjust our timeout. */
bool SafeTimer::cancel_event(Context *callback)
{
- assert(lock.is_locked());
+ ceph_assert(lock.is_locked());
auto p = events.find(callback);
if (p == events.end()) {
void SafeTimer::cancel_all_events()
{
ldout(cct,10) << "cancel_all_events" << dendl;
- assert(lock.is_locked());
-
+ ceph_assert(lock.is_locked());
+
while (!events.empty()) {
auto p = events.begin();
ldout(cct,10) << " cancelled " << p->second->first << " -> " << p->first << dendl;
}
m_handle = dlopen(m_library.c_str(), RTLD_NOW | RTLD_NODELETE);
- assert(m_handle);
+ ceph_assert(m_handle);
}
OpTracker::~OpTracker() {
while (!sharded_in_flight_list.empty()) {
- assert((sharded_in_flight_list.back())->ops_in_flight_sharded.empty());
+ ceph_assert((sharded_in_flight_list.back())->ops_in_flight_sharded.empty());
delete sharded_in_flight_list.back();
sharded_in_flight_list.pop_back();
}
utime_t now = ceph_clock_now();
for (uint32_t i = 0; i < num_optracker_shards; i++) {
ShardedTrackingData* sdata = sharded_in_flight_list[i];
- assert(NULL != sdata);
+ ceph_assert(NULL != sdata);
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
for (auto& op : sdata->ops_in_flight_sharded) {
if (print_only_blocked && (now - op.get_initiated() <= complaint_time))
uint64_t current_seq = ++seq;
uint32_t shard_index = current_seq % num_optracker_shards;
ShardedTrackingData* sdata = sharded_in_flight_list[shard_index];
- assert(NULL != sdata);
+ ceph_assert(NULL != sdata);
{
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
sdata->ops_in_flight_sharded.push_back(*i);
void OpTracker::unregister_inflight_op(TrackedOp* const i)
{
// caller checks;
- assert(i->state);
+ ceph_assert(i->state);
uint32_t shard_index = i->seq % num_optracker_shards;
ShardedTrackingData* sdata = sharded_in_flight_list[shard_index];
- assert(NULL != sdata);
+ ceph_assert(NULL != sdata);
{
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
auto p = sdata->ops_in_flight_sharded.iterator_to(*i);
RWLock::RLocker l(lock);
for (const auto sdata : sharded_in_flight_list) {
- assert(sdata);
+ ceph_assert(sdata);
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
if (!sdata->ops_in_flight_sharded.empty()) {
utime_t oldest_op_tmp =
for (uint32_t iter = 0; iter < num_optracker_shards; iter++) {
ShardedTrackingData* sdata = sharded_in_flight_list[iter];
- assert(NULL != sdata);
+ ceph_assert(NULL != sdata);
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
for (auto& op : sdata->ops_in_flight_sharded) {
if (!visit(op))
for (uint32_t iter = 0; iter < num_optracker_shards; iter++) {
ShardedTrackingData* sdata = sharded_in_flight_list[iter];
- assert(NULL != sdata);
+ ceph_assert(NULL != sdata);
Mutex::Locker locker(sdata->ops_in_flight_lock_sharded);
for (auto& i : sdata->ops_in_flight_sharded) {
opsvc.create("OpHistorySvc");
}
~OpHistory() {
- assert(arrived.empty());
- assert(duration.empty());
- assert(slow_op.empty());
+ ceph_assert(arrived.empty());
+ ceph_assert(duration.empty());
+ ceph_assert(slow_op.empty());
}
void insert(const utime_t& now, TrackedOpRef op)
{
#include <boost/intrusive/rbtree.hpp>
#include <boost/intrusive/avl_set.hpp>
+#include "include/assert.h"
+
namespace bi = boost::intrusive;
template <typename T, typename S>
}
//Get the cost of the next item to dequeue
unsigned get_cost() const {
- assert(!empty());
+ ceph_assert(!empty());
return lp.begin()->cost;
}
T pop() {
- assert(!lp.empty());
+ ceph_assert(!lp.empty());
T ret = std::move(lp.begin()->item);
lp.erase_and_dispose(lp.begin(), DelItem<ListPair>());
return ret;
ret.first->insert(cost, std::move(item), front);
}
unsigned get_cost() const {
- assert(!empty());
+ ceph_assert(!empty());
return next->get_cost();
}
T pop() {
normal.insert(p, cl, cost, std::move(item), true);
}
T dequeue() override {
- assert(strict.size + normal.size > 0);
+ ceph_assert(strict.size + normal.size > 0);
if (!strict.empty()) {
return strict.pop(true);
}
ThreadPool::~ThreadPool()
{
- assert(_threads.empty());
+ ceph_assert(_threads.empty());
delete[] _conf_keys;
}
if (changed.count(_thread_num_option)) {
char *buf;
int r = conf.get_val(_thread_num_option.c_str(), &buf, -1);
- assert(r >= 0);
+ ceph_assert(r >= 0);
int v = atoi(buf);
free(buf);
if (v >= 0) {
void ThreadPool::start_threads()
{
- assert(_lock.is_locked());
+ ceph_assert(_lock.is_locked());
while (_threads.size() < _num_threads) {
WorkThread *wt = new WorkThread(this);
ldout(cct, 10) << "start_threads creating and starting " << wt << dendl;
void ThreadPool::join_old_threads()
{
- assert(_lock.is_locked());
+ ceph_assert(_lock.is_locked());
while (!_old_threads.empty()) {
ldout(cct, 10) << "join_old_threads joining and deleting " << _old_threads.front() << dendl;
_old_threads.front()->join();
{
ldout(cct,10) << "unpause" << dendl;
_lock.Lock();
- assert(_pause > 0);
+ ceph_assert(_pause > 0);
_pause--;
_cond.Signal();
_lock.Unlock();
void ShardedThreadPool::shardedthreadpool_worker(uint32_t thread_index)
{
- assert(wq != NULL);
+ ceph_assert(wq != NULL);
ldout(cct,10) << "worker start" << dendl;
std::stringstream ss;
void ShardedThreadPool::start_threads()
{
- assert(shardedpool_lock.is_locked());
+ ceph_assert(shardedpool_lock.is_locked());
int32_t thread_index = 0;
while (threads_shardedpool.size() < num_threads) {
{
ldout(cct,10) << "stop" << dendl;
stop_threads = true;
- assert(wq != NULL);
+ ceph_assert(wq != NULL);
wq->return_waiting_threads();
for (vector<WorkThreadSharded*>::iterator p = threads_shardedpool.begin();
p != threads_shardedpool.end();
ldout(cct,10) << "pause" << dendl;
shardedpool_lock.Lock();
pause_threads = true;
- assert(wq != NULL);
+ ceph_assert(wq != NULL);
wq->return_waiting_threads();
while (num_threads != num_paused){
wait_cond.Wait(shardedpool_lock);
ldout(cct,10) << "pause_new" << dendl;
shardedpool_lock.Lock();
pause_threads = true;
- assert(wq != NULL);
+ ceph_assert(wq != NULL);
wq->return_waiting_threads();
shardedpool_lock.Unlock();
ldout(cct,10) << "paused_new" << dendl;
ldout(cct,10) << "drain" << dendl;
shardedpool_lock.Lock();
drain_threads = true;
- assert(wq != NULL);
+ ceph_assert(wq != NULL);
wq->return_waiting_threads();
while (num_threads != num_drained) {
wait_cond.Wait(shardedpool_lock);
}
void _void_process(void *, TPHandle &handle) override {
_lock.Lock();
- assert(!to_process.empty());
+ ceph_assert(!to_process.empty());
U u = to_process.front();
to_process.pop_front();
_lock.Unlock();
void _void_process_finish(void *) override {
_lock.Lock();
- assert(!to_finish.empty());
+ ceph_assert(!to_finish.empty());
U u = to_finish.front();
to_finish.pop_front();
_lock.Unlock();
public:
~PointerWQ() override {
m_pool->remove_work_queue(this);
- assert(m_processing == 0);
+ ceph_assert(m_processing == 0);
}
void drain() {
{
m_pool->add_work_queue(this);
}
void _clear() override {
- assert(m_pool->_lock.is_locked());
+ ceph_assert(m_pool->_lock.is_locked());
m_items.clear();
}
bool _empty() override {
- assert(m_pool->_lock.is_locked());
+ ceph_assert(m_pool->_lock.is_locked());
return m_items.empty();
}
void *_void_dequeue() override {
- assert(m_pool->_lock.is_locked());
+ ceph_assert(m_pool->_lock.is_locked());
if (m_items.empty()) {
return NULL;
}
process(reinterpret_cast<T *>(item));
}
void _void_process_finish(void *item) override {
- assert(m_pool->_lock.is_locked());
- assert(m_processing > 0);
+ ceph_assert(m_pool->_lock.is_locked());
+ ceph_assert(m_processing > 0);
--m_processing;
}
}
T *front() {
- assert(m_pool->_lock.is_locked());
+ ceph_assert(m_pool->_lock.is_locked());
if (m_items.empty()) {
return NULL;
}
i++;
for (i++; i < work_queues.size(); i++)
work_queues[i-1] = work_queues[i];
- assert(i == work_queues.size());
+ ceph_assert(i == work_queues.size());
work_queues.resize(i-1);
}
return _queue.empty();
}
GenContext<ThreadPool::TPHandle&> *_dequeue() override {
- assert(!_queue.empty());
+ ceph_assert(!_queue.empty());
GenContext<ThreadPool::TPHandle&> *c = _queue.front();
_queue.pop_front();
return c;
namespace ceph {
static CephContext *g_assert_context = NULL;
- /* If you register an assert context, assert() will try to lock the dout
+ /* If you register an assert context, ceph_assert() will try to lock the dout
* stream of that context before starting an assert. This is nice because the
* output looks better. Your assert will not be interleaved with other dout
* statements.
*/
void register_assert_context(CephContext *cct)
{
- assert(!g_assert_context);
+ ceph_assert(!g_assert_context);
g_assert_context = cct;
}
char buf[8096];
snprintf(buf, sizeof(buf),
"%s: In function '%s' thread %llx time %s\n"
- "%s: %d: FAILED assert(%s)\n",
+ "%s: %d: FAILED ceph_assert(%s)\n",
file, func, (unsigned long long)pthread_self(), tss.str().c_str(),
file, line, assertion);
dout_emergency(buf);
BufAppender ba(buf, sizeof(buf));
BackTrace *bt = new BackTrace(1);
ba.printf("%s: In function '%s' thread %llx time %s\n"
- "%s: %d: FAILED assert(%s)\n",
+ "%s: %d: FAILED ceph_assert(%s)\n",
file, func, (unsigned long long)pthread_self(), tss.str().c_str(),
file, line, assertion);
ba.printf("Assertion details: ");
{
char buf[8096];
snprintf(buf, sizeof(buf),
- "WARNING: assert(%s) at: %s: %d: %s()\n",
+ "WARNING: ceph_assert(%s) at: %s: %d: %s()\n",
assertion, file, line, func);
dout_emergency(buf);
}
#include <boost/intrusive_ptr.hpp>
#include <boost/intrusive/list.hpp>
+#include "include/assert.h"
+
#include "common/async/completion.h"
namespace ceph::async::detail {
inline SharedMutexImpl::~SharedMutexImpl()
{
- assert(state == Unlocked);
- assert(shared_queue.empty());
- assert(exclusive_queue.empty());
+ ceph_assert(state == Unlocked);
+ ceph_assert(shared_queue.empty());
+ ceph_assert(exclusive_queue.empty());
}
template <typename Mutex, typename CompletionToken>
RequestList granted;
{
std::lock_guard lock{mutex};
- assert(state == Exclusive);
+ ceph_assert(state == Exclusive);
if (!exclusive_queue.empty()) {
// grant next exclusive lock
inline void SharedMutexImpl::unlock_shared()
{
std::lock_guard lock{mutex};
- assert(state != Unlocked && state <= MaxShared);
+ ceph_assert(state != Unlocked && state <= MaxShared);
if (state == 1 && !exclusive_queue.empty()) {
// grant next exclusive lock
#include <stdexcept>
#include <vector>
+#include "include/assert.h"
+
// A vector that leverages pre-allocated stack-based array to achieve better
// performance for array with small amount of items.
//
}
difference_type operator-(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ - other.index_;
}
// -- Reference
reference operator*() {
- assert(vect_->size() >= index_);
+ ceph_assert(vect_->size() >= index_);
return (*vect_)[index_];
}
const_reference operator*() const {
- assert(vect_->size() >= index_);
+ ceph_assert(vect_->size() >= index_);
return (*vect_)[index_];
}
pointer operator->() {
- assert(vect_->size() >= index_);
+ ceph_assert(vect_->size() >= index_);
return &(*vect_)[index_];
}
const_pointer operator->() const {
- assert(vect_->size() >= index_);
+ ceph_assert(vect_->size() >= index_);
return &(*vect_)[index_];
}
// -- Logical Operators
bool operator==(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ == other.index_;
}
bool operator!=(const self_type& other) const { return !(*this == other); }
bool operator>(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ > other.index_;
}
bool operator<(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ < other.index_;
}
bool operator>=(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ >= other.index_;
}
bool operator<=(const self_type& other) const {
- assert(vect_ == other.vect_);
+ ceph_assert(vect_ == other.vect_);
return index_ <= other.index_;
}
bool empty() const { return size() == 0; }
const_reference operator[](size_type n) const {
- assert(n < size());
+ ceph_assert(n < size());
return n < kSize ? values_[n] : vect_[n - kSize];
}
reference operator[](size_type n) {
- assert(n < size());
+ ceph_assert(n < size());
return n < kSize ? values_[n] : vect_[n - kSize];
}
const_reference at(size_type n) const {
- assert(n < size());
+ ceph_assert(n < size());
return (*this)[n];
}
reference at(size_type n) {
- assert(n < size());
+ ceph_assert(n < size());
return (*this)[n];
}
reference front() {
- assert(!empty());
+ ceph_assert(!empty());
return *begin();
}
const_reference front() const {
- assert(!empty());
+ ceph_assert(!empty());
return *begin();
}
reference back() {
- assert(!empty());
+ ceph_assert(!empty());
return *(end() - 1);
}
const_reference back() const {
- assert(!empty());
+ ceph_assert(!empty());
return *(end() - 1);
}
}
void pop_back() {
- assert(!empty());
+ ceph_assert(!empty());
if (!vect_.empty()) {
vect_.pop_back();
} else {
*out << "(" << r << ")";
}
} else {
- assert(f != NULL);
+ ceph_assert(f != NULL);
if (dump_bit_val) {
f->dump_stream("bit_flag") << func(r)
<< "(" << r << ")";
uint64_t index;
compute_index(m_offset, &index, &m_shift);
- assert(index == m_index || index == m_index + 1);
+ ceph_assert(index == m_index || index == m_index + 1);
if (index > m_index) {
m_index = index;
++m_data_iterator;
template <uint8_t _b>
void BitVector<_b>::encode_data(bufferlist& bl, uint64_t byte_offset,
uint64_t byte_length) const {
- assert(byte_offset % BLOCK_SIZE == 0);
- assert(byte_offset + byte_length == m_data.length() ||
+ ceph_assert(byte_offset % BLOCK_SIZE == 0);
+ ceph_assert(byte_offset + byte_length == m_data.length() ||
byte_length % BLOCK_SIZE == 0);
uint64_t end_offset = byte_offset + byte_length;
template <uint8_t _b>
void BitVector<_b>::decode_data(bufferlist::const_iterator& it, uint64_t byte_offset) {
- assert(byte_offset % BLOCK_SIZE == 0);
+ ceph_assert(byte_offset % BLOCK_SIZE == 0);
if (it.end()) {
return;
}
tail.substr_of(m_data, end_offset, m_data.length() - end_offset);
data.append(tail);
}
- assert(data.length() == m_data.length());
+ ceph_assert(data.length() == m_data.length());
data.swap(m_data);
}
uint64_t *byte_offset,
uint64_t *byte_length) const {
// read BLOCK_SIZE-aligned chunks
- assert(length > 0 && offset + length <= m_size);
+ ceph_assert(length > 0 && offset + length <= m_size);
uint64_t shift;
compute_index(offset, byte_offset, &shift);
*byte_offset -= (*byte_offset % BLOCK_SIZE);
uint64_t end_offset;
compute_index(offset + length - 1, &end_offset, &shift);
end_offset += (BLOCK_SIZE - (end_offset % BLOCK_SIZE));
- assert(*byte_offset <= end_offset);
+ ceph_assert(*byte_offset <= end_offset);
*byte_length = end_offset - *byte_offset;
if (*byte_offset + *byte_length > m_data.length()) {
target_element_count_(predicted_inserted_element_count),
random_seed_((random_seed) ? random_seed : 0xA5A5A5A5)
{
- assert(false_positive_probability > 0.0);
+ ceph_assert(false_positive_probability > 0.0);
find_optimal_parameters(predicted_inserted_element_count, false_positive_probability,
&salt_count_, &table_size_);
init();
* @param val integer value to insert
*/
inline void insert(uint32_t val) {
- assert(bit_table_);
+ ceph_assert(bit_table_);
std::size_t bit_index = 0;
std::size_t bit = 0;
for (std::size_t i = 0; i < salt_.size(); ++i)
inline void insert(const unsigned char* key_begin, const std::size_t& length)
{
- assert(bit_table_);
+ ceph_assert(bit_table_);
std::size_t bit_index = 0;
std::size_t bit = 0;
for (std::size_t i = 0; i < salt_.size(); ++i)
sorted.assign(const_pointer_iterator{counters.cbegin()},
const_pointer_iterator{counters.cend()});
// entire range is unsorted
- assert(sorted_position == sorted.begin());
+ ceph_assert(sorted_position == sorted.begin());
}
const size_t sorted_count = get_num_sorted();
#include <sys/uio.h>
+#include "include/assert.h"
#include "include/types.h"
#include "include/buffer_raw.h"
#include "include/compat.h"
raw_posix_aligned(unsigned l, unsigned _align) : raw(l) {
align = _align;
- assert((align >= sizeof(void *)) && (align & (align - 1)) == 0);
+ ceph_assert((align >= sizeof(void *)) && (align & (align - 1)) == 0);
#ifdef DARWIN
data = (char *) valloc(len);
#else
//cout << "hack aligned " << (unsigned)data
//<< " in raw " << (unsigned)realdata
//<< " off " << off << std::endl;
- assert(((unsigned)data & (align-1)) == 0);
+ ceph_assert(((unsigned)data & (align-1)) == 0);
}
~raw_hack_aligned() {
delete[] realdata;
}
int zero_copy_to_fd(int fd, loff_t *offset) override {
- assert(!source_consumed);
+ ceph_assert(!source_consumed);
int flags = SPLICE_F_NONBLOCK;
ssize_t r = safe_splice_exact(pipefds[0], NULL, fd, offset, len, flags);
if (r < 0) {
int tmpfd[2];
int r;
- assert(!source_consumed);
- assert(fds[0] >= 0);
+ ceph_assert(!source_consumed);
+ ceph_assert(fds[0] >= 0);
if (::pipe(tmpfd) == -1) {
r = -errno;
buffer::ptr::ptr(const ptr& p, unsigned o, unsigned l)
: _raw(p._raw), _off(p._off + o), _len(l)
{
- assert(o+l <= p._len);
- assert(_raw);
+ ceph_assert(o+l <= p._len);
+ ceph_assert(_raw);
_raw->nref++;
bdout << "ptr " << this << " get " << _raw << bendl;
}
}
const char *buffer::ptr::c_str() const {
- assert(_raw);
+ ceph_assert(_raw);
if (buffer_track_c_str)
buffer_c_str_accesses++;
return _raw->get_data() + _off;
}
char *buffer::ptr::c_str() {
- assert(_raw);
+ ceph_assert(_raw);
if (buffer_track_c_str)
buffer_c_str_accesses++;
return _raw->get_data() + _off;
}
const char *buffer::ptr::end_c_str() const {
- assert(_raw);
+ ceph_assert(_raw);
if (buffer_track_c_str)
buffer_c_str_accesses++;
return _raw->get_data() + _off + _len;
}
char *buffer::ptr::end_c_str() {
- assert(_raw);
+ ceph_assert(_raw);
if (buffer_track_c_str)
buffer_c_str_accesses++;
return _raw->get_data() + _off + _len;
}
const char& buffer::ptr::operator[](unsigned n) const
{
- assert(_raw);
- assert(n < _len);
+ ceph_assert(_raw);
+ ceph_assert(n < _len);
return _raw->get_data()[_off + n];
}
char& buffer::ptr::operator[](unsigned n)
{
- assert(_raw);
- assert(n < _len);
+ ceph_assert(_raw);
+ ceph_assert(n < _len);
return _raw->get_data()[_off + n];
}
- const char *buffer::ptr::raw_c_str() const { assert(_raw); return _raw->data; }
- unsigned buffer::ptr::raw_length() const { assert(_raw); return _raw->len; }
- int buffer::ptr::raw_nref() const { assert(_raw); return _raw->nref; }
+ const char *buffer::ptr::raw_c_str() const { ceph_assert(_raw); return _raw->data; }
+ unsigned buffer::ptr::raw_length() const { ceph_assert(_raw); return _raw->len; }
+ int buffer::ptr::raw_nref() const { ceph_assert(_raw); return _raw->nref; }
void buffer::ptr::copy_out(unsigned o, unsigned l, char *dest) const {
- assert(_raw);
+ ceph_assert(_raw);
if (o+l > _len)
throw end_of_buffer();
char* src = _raw->data + _off + o;
unsigned buffer::ptr::append(char c)
{
- assert(_raw);
- assert(1 <= unused_tail_length());
+ ceph_assert(_raw);
+ ceph_assert(1 <= unused_tail_length());
char* ptr = _raw->data + _off + _len;
*ptr = c;
_len++;
unsigned buffer::ptr::append(const char *p, unsigned l)
{
- assert(_raw);
- assert(l <= unused_tail_length());
+ ceph_assert(_raw);
+ ceph_assert(l <= unused_tail_length());
char* c = _raw->data + _off + _len;
maybe_inline_memcpy(c, p, l, 32);
_len += l;
unsigned buffer::ptr::append_zeros(unsigned l)
{
- assert(_raw);
- assert(l <= unused_tail_length());
+ ceph_assert(_raw);
+ ceph_assert(l <= unused_tail_length());
char* c = _raw->data + _off + _len;
memset(c, 0, l);
_len += l;
void buffer::ptr::copy_in(unsigned o, unsigned l, const char *src, bool crc_reset)
{
- assert(_raw);
- assert(o <= _len);
- assert(o+l <= _len);
+ ceph_assert(_raw);
+ ceph_assert(o <= _len);
+ ceph_assert(o+l <= _len);
char* dest = _raw->data + _off + o;
if (crc_reset)
_raw->invalidate_crc();
void buffer::ptr::zero(unsigned o, unsigned l, bool crc_reset)
{
- assert(o+l <= _len);
+ ceph_assert(o+l <= _len);
if (crc_reset)
_raw->invalidate_crc();
memset(c_str()+o, 0, l);
off -= d;
o += d;
} else if (off > 0) {
- assert(p != ls->begin());
+ ceph_assert(p != ls->begin());
p--;
p_off = p->length();
} else {
while (len > 0) {
if (p == ls->end())
throw end_of_buffer();
- assert(p->length() > 0);
+ ceph_assert(p->length() > 0);
unsigned howmuch = p->length() - p_off;
if (len < howmuch) howmuch = len;
}
if (p == ls->end())
throw end_of_buffer();
- assert(p->length() > 0);
+ ceph_assert(p->length() > 0);
dest = create(len);
copy(len, dest.c_str());
}
}
if (p == ls->end())
throw end_of_buffer();
- assert(p->length() > 0);
+ ceph_assert(p->length() > 0);
unsigned howmuch = p->length() - p_off;
if (howmuch < len) {
dest = create(len);
while (1) {
if (p == ls->end())
return;
- assert(p->length() > 0);
+ ceph_assert(p->length() > 0);
unsigned howmuch = p->length() - p_off;
const char *c_str = p->c_str();
++b;
}
}
- assert(b == other._buffers.end());
+ ceph_assert(b == other._buffers.end());
return true;
}
void buffer::list::zero(unsigned o, unsigned l)
{
- assert(o+l <= _len);
+ ceph_assert(o+l <= _len);
unsigned p = 0;
for (std::list<ptr>::iterator it = _buffers.begin();
it != _buffers.end();
void buffer::list::append(const ptr& bp, unsigned off, unsigned len)
{
- assert(len+off <= bp.length());
+ ceph_assert(len+off <= bp.length());
if (!_buffers.empty()) {
ptr &l = _buffers.back();
if (l.get_raw() == bp.get_raw() &&
} while (curbuf != _buffers.end() && l > 0);
- assert(l == 0);
+ ceph_assert(l == 0);
tmp.rebuild();
_buffers.insert(curbuf, tmp._buffers.front());
off -= (*curbuf).length();
++curbuf;
}
- assert(len == 0 || curbuf != other._buffers.end());
+ ceph_assert(len == 0 || curbuf != other._buffers.end());
while (len > 0) {
// partial?
if (off >= length())
throw end_of_buffer();
- assert(len > 0);
+ ceph_assert(len > 0);
//cout << "splice off " << off << " len " << len << " ... mylen = " << length() << std::endl;
// skip off
std::list<ptr>::iterator curbuf = _buffers.begin();
while (off > 0) {
- assert(curbuf != _buffers.end());
+ ceph_assert(curbuf != _buffers.end());
if (off >= (*curbuf).length()) {
// skip this buffer
//cout << "off = " << off << " skipping over " << *curbuf << std::endl;
hexdump(oss);
throw buffer::malformed_input(oss.str().c_str());
}
- assert(l <= (int)bp.length());
+ ceph_assert(l <= (int)bp.length());
bp.set_length(l);
push_back(std::move(bp));
}
"dump_mempools",
this,
"get mempool stats");
- assert(r == 0);
+ ceph_assert(r == 0);
}
~MempoolObs() override {
cct->_conf.remove_observer(this);
lgeneric_dout(this, 1) << "do_command '" << command << "' '"
<< ss.str() << dendl;
if (command == "assert" && _conf->debug_asok_assert_abort) {
- assert(0 == "assert");
+ ceph_assert(0 == "assert");
}
if (command == "abort" && _conf->debug_asok_assert_abort) {
abort();
_log->reopen_log_file();
}
else {
- assert(0 == "registered under wrong command?");
+ ceph_assert(0 == "registered under wrong command?");
}
f->close_section();
}
delete _crypto_none;
delete _crypto_aes;
if (_crypto_inited > 0) {
- assert(_crypto_inited == 1); // or else someone explicitly did
+ ceph_assert(_crypto_inited == 1); // or else someone explicitly did
// init but not shutdown
shutdown_crypto();
}
PerfCounters *perf_tmp = plb.create_perf_counters();
std::unique_lock<ceph::spinlock> lg(_cct_perf_lock);
- assert(_cct_perf == NULL);
+ ceph_assert(_cct_perf == NULL);
_cct_perf = perf_tmp;
lg.unlock();
SECMOD_DB, &init_params, flags);
}
pthread_mutex_unlock(&crypto_init_mutex);
- assert(crypto_context != NULL);
+ ceph_assert(crypto_context != NULL);
}
void ceph::crypto::shutdown(bool shared)
{
pthread_mutex_lock(&crypto_init_mutex);
- assert(crypto_refs > 0);
+ ceph_assert(crypto_refs > 0);
if (--crypto_refs == 0) {
NSS_ShutdownContext(crypto_context);
if (!shared) {
return;
suspended = false;
- assert(!thread.joinable());
+ ceph_assert(!thread.joinable());
thread = std::thread(&timer::timer_thread, this);
}
void cmdmap_dump(const cmdmap_t &cmdmap, Formatter *f)
{
- assert(f != nullptr);
+ ceph_assert(f != nullptr);
class dump_visitor : public boost::static_visitor<void>
{
}
} else if (type == "CephChoices") {
auto choices = desc.find("strings");
- assert(choices != end(desc));
+ ceph_assert(choices != end(desc));
auto strings = choices->second;
if (find_first_in(strings, "|", [=](auto choice) {
return (value == choice);
if (arg_desc.empty()) {
return false;
}
- assert(arg_desc.count("name"));
- assert(arg_desc.count("type"));
+ ceph_assert(arg_desc.count("name"));
+ ceph_assert(arg_desc.count("type"));
auto name = arg_desc["name"];
auto type = arg_desc["type"];
if (arg_desc.count("n")) {
--(o->lru_refcnt);
/* assertions that o state has not changed across
* relock */
- assert(o->lru_refcnt == SENTINEL_REFCNT);
- assert(o->lru_flags & FLAG_INLRU);
+ ceph_assert(o->lru_refcnt == SENTINEL_REFCNT);
+ ceph_assert(o->lru_flags & FLAG_INLRU);
Object::Queue::iterator it =
Object::Queue::s_iterator_to(*o);
lane.q.erase(it);
LRU(int lanes, uint32_t _hiwat)
: n_lanes(lanes), evict_lane(0), lane_hiwat(_hiwat)
{
- assert(n_lanes > 0);
+ ceph_assert(n_lanes > 0);
qlane = new Lane[n_lanes];
}
}
TreeX(int n_part=1, int csz=127) : n_part(n_part), csz(csz) {
- assert(n_part > 0);
+ ceph_assert(n_part > 0);
part = new Partition[n_part];
for (int ix = 0; ix < n_part; ++ix) {
Partition& p = part[ix];
void condition_variable_debug::wait(std::unique_lock<mutex_debug>& lock)
{
// make sure this cond is used with one mutex only
- assert(waiter_mutex == nullptr ||
+ ceph_assert(waiter_mutex == nullptr ||
waiter_mutex == lock.mutex());
waiter_mutex = lock.mutex();
- assert(waiter_mutex->is_locked());
+ ceph_assert(waiter_mutex->is_locked());
waiter_mutex->_pre_unlock();
if (int r = pthread_cond_wait(&cond, waiter_mutex->native_handle());
r != 0) {
void condition_variable_debug::notify_one()
{
// make sure signaler is holding the waiter's lock.
- assert(waiter_mutex == nullptr ||
+ ceph_assert(waiter_mutex == nullptr ||
waiter_mutex->is_locked());
if (int r = pthread_cond_signal(&cond); r != 0) {
throw std::system_error(r, std::generic_category());
void condition_variable_debug::notify_all(bool sloppy)
{
// make sure signaler is holding the waiter's lock.
- assert(waiter_mutex == NULL ||
+ ceph_assert(waiter_mutex == NULL ||
waiter_mutex->is_locked());
if (int r = pthread_cond_broadcast(&cond); r != 0 && !sloppy) {
throw std::system_error(r, std::generic_category());
timespec* ts)
{
// make sure this cond is used with one mutex only
- assert(waiter_mutex == nullptr ||
+ ceph_assert(waiter_mutex == nullptr ||
waiter_mutex == mutex);
waiter_mutex = mutex;
- assert(waiter_mutex->is_locked());
+ ceph_assert(waiter_mutex->is_locked());
waiter_mutex->_pre_unlock();
int r = pthread_cond_timedwait(&cond, waiter_mutex->native_handle(), ts);
const string& name, const std::string& val)
{
const Option *o = find_option(name);
- assert(o);
+ ceph_assert(o);
string err;
int r = _set_val(values, tracker, val, *o, CONF_DEFAULT, &err);
- assert(r >= 0);
+ ceph_assert(r >= 0);
}
int md_config_t::set_mon_vals(CephContext *cct,
for (auto name : { "erasure_code_dir", "plugin_dir", "osd_class_dir" }) {
std::string err;
const Option *o = find_option(name);
- assert(o);
+ ceph_assert(o);
_set_val(values, tracker, dir, *o, CONF_ENV, &err);
}
}
}
if (ret < 0 || !error_message.empty()) {
- assert(!option_name.empty());
+ ceph_assert(!option_name.empty());
if (oss) {
*oss << "Parse error setting " << option_name << " to '"
<< val << "' using injectargs";
if (ret != 0) {
std::cerr << "set_val_or_die(" << key << "): " << err.str();
}
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
int md_config_t::set_val(ConfigValues& values,
string out;
decltype(pos) last_pos = 0;
while (pos != std::string::npos) {
- assert((*str)[pos] == '$');
+ ceph_assert((*str)[pos] == '$');
if (pos > last_pos) {
out += str->substr(last_pos, pos - last_pos);
}
++o;
}
}
- assert(found_obs);
+ ceph_assert(found_obs);
}
template<class ConfigObs>
class _bad_endl_use_dendl_t { public: _bad_endl_use_dendl_t(int) {} };
static const _bad_endl_use_dendl_t endl = 0;
inline std::ostream& operator<<(std::ostream& out, _bad_endl_use_dendl_t) {
- assert(0 && "you are using the wrong endl.. use std::endl or dendl");
+ ceph_assert(0 && "you are using the wrong endl.. use std::endl or dendl");
return out;
}
#include <sys/wait.h>
#include <sys/types.h>
#include <ostream>
+
+#include "include/assert.h"
#include "common/errno.h"
static void _fork_function_dummy_sighandler(int sig) {}
// just wait
int status;
while (waitpid(forker_pid, &status, 0) == -1) {
- assert(errno == EINTR);
+ ceph_assert(errno == EINTR);
}
if (WIFSIGNALED(status)) {
errstr << ": got signal: " << WTERMSIG(status) << "\n";
using ceph::encode;
if ((features & CEPH_FEATURE_FS_FILE_LAYOUT_V2) == 0) {
ceph_file_layout fl;
- assert((stripe_unit & 0xff) == 0); // first byte must be 0
+ ceph_assert((stripe_unit & 0xff) == 0); // first byte must be 0
to_legacy(&fl);
encode(fl, bl);
return;
encode(max, bl);
encode(nspace, bl);
encode(pool, bl);
- assert(!max || (*this == hobject_t(hobject_t::get_max())));
+ ceph_assert(!max || (*this == hobject_t(hobject_t::get_max())));
ENCODE_FINISH(bl);
}
!max &&
oid.name.empty()) {
pool = INT64_MIN;
- assert(is_min());
+ ceph_assert(is_min());
}
// for compatibility with some earlier verisons which might encoded
!hobj.max &&
hobj.oid.name.empty()) {
hobj.pool = INT64_MIN;
- assert(hobj.is_min());
+ ceph_assert(hobj.is_min());
}
}
if (struct_v >= 5) {
}
bool is_max() const {
- assert(!max || (*this == hobject_t(hobject_t::get_max())));
+ ceph_assert(!max || (*this == hobject_t(hobject_t::get_max())));
return max;
}
bool is_min() const {
// filestore nibble-based key
uint32_t get_nibblewise_key_u32() const {
- assert(!max);
+ ceph_assert(!max);
return nibblewise_key_cache;
}
uint64_t get_nibblewise_key() const {
// newer bit-reversed key
uint32_t get_bitwise_key_u32() const {
- assert(!max);
+ ceph_assert(!max);
return hash_reverse_bits;
}
uint64_t get_bitwise_key() const {
std::make_pair(
off,
std::make_pair(len, std::move(n))));
- assert(p.second);
+ ceph_assert(p.second);
niter = p.first;
}
}
std::make_pair(
off,
std::make_pair(len, std::move(n))));
- assert(p.second);
+ ceph_assert(p.second);
}
}
public:
m.insert(to_insert.begin(), to_insert.end());
}
void insert(K off, K len, V &&v) {
- assert(len > 0);
- assert(len == s.length(v));
+ ceph_assert(len > 0);
+ ceph_assert(len == s.length(v));
erase(off, len);
auto p = m.insert(make_pair(off, std::make_pair(len, std::forward<V>(v))));
- assert(p.second);
+ ceph_assert(p.second);
try_merge(p.first);
}
void insert(interval_map &&other) {
}
}
void insert(K off, K len, const V &v) {
- assert(len > 0);
- assert(len == s.length(v));
+ ceph_assert(len > 0);
+ ceph_assert(len == s.length(v));
erase(off, len);
auto p = m.insert(make_pair(off, std::make_pair(len, v)));
- assert(p.second);
+ ceph_assert(p.second);
try_merge(p.first);
}
void insert(const interval_map &other) {
if (id < 0) {
//id = lockdep_register(name);
- assert(id == -1);
+ ceph_assert(id == -1);
return id;
}
while (entries.size() > max) {
typename std::list<K>::reverse_iterator riter = entries_lru.rbegin();
iter = entries.find(*riter);
- // assert(iter != entries.end());
+ // ceph_assert(iter != entries.end());
entries.erase(iter);
entries_lru.pop_back();
}
}
const std::pair<cost_t, T>& front() const {
- assert(!(q.empty()));
- assert(cur != q.end());
+ ceph_assert(!(q.empty()));
+ ceph_assert(cur != q.end());
return cur->second.front();
}
std::pair<cost_t, T>& front() {
- assert(!(q.empty()));
- assert(cur != q.end());
+ ceph_assert(!(q.empty()));
+ ceph_assert(cur != q.end());
return cur->second.front();
}
void pop_front() {
- assert(!(q.empty()));
- assert(cur != q.end());
+ ceph_assert(!(q.empty()));
+ ceph_assert(cur != q.end());
cur->second.pop_front();
if (cur->second.empty()) {
auto i = cur;
}
unsigned length() const {
- assert(size >= 0);
+ ceph_assert(size >= 0);
return (unsigned)size;
}
total += queue_front.size();
total += queue.request_count();
for (auto i = high_queue.cbegin(); i != high_queue.cend(); ++i) {
- assert(i->second.length());
+ ceph_assert(i->second.length());
total += i->second.length();
}
return total;
}
T dequeue() override final {
- assert(!empty());
+ ceph_assert(!empty());
if (!high_queue.empty()) {
T ret = std::move(high_queue.rbegin()->second.front().second);
}
auto pr = queue.pull_request();
- assert(pr.is_retn());
+ ceph_assert(pr.is_retn());
auto& retn = pr.get_retn();
return std::move(*(retn.request));
}
for (size_t i = 0; i < num_shards; ++i) {
result += shard[i].bytes;
}
- assert(result >= 0);
+ ceph_assert(result >= 0);
return (size_t) result;
}
for (size_t i = 0; i < num_shards; ++i) {
result += shard[i].items;
}
- assert(result >= 0);
+ ceph_assert(result >= 0);
return (size_t) result;
}
}
mutex_debugging_base::~mutex_debugging_base() {
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
if (cct && logger) {
cct->get_perfcounters_collection()->remove(logger);
delete logger;
void _post_lock() {
if (!impl->recursive)
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
locked_by = std::this_thread::get_id();
nlock++;
}
void _pre_unlock() {
- assert(nlock > 0);
+ ceph_assert(nlock > 0);
--nlock;
- assert(locked_by == std::this_thread::get_id());
+ ceph_assert(locked_by == std::this_thread::get_id());
if (!impl->recursive)
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
if (nlock == 0)
locked_by = std::thread::id();
}
r = pthread_mutexattr_settype(&a, PTHREAD_MUTEX_RECURSIVE);
else
r = pthread_mutexattr_settype(&a, PTHREAD_MUTEX_ERRORCHECK);
- assert(r == 0);
+ ceph_assert(r == 0);
r = pthread_mutex_init(&m, &a);
- assert(r == 0);
+ ceph_assert(r == 0);
}
// Mutex is Destructible
~mutex_debug_impl() {
int r = pthread_mutex_destroy(&m);
- assert(r == 0);
+ ceph_assert(r == 0);
}
// Mutex concept is non-Copyable
r == EBUSY)) {
throw std::system_error(r, std::generic_category());
}
- assert(r == 0);
+ ceph_assert(r == 0);
}
void unlock_impl() noexcept {
int r = pthread_mutex_unlock(&m);
- assert(r == 0);
+ ceph_assert(r == 0);
}
bool try_lock_impl() {
char name[512];
int n = snprintf(&name[0], sizeof(name), BENCH_OBJ_NAME.c_str(), cached_hostname, cached_pid, objnum);
- assert(n > 0 && n < (int)sizeof(name));
+ ceph_assert(n > 0 && n < (int)sizeof(name));
return std::string(&name[0], (size_t)n);
}
}
perf_counters_set_t::iterator i = m_loggers.find(l);
- assert(i != m_loggers.end());
+ ceph_assert(i != m_loggers.end());
m_loggers.erase(i);
}
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_U64))
return;
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- assert(!(data.type & PERFCOUNTER_LONGRUNAVG));
+ ceph_assert(!(data.type & PERFCOUNTER_LONGRUNAVG));
if (!(data.type & PERFCOUNTER_U64))
return;
data.u64 -= amt;
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_U64))
return;
if (!m_cct->_conf->perf)
return 0;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_U64))
return 0;
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_TIME))
return;
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_TIME))
return;
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_TIME))
return;
if (!m_cct->_conf->perf)
return utime_t();
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_TIME))
return utime_t();
if (!m_cct->_conf->perf)
return;
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- assert(data.type == (PERFCOUNTER_HISTOGRAM | PERFCOUNTER_COUNTER | PERFCOUNTER_U64));
- assert(data.histogram);
+ ceph_assert(data.type == (PERFCOUNTER_HISTOGRAM | PERFCOUNTER_COUNTER | PERFCOUNTER_U64));
+ ceph_assert(data.histogram);
data.histogram->inc(x, y);
}
if (!m_cct->_conf->perf)
return make_pair(0, 0);
- assert(idx > m_lower_bound);
- assert(idx < m_upper_bound);
+ ceph_assert(idx > m_lower_bound);
+ ceph_assert(idx < m_upper_bound);
const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
if (!(data.type & PERFCOUNTER_TIME))
return make_pair(0, 0);
}
f->close_section();
} else if (d->type & PERFCOUNTER_HISTOGRAM) {
- assert(d->type == (PERFCOUNTER_HISTOGRAM | PERFCOUNTER_COUNTER | PERFCOUNTER_U64));
- assert(d->histogram);
+ ceph_assert(d->type == (PERFCOUNTER_HISTOGRAM | PERFCOUNTER_COUNTER | PERFCOUNTER_U64));
+ ceph_assert(d->histogram);
f->open_object_section(d->name);
d->histogram->dump_formatted(f);
f->close_section();
const char *description, const char *nick, int prio, int ty, int unit,
unique_ptr<PerfHistogram<>> histogram)
{
- assert(idx > m_perf_counters->m_lower_bound);
- assert(idx < m_perf_counters->m_upper_bound);
+ ceph_assert(idx > m_perf_counters->m_lower_bound);
+ ceph_assert(idx < m_perf_counters->m_upper_bound);
PerfCounters::perf_counter_data_vec_t &vec(m_perf_counters->m_data);
PerfCounters::perf_counter_data_any_d
&data(vec[idx - m_perf_counters->m_lower_bound - 1]);
- assert(data.type == PERFCOUNTER_NONE);
+ ceph_assert(data.type == PERFCOUNTER_NONE);
data.name = name;
data.description = description;
// nick must be <= 4 chars
if (nick) {
- assert(strlen(nick) <= 4);
+ ceph_assert(strlen(nick) <= 4);
}
data.nick = nick;
data.prio = prio ? prio : prio_default;
PerfCounters::perf_counter_data_vec_t::const_iterator d = m_perf_counters->m_data.begin();
PerfCounters::perf_counter_data_vec_t::const_iterator d_end = m_perf_counters->m_data.end();
for (; d != d_end; ++d) {
- assert(d->type != PERFCOUNTER_NONE);
- assert(d->type & (PERFCOUNTER_U64 | PERFCOUNTER_TIME));
+ ceph_assert(d->type != PERFCOUNTER_NONE);
+ ceph_assert(d->type & (PERFCOUNTER_U64 | PERFCOUNTER_TIME));
}
PerfCounters *ret = m_perf_counters;
f->dump_string("scale_type", "log2");
break;
default:
- assert(false && "Invalid scale type");
+ ceph_assert(false && "Invalid scale type");
}
{
case PerfHistogramCommon::SCALE_LOG2:
return int64_t(1) << (i - 1);
}
- assert(false && "Invalid scale type");
+ ceph_assert(false && "Invalid scale type");
}
int64_t PerfHistogramCommon::get_bucket_for_axis(
}
return ac.m_buckets - 1;
}
- assert(false && "Invalid scale type");
+ ceph_assert(false && "Invalid scale type");
}
std::vector<std::pair<int64_t, int64_t>>
public:
/// Initialize new histogram object
PerfHistogram(std::initializer_list<axis_config_d> axes_config) {
- assert(axes_config.size() == DIM &&
- "Invalid number of axis configuration objects");
+ ceph_assert(axes_config.size() == DIM &&
+ "Invalid number of axis configuration objects");
int i = 0;
for (const auto &ac : axes_config) {
- assert(ac.m_buckets > 0 && "Must have at least one bucket on axis");
- assert(ac.m_quant_size > 0 &&
+ ceph_assert(ac.m_buckets > 0 && "Must have at least one bucket on axis");
+ ceph_assert(ac.m_quant_size > 0 &&
"Quantization unit must be non-zero positive integer value");
m_axes_config[i++] = ac;
static_assert(sizeof...(T) == DIM, "Incorrect number of arguments");
return get_raw_index_internal<0>(
[](int64_t bucket, const axis_config_d &ac) {
- assert(bucket >= 0 && "Bucket index can not be negative");
- assert(bucket < ac.m_buckets && "Bucket index too large");
+ ceph_assert(bucket >= 0 && "Bucket index can not be negative");
+ ceph_assert(bucket < ac.m_buckets && "Bucket index too large");
return bucket;
},
0, buckets...);
dump_weak_refs(*_dout);
*_dout << dendl;
if (cct->_conf.get_val<bool>("debug_asserts_on_shutdown")) {
- assert(weak_refs.empty());
+ ceph_assert(weak_refs.empty());
}
}
}
if (!found || !next)
return found;
next->first = r.first;
- assert(r.second);
+ ceph_assert(r.second);
next->second = *(r.second);
return found;
}
void shared_mutex_debug::_pre_unlock()
{
if (track) {
- assert(nlock > 0);
+ ceph_assert(nlock > 0);
--nlock;
- assert(locked_by == std::this_thread::get_id());
- assert(nlock == 0);
+ ceph_assert(locked_by == std::this_thread::get_id());
+ ceph_assert(nlock == 0);
locked_by = std::thread::id();
}
}
void shared_mutex_debug::_post_lock()
{
if (track) {
- assert(nlock == 0);
+ ceph_assert(nlock == 0);
locked_by = std::this_thread::get_id();
++nlock;
}
void shared_mutex_debug::_pre_unlock_shared()
{
if (track) {
- assert(nrlock > 0);
+ ceph_assert(nrlock > 0);
nrlock--;
}
}
}
}
int ret = pthread_sigmask(SIG_BLOCK, &sigset, old_sigset);
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
void restore_sigset(const sigset_t *old_sigset)
{
int ret = pthread_sigmask(SIG_SETMASK, old_sigset, NULL);
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
void unblock_all_signals(sigset_t *old_sigset)
sigfillset(&sigset);
sigdelset(&sigset, SIGKILL);
int ret = pthread_sigmask(SIG_UNBLOCK, &sigset, old_sigset);
- assert(ret == 0);
+ ceph_assert(ret == 0);
}
if (ptr)
put_with_id(ptr, id);
else
- assert(id == 0);
+ ceph_assert(id == 0);
}
void swap(TrackedIntPtr &other) {
T *optr = other.ptr;
void dump_services(Formatter* f, const map<string, list<int> >& services, const char* type)
{
- assert(f);
+ ceph_assert(f);
f->open_object_section(type);
for (map<string, list<int> >::const_iterator host = services.begin();
void dump_services(Formatter* f, const map<string, list<string> >& services, const char* type)
{
- assert(f);
+ ceph_assert(f);
f->open_object_section(type);
for (const auto& host : services) {
projects / ceph.git / commitdiff