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);
+ lttng_ust_ctl_flush_buffer(stream->ustream, 0);
stream->quiescent = true;
}
next:
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);
+ lttng_ust_ctl_flush_buffer(stream->ustream, 0);
}
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);
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,
+void lttng_lttng_ust_ctl_flush_buffer(struct lttng_consumer_stream *stream,
int producer_active)
{
assert(stream);
assert(stream->ustream);
- ustctl_flush_buffer(stream->ustream, producer_active);
+ 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,
assert(stream);
assert(stream->ustream);
- ustctl_flush_buffer(stream->ustream, producer);
+ lttng_ust_ctl_flush_buffer(stream->ustream, producer);
}
void lttng_ustconsumer_clear_buffer(struct lttng_consumer_stream *stream)
assert(stream);
assert(stream->ustream);
- ustctl_clear_buffer(stream->ustream);
+ 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);
+ lttng_ust_ctl_flush_buffer(stream->ustream, 0);
stream->quiescent = true;
}
pthread_mutex_unlock(&stream->lock);
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);
+ lttng_ust_ctl_flush_buffer(stream->ustream, 1);
stream->quiescent = true;
end:
pthread_mutex_unlock(&stream->chan->metadata_cache->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);
* 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. */
{
int ret;
- ret = ustctl_get_next_subbuf(stream->ustream);
+ ret = lttng_ust_ctl_get_next_subbuf(stream->ustream);
if (ret) {
goto end;
}
unsigned long consumed_pos, produced_pos;
do {
- ret = ustctl_get_next_subbuf(stream->ustream);
+ ret = lttng_ust_ctl_get_next_subbuf(stream->ustream);
if (ret == 0) {
got_subbuffer = true;
} else {
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);
}
projects / lttng-tools.git / blobdiff