*/
#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");
health_code_update();
cds_list_del(&stream->send_node);
- ustctl_destroy_stream(stream->ustream);
+ lttng_ust_ctl_destroy_stream(stream->ustream);
lttng_trace_chunk_put(stream->trace_chunk);
free(stream);
}
{
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_local_data *ctx)
{
int ret, cpu = 0;
- struct ustctl_consumer_stream *ustream;
+ struct lttng_ust_ctl_consumer_stream *ustream;
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
* reached the end of the possible stream for the channel.
*/
- while ((ustream = ustctl_create_stream(channel->uchan, cpu))) {
+ while ((ustream = lttng_ust_ctl_create_stream(channel->uchan, cpu))) {
int wait_fd;
int ust_metadata_pipe[2];
}
wait_fd = ust_metadata_pipe[0];
} else {
- wait_fd = ustctl_stream_get_wait_fd(ustream);
+ wait_fd = lttng_ust_ctl_stream_get_wait_fd(ustream);
}
/* Allocate consumer stream object. */
*/
cds_list_add_tail(&stream->send_node, &channel->streams.head);
- ret = ustctl_get_max_subbuf_size(stream->ustream,
+ ret = lttng_ust_ctl_get_max_subbuf_size(stream->ustream,
&stream->max_sb_size);
if (ret < 0) {
- ERR("ustctl_get_max_subbuf_size failed for stream %s",
+ ERR("lttng_ust_ctl_get_max_subbuf_size failed for stream %s",
stream->name);
goto error;
}
* Return 0 on success or else a negative value.
*/
static int create_ust_channel(struct lttng_consumer_channel *channel,
- struct ustctl_consumer_channel_attr *attr,
- struct ustctl_consumer_channel **ust_chanp)
+ struct lttng_ust_ctl_consumer_channel_attr *attr,
+ struct lttng_ust_ctl_consumer_channel **ust_chanp)
{
int ret, nr_stream_fds, i, j;
int *stream_fds;
- struct ustctl_consumer_channel *ust_channel;
+ 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 ", "
if (channel->type == CONSUMER_CHANNEL_TYPE_METADATA)
nr_stream_fds = 1;
else
- nr_stream_fds = ustctl_get_nr_stream_per_channel();
+ nr_stream_fds = lttng_ust_ctl_get_nr_stream_per_channel();
stream_fds = zmalloc(nr_stream_fds * sizeof(*stream_fds));
if (!stream_fds) {
ret = -1;
goto error_open;
}
}
- ust_channel = ustctl_create_channel(attr, stream_fds, nr_stream_fds);
+ ust_channel = lttng_ust_ctl_create_channel(attr, stream_fds, nr_stream_fds);
if (!ust_channel) {
ret = -1;
goto error_create;
{
int ret;
- assert(stream);
- assert(sock >= 0);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(sock >= 0);
DBG("UST consumer sending stream %" PRIu64 " to sessiond", stream->key);
/* Send stream to session daemon. */
- ret = ustctl_send_stream_to_sessiond(sock, stream->ustream);
+ ret = lttng_ust_ctl_send_stream_to_sessiond(sock, stream->ustream);
if (ret < 0) {
goto error;
}
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);
}
/* Send channel to sessiond. */
- ret = ustctl_send_channel_to_sessiond(sock, channel->uchan);
+ ret = lttng_ust_ctl_send_channel_to_sessiond(sock, channel->uchan);
if (ret < 0) {
goto error;
}
- ret = ustctl_channel_close_wakeup_fd(channel->uchan);
+ ret = lttng_ust_ctl_channel_close_wakeup_fd(channel->uchan);
if (ret < 0) {
goto error;
}
}
/* Tell sessiond there is no more stream. */
- ret = ustctl_send_stream_to_sessiond(sock, NULL);
+ ret = lttng_ust_ctl_send_stream_to_sessiond(sock, NULL);
if (ret < 0) {
goto error;
}
*/
static int ask_channel(struct lttng_consumer_local_data *ctx,
struct lttng_consumer_channel *channel,
- struct ustctl_consumer_channel_attr *attr)
+ struct lttng_ust_ctl_consumer_channel_attr *attr)
{
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,
goto end;
}
- channel->wait_fd = ustctl_channel_get_wait_fd(channel->uchan);
+ channel->wait_fd = lttng_ust_ctl_channel_get_wait_fd(channel->uchan);
/*
* For the snapshots (no monitor), we create the metadata streams
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) {
- ustctl_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 mmap_offset;
const char *mmap_base;
- mmap_base = ustctl_get_mmap_base(stream->ustream);
+ mmap_base = lttng_ust_ctl_get_mmap_base(stream->ustream);
if (!mmap_base) {
ERR("Failed to get mmap base for stream `%s`",
stream->name);
goto error;
}
- ret = ustctl_get_mmap_read_offset(stream->ustream, &mmap_offset);
+ ret = lttng_ust_ctl_get_mmap_read_offset(stream->ustream, &mmap_offset);
if (ret != 0) {
ERR("Failed to get mmap offset for stream `%s`", stream->name);
ret = -EINVAL;
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) {
- ustctl_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);
DBG("UST consumer taking snapshot at pos %lu", consumed_pos);
- ret = ustctl_get_subbuf(stream->ustream, &consumed_pos);
+ ret = lttng_ust_ctl_get_subbuf(stream->ustream, &consumed_pos);
if (ret < 0) {
if (ret != -EAGAIN) {
- PERROR("ustctl_get_subbuf snapshot");
+ PERROR("lttng_ust_ctl_get_subbuf snapshot");
goto error_close_stream;
}
DBG("UST consumer get subbuf failed. Skipping it.");
continue;
}
- ret = ustctl_get_subbuf_size(stream->ustream, &len);
+ ret = lttng_ust_ctl_get_subbuf_size(stream->ustream, &len);
if (ret < 0) {
- ERR("Snapshot ustctl_get_subbuf_size");
+ ERR("Snapshot lttng_ust_ctl_get_subbuf_size");
goto error_put_subbuf;
}
- ret = ustctl_get_padded_subbuf_size(stream->ustream, &padded_len);
+ ret = lttng_ust_ctl_get_padded_subbuf_size(stream->ustream, &padded_len);
if (ret < 0) {
- ERR("Snapshot ustctl_get_padded_subbuf_size");
+ ERR("Snapshot lttng_ust_ctl_get_padded_subbuf_size");
goto error_put_subbuf;
}
}
}
- ret = ustctl_put_subbuf(stream->ustream);
+ ret = lttng_ust_ctl_put_subbuf(stream->ustream);
if (ret < 0) {
- ERR("Snapshot ustctl_put_subbuf");
+ ERR("Snapshot lttng_ust_ctl_put_subbuf");
goto error_close_stream;
}
consumed_pos += stream->max_sb_size;
return 0;
error_put_subbuf:
- if (ustctl_put_subbuf(stream->ustream) < 0) {
- ERR("Snapshot ustctl_put_subbuf");
+ if (lttng_ust_ctl_put_subbuf(stream->ustream) < 0) {
+ ERR("Snapshot lttng_ust_ctl_put_subbuf");
}
error_close_stream:
consumer_stream_close(stream);
health_code_update();
/* deprecated */
- assert(msg.cmd_type != LTTNG_CONSUMER_STOP);
+ LTTNG_ASSERT(msg.cmd_type != LTTNG_CONSUMER_STOP);
health_code_update();
case LTTNG_CONSUMER_ASK_CHANNEL_CREATION:
{
int ret_ask_channel, ret_add_channel, ret_send;
- struct ustctl_consumer_channel_attr attr;
+ struct lttng_ust_ctl_consumer_channel_attr attr;
const uint64_t chunk_id = msg.u.ask_channel.chunk_id.value;
const struct lttng_credentials buffer_credentials = {
.uid = LTTNG_OPTIONAL_INIT_VALUE(msg.u.ask_channel.buffer_credentials.uid),
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:
const uint64_t relayd_id =
msg.u.close_trace_chunk.relayd_id.value;
struct lttcomm_consumer_close_trace_chunk_reply reply;
- char closed_trace_chunk_path[LTTNG_PATH_MAX];
+ char closed_trace_chunk_path[LTTNG_PATH_MAX] = {};
int ret;
ret_code = lttng_consumer_close_trace_chunk(
return ret_func;
}
-void lttng_ustctl_flush_buffer(struct lttng_consumer_stream *stream,
+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);
- ustctl_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 ustctl_snapshot(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 ustctl_snapshot_sample_positions(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 ustctl_snapshot_get_produced(stream->ustream, 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 ustctl_snapshot_get_consumed(stream->ustream, 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);
- ustctl_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);
- ustctl_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 ustctl_get_current_timestamp(stream->ustream, 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 ustctl_get_sequence_number(stream->ustream, 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) {
- ustctl_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);
- ustctl_destroy_channel(chan->uchan);
+ lttng_ust_ctl_destroy_channel(chan->uchan);
/* Try to rmdir all directories under shm_path root. */
if (chan->root_shm_path[0]) {
(void) run_as_rmdir_recursive(chan->root_shm_path,
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);
}
- ustctl_destroy_stream(stream->ustream);
+ lttng_ust_ctl_destroy_stream(stream->ustream);
}
int lttng_ustconsumer_get_wakeup_fd(struct lttng_consumer_stream *stream)
{
- assert(stream);
- assert(stream->ustream);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(stream->ustream);
- return ustctl_stream_get_wakeup_fd(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 ustctl_stream_close_wakeup_fd(stream->ustream);
+ return lttng_ust_ctl_stream_close_wakeup_fd(stream->ustream);
}
/*
}
}
- write_len = ustctl_write_one_packet_to_channel(stream->chan->uchan,
+ write_len = lttng_ust_ctl_write_one_packet_to_channel(stream->chan->uchan,
&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.
*/
- ustctl_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);
goto end;
}
- ret = ustctl_snapshot(metadata_stream->ustream);
+ ret = lttng_ust_ctl_snapshot(metadata_stream->ustream);
if (ret < 0) {
ERR("Failed to take a snapshot of the metadata ring-buffer positions, ret = %d", ret);
status = SYNC_METADATA_STATUS_ERROR;
struct lttng_consumer_local_data *ctx)
{
int ret;
- struct ustctl_consumer_stream *ustream;
+ struct lttng_ust_ctl_consumer_stream *ustream;
- assert(stream);
- assert(ctx);
+ LTTNG_ASSERT(stream);
+ LTTNG_ASSERT(ctx);
ustream = stream->ustream;
* before reading the stream wait_fd.
*/
/* Get the next subbuffer */
- ret = ustctl_get_next_subbuf(ustream);
+ ret = lttng_ust_ctl_get_next_subbuf(ustream);
if (ret) {
/* No more data found, flag the stream. */
stream->has_data = 0;
goto end;
}
- ret = ustctl_put_subbuf(ustream);
- assert(!ret);
+ ret = lttng_ust_ctl_put_subbuf(ustream);
+ LTTNG_ASSERT(!ret);
/* This stream still has data. Flag it and wake up the data thread. */
stream->has_data = 1;
{
int ret;
- ret = ustctl_get_subbuf_size(
+ ret = lttng_ust_ctl_get_subbuf_size(
stream->ustream, &subbuf->info.data.subbuf_size);
if (ret) {
goto end;
}
- ret = ustctl_get_padded_subbuf_size(
+ ret = lttng_ust_ctl_get_padded_subbuf_size(
stream->ustream, &subbuf->info.data.padded_subbuf_size);
if (ret) {
goto end;
goto end;
}
- ret = ustctl_get_packet_size(
+ ret = lttng_ust_ctl_get_packet_size(
stream->ustream, &subbuf->info.data.packet_size);
if (ret < 0) {
PERROR("Failed to get sub-buffer packet size");
goto end;
}
- ret = ustctl_get_content_size(
+ ret = lttng_ust_ctl_get_content_size(
stream->ustream, &subbuf->info.data.content_size);
if (ret < 0) {
PERROR("Failed to get sub-buffer content size");
goto end;
}
- ret = ustctl_get_timestamp_begin(
+ ret = lttng_ust_ctl_get_timestamp_begin(
stream->ustream, &subbuf->info.data.timestamp_begin);
if (ret < 0) {
PERROR("Failed to get sub-buffer begin timestamp");
goto end;
}
- ret = ustctl_get_timestamp_end(
+ ret = lttng_ust_ctl_get_timestamp_end(
stream->ustream, &subbuf->info.data.timestamp_end);
if (ret < 0) {
PERROR("Failed to get sub-buffer end timestamp");
goto end;
}
- ret = ustctl_get_events_discarded(
+ ret = lttng_ust_ctl_get_events_discarded(
stream->ustream, &subbuf->info.data.events_discarded);
if (ret) {
PERROR("Failed to get sub-buffer events discarded count");
goto end;
}
- ret = ustctl_get_sequence_number(stream->ustream,
+ ret = lttng_ust_ctl_get_sequence_number(stream->ustream,
&subbuf->info.data.sequence_number.value);
if (ret) {
/* May not be supported by older LTTng-modules. */
subbuf->info.data.sequence_number.is_set = true;
}
- ret = ustctl_get_stream_id(
+ ret = lttng_ust_ctl_get_stream_id(
stream->ustream, &subbuf->info.data.stream_id);
if (ret < 0) {
PERROR("Failed to get stream id");
goto end;
}
- ret = ustctl_get_instance_id(stream->ustream,
+ ret = lttng_ust_ctl_get_instance_id(stream->ustream,
&subbuf->info.data.stream_instance_id.value);
if (ret) {
/* May not be supported by older LTTng-modules. */
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;
}
-static int get_next_subbuffer(struct lttng_consumer_stream *stream,
+static enum get_next_subbuffer_status get_next_subbuffer(
+ struct lttng_consumer_stream *stream,
struct stream_subbuffer *subbuffer)
{
int ret;
+ enum get_next_subbuffer_status status;
- ret = ustctl_get_next_subbuf(stream->ustream);
- if (ret) {
+ ret = lttng_ust_ctl_get_next_subbuf(stream->ustream);
+ switch (ret) {
+ case 0:
+ status = GET_NEXT_SUBBUFFER_STATUS_OK;
+ break;
+ case -ENODATA:
+ case -EAGAIN:
+ /*
+ * The caller only expects -ENODATA when there is no data to
+ * read, but the kernel tracer returns -EAGAIN when there is
+ * currently no data for a non-finalized stream, and -ENODATA
+ * when there is no data for a finalized stream. Those can be
+ * combined into a -ENODATA return value.
+ */
+ status = GET_NEXT_SUBBUFFER_STATUS_NO_DATA;
+ goto end;
+ default:
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
ret = get_next_subbuffer_common(stream, subbuffer);
if (ret) {
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
end:
- return ret;
+ return status;
}
-static int get_next_subbuffer_metadata(struct lttng_consumer_stream *stream,
+static enum get_next_subbuffer_status get_next_subbuffer_metadata(
+ struct lttng_consumer_stream *stream,
struct stream_subbuffer *subbuffer)
{
int ret;
bool coherent;
bool buffer_empty;
unsigned long consumed_pos, produced_pos;
+ enum get_next_subbuffer_status status;
do {
- ret = ustctl_get_next_subbuf(stream->ustream);
+ ret = lttng_ust_ctl_get_next_subbuf(stream->ustream);
if (ret == 0) {
got_subbuffer = true;
} else {
got_subbuffer = false;
if (ret != -EAGAIN) {
/* Fatal error. */
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
}
if (!got_subbuffer) {
ret = commit_one_metadata_packet(stream);
if (ret < 0 && ret != -ENOBUFS) {
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
} else if (ret == 0) {
/* Not an error, the cache is empty. */
cache_empty = true;
- ret = -ENODATA;
+ status = GET_NEXT_SUBBUFFER_STATUS_NO_DATA;
goto end;
} else {
cache_empty = false;
/* Populate sub-buffer infos and view. */
ret = get_next_subbuffer_common(stream, subbuffer);
if (ret) {
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
* pushed the consumption position yet (on put_next).
*/
PERROR("Failed to take a snapshot of metadata buffer positions");
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
ret = lttng_ustconsumer_get_consumed_snapshot(stream, &consumed_pos);
if (ret) {
PERROR("Failed to get metadata consumed position");
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
ret = lttng_ustconsumer_get_produced_snapshot(stream, &produced_pos);
if (ret) {
PERROR("Failed to get metadata produced position");
+ status = GET_NEXT_SUBBUFFER_STATUS_ERROR;
goto end;
}
coherent = got_subbuffer && cache_empty && buffer_empty;
LTTNG_OPTIONAL_SET(&subbuffer->info.metadata.coherent, coherent);
+ status = GET_NEXT_SUBBUFFER_STATUS_OK;
end:
- return ret;
+ return status;
}
static int put_next_subbuffer(struct lttng_consumer_stream *stream,
struct stream_subbuffer *subbuffer)
{
- const int ret = ustctl_put_next_subbuf(stream->ustream);
+ 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 */
goto end;
}
} else {
- ret = ustctl_get_next_subbuf(stream->ustream);
+ ret = lttng_ust_ctl_get_next_subbuf(stream->ustream);
if (ret == 0) {
/*
* There is still data so let's put back this
* subbuffer.
*/
- ret = ustctl_put_subbuf(stream->ustream);
- assert(ret == 0);
+ ret = lttng_ust_ctl_put_subbuf(stream->ustream);
+ 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");
{
int ret;
- ret = ustctl_stream_close_wakeup_fd(stream->ustream);
+ ret = lttng_ust_ctl_stream_close_wakeup_fd(stream->ustream);
if (ret < 0) {
ERR("Unable to close wakeup fd");
}
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 ustctl_get_stream_id(stream->ustream, 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