int ret;
char *tok, *tmp_name;
- assert(name);
+ LTTNG_ASSERT(name);
tmp_name = strdup(name);
if (!tmp_name) {
*/
static uint64_t add_session_list(struct ltt_session *ls)
{
- assert(ls);
+ LTTNG_ASSERT(ls);
cds_list_add(&ls->list, <t_session_list.head);
return ltt_session_list.next_uuid++;
*/
static void del_session_list(struct ltt_session *ls)
{
- assert(ls);
+ LTTNG_ASSERT(ls);
cds_list_del(&ls->list);
}
{
int ret;
- assert(ls);
+ LTTNG_ASSERT(ls);
if (!ltt_sessions_ht_by_id) {
ret = ltt_sessions_ht_alloc();
}
/* Should always be present with ltt_sessions_ht_by_id. */
- assert(ltt_sessions_ht_by_name);
+ LTTNG_ASSERT(ltt_sessions_ht_by_name);
lttng_ht_node_init_u64(&ls->node, ls->id);
lttng_ht_add_unique_u64(ltt_sessions_ht_by_id, &ls->node);
goto end;
}
- assert(ltt_sessions_ht_by_name);
+ LTTNG_ASSERT(ltt_sessions_ht_by_name);
count = lttng_ht_get_count(ltt_sessions_ht_by_id);
- assert(count == lttng_ht_get_count(ltt_sessions_ht_by_name));
+ LTTNG_ASSERT(count == lttng_ht_get_count(ltt_sessions_ht_by_name));
end:
return count ? 0 : 1;
}
struct lttng_ht_iter iter;
int ret;
- assert(ls);
- assert(ltt_sessions_ht_by_id);
- assert(ltt_sessions_ht_by_name);
+ LTTNG_ASSERT(ls);
+ LTTNG_ASSERT(ltt_sessions_ht_by_id);
+ LTTNG_ASSERT(ltt_sessions_ht_by_name);
iter.iter.node = &ls->node.node;
ret = lttng_ht_del(ltt_sessions_ht_by_id, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
iter.iter.node = &ls->node_by_name.node;
ret = lttng_ht_del(ltt_sessions_ht_by_name, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
if (ltt_sessions_ht_empty()) {
DBG("Empty ltt_sessions_ht_by_id/name, destroying hast tables");
*/
void session_lock(struct ltt_session *session)
{
- assert(session);
+ LTTNG_ASSERT(session);
pthread_mutex_lock(&session->lock);
}
*/
void session_unlock(struct ltt_session *session)
{
- assert(session);
+ LTTNG_ASSERT(session);
pthread_mutex_unlock(&session->lock);
}
goto end;
}
chunk_status = lttng_trace_chunk_get_id(new_trace_chunk, &chunk_id);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+ LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
refs_to_acquire = 1;
refs_to_acquire += !!session->ust_session;
if (consumer_output_override) {
output = consumer_output_override;
} else {
- assert(session->ust_session || session->kernel_session);
+ LTTNG_ASSERT(session->ust_session || session->kernel_session);
output = session->ust_session ?
session->ust_session->consumer :
session->kernel_session->consumer;
struct ltt_session *session = container_of(ref, typeof(*session), ref);
const bool session_published = session->published;
- assert(!session->chunk_being_archived);
+ LTTNG_ASSERT(!session->chunk_being_archived);
usess = session->ust_session;
ksess = session->kernel_session;
* may cause the removal of the session from the session_list.
*/
ASSERT_LOCKED(ltt_session_list.lock);
- assert(session->ref.refcount);
+ LTTNG_ASSERT(session->ref.refcount);
urcu_ref_put(&session->ref, session_release);
}
*/
void session_destroy(struct ltt_session *session)
{
- assert(!session->destroyed);
+ LTTNG_ASSERT(!session->destroyed);
session->destroyed = true;
session_put(session);
}
{
struct ltt_session *iter;
- assert(name);
+ LTTNG_ASSERT(name);
ASSERT_LOCKED(ltt_session_list.lock);
DBG2("Trying to find session by name %s", name);
*/
bool session_access_ok(struct ltt_session *session, uid_t uid)
{
- assert(session);
+ LTTNG_ASSERT(session);
return (uid == session->uid) || uid == 0;
}
chunk_status = lttng_trace_chunk_get_id(
session->chunk_being_archived,
&chunk_id);
- assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
+ LTTNG_ASSERT(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK);
LTTNG_OPTIONAL_SET(&session->last_archived_chunk_id,
chunk_id);
lttng_trace_chunk_put(session->chunk_being_archived);