/*
- * Copyright (C) 2011 Julien Desfossez <julien.desfossez@polymtl.ca>
+ * Copyright (C) 2011 EfficiOS Inc.
* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
* Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
#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;
+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
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);
}
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;
* 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);
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;
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;
}
}
/* 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;
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
}
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:
metadata_stream = metadata_channel->metadata_stream;
assert(metadata_stream);
- pthread_mutex_lock(&metadata_stream->lock);
+ metadata_stream->read_subbuffer_ops.lock(metadata_stream);
if (relayd_id != (uint64_t) -1ULL) {
metadata_stream->net_seq_idx = relayd_id;
ret = consumer_send_relayd_stream(metadata_stream, path);
ret = consumer_stream_create_output_files(metadata_stream,
false);
}
- pthread_mutex_unlock(&metadata_stream->lock);
if (ret < 0) {
goto error_stream;
}
do {
health_code_update();
-
ret = lttng_consumer_read_subbuffer(metadata_stream, ctx, true);
if (ret < 0) {
goto error_stream;
} while (ret > 0);
error_stream:
+ metadata_stream->read_subbuffer_ops.unlock(metadata_stream);
/*
- * Clean up the stream completly because the next snapshot will use a new
- * metadata stream.
+ * Clean up the stream completely because the next snapshot will use a
+ * new metadata stream.
*/
consumer_stream_destroy(metadata_stream, NULL);
cds_list_del(&metadata_stream->send_node);
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;
* 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);
* metadata position to ensure the metadata poll thread consumes
* the whole cache.
*/
- pthread_mutex_lock(&channel->metadata_stream->lock);
- metadata_stream_reset_cache_consumed_position(
- channel->metadata_stream);
- pthread_mutex_unlock(&channel->metadata_stream->lock);
+
+ /*
+ * channel::metadata_stream can be null when the metadata
+ * channel is under a snapshot session type. No need to update
+ * the stream position in that scenario.
+ */
+ if (channel->metadata_stream != NULL) {
+ pthread_mutex_lock(&channel->metadata_stream->lock);
+ metadata_stream_reset_cache_consumed_position(
+ channel->metadata_stream);
+ pthread_mutex_unlock(&channel->metadata_stream->lock);
+ } else {
+ /* Validate we are in snapshot mode. */
+ assert(!channel->monitor);
+ }
/* Fall-through. */
case CONSUMER_METADATA_CACHE_WRITE_STATUS_APPENDED_CONTENT:
/*
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),
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);
- ustctl_flush_buffer(stream->ustream, producer_active);
+ return lttng_ust_ctl_flush_buffer(stream->ustream, producer_active);
}
/*
assert(stream);
assert(stream->ustream);
- return ustctl_snapshot(stream->ustream);
+ return lttng_ust_ctl_snapshot(stream->ustream);
}
/*
assert(stream);
assert(stream->ustream);
- return ustctl_snapshot_sample_positions(stream->ustream);
+ return lttng_ust_ctl_snapshot_sample_positions(stream->ustream);
}
/*
assert(stream->ustream);
assert(pos);
- return ustctl_snapshot_get_produced(stream->ustream, pos);
+ return lttng_ust_ctl_snapshot_get_produced(stream->ustream, pos);
}
/*
assert(stream->ustream);
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);
- 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);
- ustctl_clear_buffer(stream->ustream);
+ return lttng_ust_ctl_clear_buffer(stream->ustream);
}
int lttng_ustconsumer_get_current_timestamp(
assert(stream->ustream);
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(
assert(stream->ustream);
assert(seq);
- return ustctl_get_sequence_number(stream->ustream, seq);
+ return lttng_ust_ctl_get_sequence_number(stream->ustream, seq);
}
/*
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;
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,
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);
- 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);
- 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);
* 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;
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);
* 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);
+ ret = lttng_ust_ctl_put_subbuf(ustream);
assert(!ret);
/* This stream still has data. Flag it and wake up the data thread. */
{
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. */
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);
return ret;
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);
+ ret = lttng_ust_ctl_put_subbuf(stream->ustream);
assert(ret == 0);
ret = 1; /* Data is pending */
goto end;
{
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");
}
assert(stream);
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);
}