#include "common/index/ctf-index.h"
#define _LGPL_SOURCE
-#include <assert.h>
#include <poll.h>
#include <pthread.h>
#include <stdlib.h>
{
struct lttng_consumer_stream *null_stream = NULL;
- assert(pipe);
+ LTTNG_ASSERT(pipe);
(void) lttng_pipe_write(pipe, &null_stream, sizeof(null_stream));
}
{
struct lttng_consumer_stream *stream, *stmp;
- assert(channel);
+ LTTNG_ASSERT(channel);
/* Delete streams that might have been left in the stream list. */
cds_list_for_each_entry_safe(stream, stmp, &channel->streams.head,
struct lttng_ht_node_u64 *node;
struct lttng_consumer_stream *stream = NULL;
- assert(ht);
+ LTTNG_ASSERT(ht);
/* -1ULL keys are lookup failures */
if (key == (uint64_t) -1ULL) {
break;
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
goto end;
}
rcu_read_lock();
iter.iter.node = &channel->node.node;
ret = lttng_ht_del(the_consumer_data.channel_ht, &iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
iter.iter.node = &channel->channels_by_session_id_ht_node.node;
ret = lttng_ht_del(the_consumer_data.channels_by_session_id_ht,
&iter);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
rcu_read_unlock();
}
{
uint64_t netidx;
- assert(relayd);
+ LTTNG_ASSERT(relayd);
DBG("Cleaning up relayd object ID %"PRIu64, relayd->net_seq_idx);
*/
void consumer_flag_relayd_for_destroy(struct consumer_relayd_sock_pair *relayd)
{
- assert(relayd);
+ LTTNG_ASSERT(relayd);
/* Set destroy flag for this object */
uatomic_set(&relayd->destroy_flag, 1);
{
struct lttng_ht *ht = data_ht;
- assert(stream);
- assert(ht);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(ht);
DBG3("Adding consumer stream %" PRIu64, stream->key);
struct lttng_ht_node_u64 *node;
struct lttng_ht_iter iter;
- assert(relayd);
+ LTTNG_ASSERT(relayd);
lttng_ht_lookup(the_consumer_data.relayd_ht, &relayd->net_seq_idx,
&iter);
int ret = 0;
struct consumer_relayd_sock_pair *relayd;
- assert(stream);
- assert(stream->net_seq_idx != -1ULL);
- assert(path);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->net_seq_idx != -1ULL);
+ LTTNG_ASSERT(path);
/* The stream is not metadata. Get relayd reference if exists. */
rcu_read_lock();
int ret = 0;
struct consumer_relayd_sock_pair *relayd;
- assert(net_seq_idx != -1ULL);
+ LTTNG_ASSERT(net_seq_idx != -1ULL);
/* The stream is not metadata. Get relayd reference if exists. */
rcu_read_lock();
struct lttcomm_relayd_data_hdr data_hdr;
/* Safety net */
- assert(stream);
- assert(relayd);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(relayd);
/* Reset data header */
memset(&data_hdr, 0, sizeof(data_hdr));
ASSERT_LOCKED(stream->chan->lock);
ASSERT_LOCKED(stream->lock);
- assert(stream->metadata_flag);
- assert(stream->chan->trace_chunk);
+ LTTNG_ASSERT(stream->metadata_flag);
+ LTTNG_ASSERT(stream->chan->trace_chunk);
switch (the_consumer_data.type) {
case LTTNG_CONSUMER_KERNEL:
const bool acquired_reference = lttng_trace_chunk_get(
new_trace_chunk);
- assert(acquired_reference);
+ LTTNG_ASSERT(acquired_reference);
}
lttng_trace_chunk_put(channel->trace_chunk);
channel->output = CONSUMER_CHANNEL_MMAP;
break;
default:
- assert(0);
+ abort();
free(channel);
channel = NULL;
goto end;
struct lttng_ht_iter iter;
struct lttng_consumer_stream *stream;
- assert(ctx);
- assert(ht);
- assert(pollfd);
- assert(local_stream);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(ht);
+ LTTNG_ASSERT(pollfd);
+ LTTNG_ASSERT(local_stream);
DBG("Updating poll fd array");
*nb_inactive_fd = 0;
int ret;
struct lttng_consumer_local_data *ctx;
- assert(the_consumer_data.type == LTTNG_CONSUMER_UNKNOWN ||
+ LTTNG_ASSERT(the_consumer_data.type == LTTNG_CONSUMER_UNKNOWN ||
the_consumer_data.type == type);
the_consumer_data.type = type;
/* RCU lock for the relayd pointer */
rcu_read_lock();
- assert(stream->net_seq_idx != (uint64_t) -1ULL ||
+ LTTNG_ASSERT(stream->net_seq_idx != (uint64_t) -1ULL ||
stream->trace_chunk);
/* Flag that the current stream if set for network streaming. */
return -ENOSYS;
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
}
/* RCU lock for the relayd pointer */
return lttng_ustconsumer_sample_snapshot_positions(stream);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
return lttng_ustconsumer_take_snapshot(stream);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
return lttng_ustconsumer_get_produced_snapshot(stream, pos);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
return lttng_ustconsumer_get_consumed_snapshot(stream, pos);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
return lttng_ustconsumer_recv_cmd(ctx, sock, consumer_sockpoll);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
break;
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
}
}
struct lttng_consumer_channel *channel = NULL;
bool free_channel = false;
- assert(stream);
+ LTTNG_ASSERT(stream);
/*
* This call should NEVER receive regular stream. It must always be
* metadata stream and this is crucial for data structure synchronization.
*/
- assert(stream->metadata_flag);
+ LTTNG_ASSERT(stream->metadata_flag);
DBG3("Consumer delete metadata stream %d", stream->wait_fd);
struct lttng_ht_iter iter;
struct lttng_ht_node_u64 *node;
- assert(stream);
- assert(ht);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(ht);
DBG3("Adding metadata stream %" PRIu64 " to hash table", stream->key);
*/
lttng_ht_lookup(ht, &stream->key, &iter);
node = lttng_ht_iter_get_node_u64(&iter);
- assert(!node);
+ LTTNG_ASSERT(!node);
/*
* When nb_init_stream_left reaches 0, we don't need to trigger any action
DBG("Consumer delete flagged metadata stream");
- assert(pollset);
+ LTTNG_ASSERT(pollset);
rcu_read_lock();
cds_lfht_for_each_entry(metadata_ht->ht, &iter.iter, stream, node.node) {
lttng_ht_lookup(metadata_ht, &tmp_id, &iter);
}
node = lttng_ht_iter_get_node_u64(&iter);
- assert(node);
+ LTTNG_ASSERT(node);
stream = caa_container_of(node, struct lttng_consumer_stream,
node);
if (revents & (LPOLLIN | LPOLLPRI)) {
/* Get the data out of the metadata file descriptor */
DBG("Metadata available on fd %d", pollfd);
- assert(stream->wait_fd == pollfd);
+ LTTNG_ASSERT(stream->wait_fd == pollfd);
do {
health_code_update();
break;
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
}
next:
pthread_mutex_unlock(&stream->lock);
rcu_read_lock();
cds_lfht_for_each_entry(ht->ht, &iter.iter, channel, wait_fd_node.node) {
ret = lttng_ht_del(ht, &iter);
- assert(ret != 0);
+ LTTNG_ASSERT(ret != 0);
}
rcu_read_unlock();
lttng_poll_del(&events, chan->wait_fd);
iter.iter.node = &chan->wait_fd_node.node;
ret = lttng_ht_del(channel_ht, &iter);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
switch (the_consumer_data.type) {
case LTTNG_CONSUMER_KERNEL:
break;
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
}
/*
lttng_ht_lookup(channel_ht, &tmp_id, &iter);
}
node = lttng_ht_iter_get_node_u64(&iter);
- assert(node);
+ LTTNG_ASSERT(node);
chan = caa_container_of(node, struct lttng_consumer_channel,
wait_fd_node);
lttng_poll_del(&events, chan->wait_fd);
ret = lttng_ht_del(channel_ht, &iter);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
/*
* This will close the wait fd for each stream associated to
{
int ret;
- assert(ctx);
- assert(sockpoll);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(sockpoll);
ret = lttng_consumer_poll_socket(sockpoll);
if (ret) {
return lttng_ustconsumer_on_recv_stream(stream);
default:
ERR("Unknown consumer_data type");
- assert(0);
+ abort();
return -ENOSYS;
}
}
enum lttcomm_return_code ret_code = LTTCOMM_CONSUMERD_SUCCESS;
struct consumer_relayd_sock_pair *relayd = NULL;
- assert(ctx);
- assert(relayd_sock);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(relayd_sock);
DBG("Consumer adding relayd socket (idx: %" PRIu64 ")", net_seq_idx);
/* Get relayd reference if exists. */
relayd = consumer_find_relayd(net_seq_idx);
if (relayd == NULL) {
- assert(sock_type == LTTNG_STREAM_CONTROL);
+ LTTNG_ASSERT(sock_type == LTTNG_STREAM_CONTROL);
/* Not found. Allocate one. */
relayd = consumer_allocate_relayd_sock_pair(net_seq_idx);
if (relayd == NULL) {
/*
* relayd key should never be found for control socket.
*/
- assert(sock_type != LTTNG_STREAM_CONTROL);
+ LTTNG_ASSERT(sock_type != LTTNG_STREAM_CONTROL);
}
/* First send a status message before receiving the fds. */
break;
default:
ERR("Unknown consumer data type");
- assert(0);
+ abort();
}
/* Ease our life a bit */
{
struct lttcomm_consumer_status_channel msg;
- assert(sock >= 0);
+ LTTNG_ASSERT(sock >= 0);
memset(&msg, 0, sizeof(msg));
if (!channel) {
rcu_read_lock();
pthread_mutex_lock(&channel->lock);
- assert(channel->trace_chunk);
+ LTTNG_ASSERT(channel->trace_chunk);
chunk_status = lttng_trace_chunk_get_id(channel->trace_chunk,
&next_chunk_id);
if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
chunk_status = lttng_trace_chunk_get_id(
stream->trace_chunk,
&trace_chunk_id);
- assert(chunk_status ==
+ LTTNG_ASSERT(chunk_status ==
LTTNG_TRACE_CHUNK_STATUS_OK);
DBG("Unable to open packet for stream during trace chunk's lifetime. "
}
/* Local protocol error. */
- assert(chunk_creation_timestamp);
+ LTTNG_ASSERT(chunk_creation_timestamp);
ret = time_to_iso8601_str(chunk_creation_timestamp,
creation_timestamp_buffer,
sizeof(creation_timestamp_buffer));
projects / lttng-tools.git / blobdiff