*/
#define _LGPL_SOURCE
-#include <assert.h>
#include <lttng/ust-ctl.h>
+#include <lttng/ust-sigbus.h>
#include <poll.h>
#include <pthread.h>
#include <stdlib.h>
extern struct lttng_consumer_global_data the_consumer_data;
extern int consumer_poll_timeout;
+LTTNG_EXPORT DEFINE_LTTNG_UST_SIGBUS_STATE();
+
/*
* Free channel object and all streams associated with it. This MUST be used
* only and only if the channel has _NEVER_ been added to the global channel
{
struct lttng_consumer_stream *stream, *stmp;
- assert(channel);
+ LTTNG_ASSERT(channel);
DBG("UST consumer cleaning stream list");
{
int ret = 0;
- assert(channel);
- assert(ctx);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(ctx);
if (ctx->on_recv_channel != NULL) {
ret = ctx->on_recv_channel(channel);
int alloc_ret;
struct lttng_consumer_stream *stream = NULL;
- assert(channel);
- assert(ctx);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(ctx);
stream = consumer_stream_create(
channel,
struct lttng_consumer_stream *stream;
pthread_mutex_t *current_stream_lock = NULL;
- assert(channel);
- assert(ctx);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(ctx);
/*
* While a stream is available from ustctl. When NULL is returned, we've
int *stream_fds;
struct lttng_ust_ctl_consumer_channel *ust_channel;
- assert(channel);
- assert(attr);
- assert(ust_chanp);
- assert(channel->buffer_credentials.is_set);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(attr);
+ LTTNG_ASSERT(ust_chanp);
+ LTTNG_ASSERT(channel->buffer_credentials.is_set);
DBG3("Creating channel to ustctl with attr: [overwrite: %d, "
"subbuf_size: %" PRIu64 ", num_subbuf: %" PRIu64 ", "
{
int ret;
- assert(stream);
- assert(sock >= 0);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(sock >= 0);
DBG("UST consumer sending stream %" PRIu64 " to sessiond", stream->key);
struct lttng_consumer_stream *stream;
uint64_t net_seq_idx = -1ULL;
- assert(channel);
- assert(ctx);
- assert(sock >= 0);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(sock >= 0);
DBG("UST consumer sending channel %s to sessiond", channel->name);
{
int ret;
- assert(ctx);
- assert(channel);
- assert(attr);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(attr);
/*
* This value is still used by the kernel consumer since for the kernel,
int ret = 0;
struct lttng_consumer_stream *stream, *stmp;
- assert(channel);
- assert(ctx);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(ctx);
/* Send streams to the corresponding thread. */
cds_list_for_each_entry_safe(stream, stmp, &channel->streams.head,
}
if (!stream->quiescent) {
- lttng_ust_ctl_flush_buffer(stream->ustream, 0);
+ ret = lttng_ust_ctl_flush_buffer(stream->ustream, 0);
+ if (ret) {
+ ERR("Failed to flush buffer while flushing channel: channel key = %" PRIu64 ", channel name = '%s'",
+ chan_key, channel->name);
+ ret = LTTNG_ERR_BUFFER_FLUSH_FAILED;
+ pthread_mutex_unlock(&stream->lock);
+ goto error;
+ }
stream->quiescent = true;
}
next:
goto send_streams_error;
}
/* List MUST be empty after or else it could be reused. */
- assert(cds_list_empty(&metadata->streams.head));
+ LTTNG_ASSERT(cds_list_empty(&metadata->streams.head));
ret = 0;
goto end;
int ret = 0;
struct lttng_consumer_stream *metadata_stream;
- assert(path);
- assert(ctx);
+ LTTNG_ASSERT(path);
+ LTTNG_ASSERT(ctx);
DBG("UST consumer snapshot metadata with key %" PRIu64 " at path %s",
key, path);
rcu_read_lock();
- assert(!metadata_channel->monitor);
+ LTTNG_ASSERT(!metadata_channel->monitor);
health_code_update();
}
metadata_stream = metadata_channel->metadata_stream;
- assert(metadata_stream);
+ LTTNG_ASSERT(metadata_stream);
pthread_mutex_lock(&metadata_stream->lock);
if (relayd_id != (uint64_t) -1ULL) {
unsigned long consumed_pos, produced_pos;
struct lttng_consumer_stream *stream;
- assert(path);
- assert(ctx);
+ LTTNG_ASSERT(path);
+ LTTNG_ASSERT(ctx);
rcu_read_lock();
use_relayd = 1;
}
- assert(!channel->monitor);
+ LTTNG_ASSERT(!channel->monitor);
DBG("UST consumer snapshot channel %" PRIu64, key);
cds_list_for_each_entry(stream, &channel->streams.head, send_node) {
/* Lock stream because we are about to change its state. */
pthread_mutex_lock(&stream->lock);
- assert(channel->trace_chunk);
+ LTTNG_ASSERT(channel->trace_chunk);
if (!lttng_trace_chunk_get(channel->trace_chunk)) {
/*
* Can't happen barring an internal error as the channel
ret = -1;
goto error_unlock;
}
- assert(!stream->trace_chunk);
+ LTTNG_ASSERT(!stream->trace_chunk);
stream->trace_chunk = channel->trace_chunk;
stream->net_seq_idx = relayd_id;
* Else, if quiescent, it has already been done by the prior stop.
*/
if (!stream->quiescent) {
- lttng_ust_ctl_flush_buffer(stream->ustream, 0);
+ ret = lttng_ust_ctl_flush_buffer(stream->ustream, 0);
+ if (ret < 0) {
+ ERR("Failed to flush buffer during snapshot of channel: channel key = %" PRIu64 ", channel name = '%s'",
+ channel->key, channel->name);
+ goto error_unlock;
+ }
}
ret = lttng_ustconsumer_take_snapshot(stream);
health_code_update();
/* deprecated */
- assert(msg.cmd_type != LTTNG_CONSUMER_STOP);
+ LTTNG_ASSERT(msg.cmd_type != LTTNG_CONSUMER_STOP);
health_code_update();
attr.type = LTTNG_UST_ABI_CHAN_METADATA;
break;
default:
- assert(0);
+ abort();
goto error_fatal;
};
goto error_get_channel_fatal;
}
/* List MUST be empty after or else it could be reused. */
- assert(cds_list_empty(&found_channel->streams.head));
+ LTTNG_ASSERT(cds_list_empty(&found_channel->streams.head));
end_get_channel:
goto end_msg_sessiond;
error_get_channel_fatal:
return ret_func;
}
-void lttng_ust_flush_buffer(
- struct lttng_consumer_stream *stream, int producer_active)
+int lttng_ust_flush_buffer(struct lttng_consumer_stream *stream,
+ int producer_active)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
- lttng_ust_ctl_flush_buffer(stream->ustream, producer_active);
+ return lttng_ust_ctl_flush_buffer(stream->ustream, producer_active);
}
/*
*/
int lttng_ustconsumer_take_snapshot(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
return lttng_ust_ctl_snapshot(stream->ustream);
}
int lttng_ustconsumer_sample_snapshot_positions(
struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
return lttng_ust_ctl_snapshot_sample_positions(stream->ustream);
}
int lttng_ustconsumer_get_produced_snapshot(
struct lttng_consumer_stream *stream, unsigned long *pos)
{
- assert(stream);
- assert(stream->ustream);
- assert(pos);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
+ LTTNG_ASSERT(pos);
return lttng_ust_ctl_snapshot_get_produced(stream->ustream, pos);
}
int lttng_ustconsumer_get_consumed_snapshot(
struct lttng_consumer_stream *stream, unsigned long *pos)
{
- assert(stream);
- assert(stream->ustream);
- assert(pos);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
+ LTTNG_ASSERT(pos);
return lttng_ust_ctl_snapshot_get_consumed(stream->ustream, pos);
}
-void lttng_ustconsumer_flush_buffer(struct lttng_consumer_stream *stream,
+int lttng_ustconsumer_flush_buffer(struct lttng_consumer_stream *stream,
int producer)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
- lttng_ust_ctl_flush_buffer(stream->ustream, producer);
+ return lttng_ust_ctl_flush_buffer(stream->ustream, producer);
}
-void lttng_ustconsumer_clear_buffer(struct lttng_consumer_stream *stream)
+int lttng_ustconsumer_clear_buffer(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
- lttng_ust_ctl_clear_buffer(stream->ustream);
+ return lttng_ust_ctl_clear_buffer(stream->ustream);
}
int lttng_ustconsumer_get_current_timestamp(
struct lttng_consumer_stream *stream, uint64_t *ts)
{
- assert(stream);
- assert(stream->ustream);
- assert(ts);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
+ LTTNG_ASSERT(ts);
return lttng_ust_ctl_get_current_timestamp(stream->ustream, ts);
}
int lttng_ustconsumer_get_sequence_number(
struct lttng_consumer_stream *stream, uint64_t *seq)
{
- assert(stream);
- assert(stream->ustream);
- assert(seq);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
+ LTTNG_ASSERT(seq);
return lttng_ust_ctl_get_sequence_number(stream->ustream, seq);
}
*/
void lttng_ustconsumer_on_stream_hangup(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
pthread_mutex_lock(&stream->lock);
if (!stream->quiescent) {
- lttng_ust_ctl_flush_buffer(stream->ustream, 0);
- stream->quiescent = true;
+ if (lttng_ust_ctl_flush_buffer(stream->ustream, 0) < 0) {
+ ERR("Failed to flush buffer on stream hang-up");
+ } else {
+ stream->quiescent = true;
+ }
}
pthread_mutex_unlock(&stream->lock);
stream->hangup_flush_done = 1;
{
int i;
- assert(chan);
- assert(chan->uchan);
- assert(chan->buffer_credentials.is_set);
+ LTTNG_ASSERT(chan);
+ LTTNG_ASSERT(chan->uchan);
+ LTTNG_ASSERT(chan->buffer_credentials.is_set);
if (chan->switch_timer_enabled == 1) {
consumer_timer_switch_stop(chan);
void lttng_ustconsumer_free_channel(struct lttng_consumer_channel *chan)
{
- assert(chan);
- assert(chan->uchan);
- assert(chan->buffer_credentials.is_set);
+ LTTNG_ASSERT(chan);
+ LTTNG_ASSERT(chan->uchan);
+ LTTNG_ASSERT(chan->buffer_credentials.is_set);
consumer_metadata_cache_destroy(chan);
lttng_ust_ctl_destroy_channel(chan->uchan);
void lttng_ustconsumer_del_stream(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
if (stream->chan->switch_timer_enabled == 1) {
consumer_timer_switch_stop(stream->chan);
int lttng_ustconsumer_get_wakeup_fd(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
return lttng_ust_ctl_stream_get_wakeup_fd(stream->ustream);
}
int lttng_ustconsumer_close_wakeup_fd(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
return lttng_ust_ctl_stream_close_wakeup_fd(stream->ustream);
}
&stream->chan->metadata_cache->contents.data[stream->ust_metadata_pushed],
stream->chan->metadata_cache->contents.size -
stream->ust_metadata_pushed);
- assert(write_len != 0);
+ LTTNG_ASSERT(write_len != 0);
if (write_len < 0) {
ERR("Writing one metadata packet");
ret = write_len;
}
stream->ust_metadata_pushed += write_len;
- assert(stream->chan->metadata_cache->contents.size >=
+ LTTNG_ASSERT(stream->chan->metadata_cache->contents.size >=
stream->ust_metadata_pushed);
ret = write_len;
* a metadata packet. Since the subbuffer is fully filled (with padding,
* if needed), the stream is "quiescent" after this commit.
*/
- lttng_ust_ctl_flush_buffer(stream->ustream, 1);
- stream->quiescent = true;
+ if (lttng_ust_ctl_flush_buffer(stream->ustream, 1)) {
+ ERR("Failed to flush buffer while commiting one metadata packet");
+ ret = -EIO;
+ } else {
+ stream->quiescent = true;
+ }
end:
pthread_mutex_unlock(&stream->chan->metadata_cache->lock);
return ret;
enum sync_metadata_status status;
struct lttng_consumer_channel *metadata_channel;
- assert(ctx);
- assert(metadata_stream);
+ LTTNG_ASSERT(ctx);
+ LTTNG_ASSERT(metadata_stream);
metadata_channel = metadata_stream->chan;
pthread_mutex_unlock(&metadata_stream->lock);
int ret;
struct lttng_ust_ctl_consumer_stream *ustream;
- assert(stream);
- assert(ctx);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(ctx);
ustream = stream->ustream;
}
ret = lttng_ust_ctl_put_subbuf(ustream);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
/* This stream still has data. Flag it and wake up the data thread. */
stream->has_data = 1;
subbuffer->buffer.buffer = lttng_buffer_view_init(
addr, 0, subbuffer->info.data.padded_subbuf_size);
- assert(subbuffer->buffer.buffer.data != NULL);
+ LTTNG_ASSERT(subbuffer->buffer.buffer.data != NULL);
end:
return ret;
}
{
const int ret = lttng_ust_ctl_put_next_subbuf(stream->ustream);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
return ret;
}
{
int ret;
- assert(stream);
+ LTTNG_ASSERT(stream);
/*
* Don't create anything if this is set for streaming or if there is
{
int ret;
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
ASSERT_LOCKED(stream->lock);
DBG("UST consumer checking data pending");
*/
DBG("UST consumer metadata pending check: contiguous %" PRIu64 " vs pushed %" PRIu64,
contiguous, pushed);
- assert(((int64_t) (contiguous - pushed)) >= 0);
+ LTTNG_ASSERT(((int64_t) (contiguous - pushed)) >= 0);
if ((contiguous != pushed) ||
(((int64_t) contiguous - pushed) > 0 || contiguous == 0)) {
ret = 1; /* Data is pending */
* subbuffer.
*/
ret = lttng_ust_ctl_put_subbuf(stream->ustream);
- assert(ret == 0);
+ LTTNG_ASSERT(ret == 0);
ret = 1; /* Data is pending */
goto end;
}
{
int ret;
- assert(metadata);
- assert(metadata->type == CONSUMER_CHANNEL_TYPE_METADATA);
+ LTTNG_ASSERT(metadata);
+ LTTNG_ASSERT(metadata->type == CONSUMER_CHANNEL_TYPE_METADATA);
DBG("Closing metadata channel key %" PRIu64, metadata->key);
struct lttng_ht_iter iter;
struct lttng_consumer_stream *stream;
- assert(metadata_ht);
- assert(metadata_ht->ht);
+ LTTNG_ASSERT(metadata_ht);
+ LTTNG_ASSERT(metadata_ht->ht);
DBG("UST consumer closing all metadata streams");
uint64_t len, key, offset, version;
int ret;
- assert(channel);
- assert(channel->metadata_cache);
+ LTTNG_ASSERT(channel);
+ LTTNG_ASSERT(channel->metadata_cache);
memset(&request, 0, sizeof(request));
offset = msg.u.push_metadata.target_offset;
version = msg.u.push_metadata.version;
- assert(key == channel->key);
+ LTTNG_ASSERT(key == channel->key);
if (len == 0) {
DBG("No new metadata to receive for key %" PRIu64, key);
}
int lttng_ustconsumer_get_stream_id(struct lttng_consumer_stream *stream,
uint64_t *stream_id)
{
- assert(stream);
- assert(stream_id);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream_id);
return lttng_ust_ctl_get_stream_id(stream->ustream, stream_id);
}
+
+void lttng_ustconsumer_sigbus_handle(void *addr)
+{
+ lttng_ust_ctl_sigbus_handle(addr);
+}
projects / lttng-tools.git / blobdiff