/*
- * 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
}
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:
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);
* 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);
* 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:
/*
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_ust_ctl_flush_buffer(stream->ustream, producer_active);
+ return lttng_ust_ctl_flush_buffer(stream->ustream, producer_active);
}
/*
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_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_ust_ctl_clear_buffer(stream->ustream);
+ return lttng_ust_ctl_clear_buffer(stream->ustream);
}
int lttng_ustconsumer_get_current_timestamp(
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;
* 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;
return lttng_ust_ctl_get_stream_id(stream->ustream, stream_id);
}
+
+void lttng_ustconsumer_sigbus_handle(void *addr)
+{
+ lttng_ust_ctl_sigbus_handle(addr);
+}