end:
rcu_read_unlock();
+ if (session) {
+ session_put(session);
+ }
}
/*
registry = get_session_registry(ua_chan->session);
if (registry) {
ust_registry_channel_del_free(registry, ua_chan->key,
- true);
+ sock >= 0);
+ }
+ /*
+ * A negative socket can be used by the caller when
+ * cleaning-up a ua_chan in an error path. Skip the
+ * accounting in this case.
+ */
+ if (sock >= 0) {
+ save_per_pid_lost_discarded_counters(ua_chan);
}
- save_per_pid_lost_discarded_counters(ua_chan);
}
if (ua_chan->obj != NULL) {
* Called with UST app session lock held and a RCU read side lock.
*/
static
-int create_ust_app_channel_context(struct ust_app_session *ua_sess,
- struct ust_app_channel *ua_chan,
+int create_ust_app_channel_context(struct ust_app_channel *ua_chan,
struct lttng_ust_context_attr *uctx,
struct ust_app *app)
{
*/
static int do_consumer_create_channel(struct ltt_ust_session *usess,
struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
- int bitness, struct ust_registry_session *registry)
+ int bitness, struct ust_registry_session *registry,
+ uint64_t trace_archive_id)
{
int ret;
unsigned int nb_fd = 0;
* stream we have to expect.
*/
ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
- registry);
+ registry, trace_archive_id);
if (ret < 0) {
goto error_ask;
}
int ret;
struct buffer_reg_uid *reg_uid;
struct buffer_reg_channel *reg_chan;
+ struct ltt_session *session = NULL;
+ enum lttng_error_code notification_ret;
+ struct ust_registry_channel *chan_reg;
assert(app);
assert(usess);
goto error;
}
+ session = session_find_by_id(ua_sess->tracing_id);
+ assert(session);
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+
/*
* Create the buffers on the consumer side. This call populates the
* ust app channel object with all streams and data object.
*/
ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
- app->bits_per_long, reg_uid->registry->reg.ust);
+ app->bits_per_long, reg_uid->registry->reg.ust,
+ session->current_archive_id);
if (ret < 0) {
ERR("Error creating UST channel \"%s\" on the consumer daemon",
ua_chan->name);
goto error;
}
- {
- enum lttng_error_code cmd_ret;
- struct ltt_session *session;
- uint64_t chan_reg_key;
- struct ust_registry_channel *chan_reg;
-
- chan_reg_key = ua_chan->tracing_channel_id;
+ /* Notify the notification subsystem of the channel's creation. */
+ pthread_mutex_lock(®_uid->registry->reg.ust->lock);
+ chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust,
+ ua_chan->tracing_channel_id);
+ assert(chan_reg);
+ chan_reg->consumer_key = ua_chan->key;
+ chan_reg = NULL;
+ pthread_mutex_unlock(®_uid->registry->reg.ust->lock);
- pthread_mutex_lock(®_uid->registry->reg.ust->lock);
- chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust,
- chan_reg_key);
- assert(chan_reg);
- chan_reg->consumer_key = ua_chan->key;
- chan_reg = NULL;
- pthread_mutex_unlock(®_uid->registry->reg.ust->lock);
-
- session = session_find_by_id(ua_sess->tracing_id);
- assert(session);
-
- assert(pthread_mutex_trylock(&session->lock));
- assert(session_trylock_list());
- cmd_ret = notification_thread_command_add_channel(
- notification_thread_handle, session->name,
- ua_sess->euid, ua_sess->egid,
- ua_chan->name,
- ua_chan->key,
- LTTNG_DOMAIN_UST,
- ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
- if (cmd_ret != LTTNG_OK) {
- ret = - (int) cmd_ret;
- ERR("Failed to add channel to notification thread");
- goto error;
- }
+ notification_ret = notification_thread_command_add_channel(
+ notification_thread_handle, session->name,
+ ua_sess->euid, ua_sess->egid,
+ ua_chan->name,
+ ua_chan->key,
+ LTTNG_DOMAIN_UST,
+ ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
+ if (notification_ret != LTTNG_OK) {
+ ret = - (int) notification_ret;
+ ERR("Failed to add channel to notification thread");
+ goto error;
}
send_channel:
}
error:
+ if (session) {
+ session_put(session);
+ }
return ret;
}
int ret;
struct ust_registry_session *registry;
enum lttng_error_code cmd_ret;
- struct ltt_session *session;
+ struct ltt_session *session = NULL;
uint64_t chan_reg_key;
struct ust_registry_channel *chan_reg;
goto error;
}
+ session = session_find_by_id(ua_sess->tracing_id);
+ assert(session);
+
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+
/* Create and get channel on the consumer side. */
ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
- app->bits_per_long, registry);
+ app->bits_per_long, registry,
+ session->current_archive_id);
if (ret < 0) {
ERR("Error creating UST channel \"%s\" on the consumer daemon",
ua_chan->name);
- goto error;
+ goto error_remove_from_registry;
}
ret = send_channel_pid_to_ust(app, ua_sess, ua_chan);
if (ret != -ENOTCONN) {
ERR("Error sending channel to application");
}
- goto error;
+ goto error_remove_from_registry;
}
- session = session_find_by_id(ua_sess->tracing_id);
- assert(session);
-
chan_reg_key = ua_chan->key;
pthread_mutex_lock(®istry->lock);
chan_reg = ust_registry_channel_find(registry, chan_reg_key);
chan_reg->consumer_key = ua_chan->key;
pthread_mutex_unlock(®istry->lock);
- assert(pthread_mutex_trylock(&session->lock));
- assert(session_trylock_list());
-
cmd_ret = notification_thread_command_add_channel(
notification_thread_handle, session->name,
ua_sess->euid, ua_sess->egid,
if (cmd_ret != LTTNG_OK) {
ret = - (int) cmd_ret;
ERR("Failed to add channel to notification thread");
- goto error;
+ goto error_remove_from_registry;
}
+error_remove_from_registry:
+ if (ret) {
+ ust_registry_channel_del_free(registry, ua_chan->key, false);
+ }
error:
rcu_read_unlock();
+ if (session) {
+ session_put(session);
+ }
return ret;
}
struct ust_app_channel *metadata;
struct consumer_socket *socket;
struct ust_registry_session *registry;
+ struct ltt_session *session = NULL;
assert(ua_sess);
assert(app);
*/
registry->metadata_key = metadata->key;
+ session = session_find_by_id(ua_sess->tracing_id);
+ assert(session);
+
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+
/*
* Ask the metadata channel creation to the consumer. The metadata object
* will be created by the consumer and kept their. However, the stream is
* consumer.
*/
ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
- registry);
+ registry, session->current_archive_id);
if (ret < 0) {
/* Nullify the metadata key so we don't try to close it later on. */
registry->metadata_key = 0;
delete_ust_app_channel(-1, metadata, app);
error:
pthread_mutex_unlock(®istry->lock);
+ if (session) {
+ session_put(session);
+ }
return ret;
}
rcu_read_lock();
+ /* Cleanup notify socket hash table */
+ if (ust_app_ht_by_notify_sock) {
+ cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
+ notify_sock_n.node) {
+ struct cds_lfht_node *node;
+ struct ust_app *app;
+
+ node = cds_lfht_iter_get_node(&iter.iter);
+ if (!node) {
+ continue;
+ }
+
+ app = container_of(node, struct ust_app,
+ notify_sock_n.node);
+ ust_app_notify_sock_unregister(app->notify_sock);
+ }
+ }
+
if (ust_app_ht) {
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
ret = lttng_ht_del(ust_app_ht, &iter);
}
}
- /* Cleanup notify socket hash table */
- if (ust_app_ht_by_notify_sock) {
- cds_lfht_for_each_entry(ust_app_ht_by_notify_sock->ht, &iter.iter, app,
- notify_sock_n.node) {
- ret = lttng_ht_del(ust_app_ht_by_notify_sock, &iter);
- assert(!ret);
- }
- }
rcu_read_unlock();
/* Destroy is done only when the ht is empty */
DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
uchan->name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
/* For every registered applications */
rcu_read_unlock();
error:
+end:
return ret;
}
DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
uchan->name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
/* For every registered applications */
rcu_read_unlock();
error:
+end:
return ret;
}
"%s for session id %" PRIu64,
uevent->attr.name, uchan->name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
/* For all registered applications */
}
rcu_read_unlock();
-
+end:
return ret;
}
DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
uchan->name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
/* For every registered applications */
error_rcu_unlock:
rcu_read_unlock();
+end:
return ret;
}
DBG("UST app enabling event %s for all apps for session id %" PRIu64,
uevent->attr.name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
/*
* NOTE: At this point, this function is called only if the session and
* channel passed are already created for all apps. and enabled on the
error:
rcu_read_unlock();
+end:
return ret;
}
DBG("UST app creating event %s for all apps for session id %" PRIu64,
uevent->attr.name, usess->id);
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
/* For all registered applications */
}
rcu_read_unlock();
-
+end:
return ret;
}
usess->consumer->dst.session_root_path,
usess->consumer->chunk_path,
usess->consumer->subdir);
+ free(tmp_path);
goto error_unlock;
}
DBG("Starting all UST traces");
+ /*
+ * Even though the start trace might fail, flag this session active so
+ * other application coming in are started by default.
+ */
+ usess->active = 1;
+
rcu_read_lock();
/*
*/
(void) ust_app_clear_quiescent_session(usess);
+ cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
+ ust_app_global_update(usess, app);
+ }
+
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
ret = ust_app_start_trace(usess, app);
if (ret < 0) {
DBG("Stopping all UST traces");
+ /*
+ * Even though the stop trace might fail, flag this session inactive so
+ * other application coming in are not started by default.
+ */
+ usess->active = 0;
+
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
/* App session already created. */
goto end;
}
+ if (!usess->active) {
+ goto end;
+ }
assert(ua_sess);
pthread_mutex_lock(&ua_sess->lock);
pthread_mutex_unlock(&ua_sess->lock);
- if (usess->active) {
- ret = ust_app_start_trace(usess, app);
- if (ret < 0) {
- goto error;
- }
-
- DBG2("UST trace started for app pid %d", app->pid);
+ ret = ust_app_start_trace(usess, app);
+ if (ret < 0) {
+ goto error;
}
+
+ DBG2("UST trace started for app pid %d", app->pid);
end:
/* Everything went well at this point. */
return;
if (!app->compatible) {
return;
}
-
+ if (!usess->active) {
+ return;
+ }
if (trace_ust_pid_tracker_lookup(usess, app->pid)) {
ust_app_global_create(usess, app);
} else {
struct lttng_ht_iter iter;
struct ust_app *app;
+ if (!usess->active) {
+ return;
+ }
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
ust_app_global_update(usess, app);
struct ust_app_session *ua_sess;
struct ust_app *app;
+ if (!usess->active) {
+ goto end;
+ }
+
rcu_read_lock();
cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
}
ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
node);
- ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
+ ret = create_ust_app_channel_context(ua_chan, &uctx->ctx, app);
if (ret < 0) {
goto next_app;
}
}
rcu_read_unlock();
+end:
return ret;
}
*
* On success 0 is returned else a negative value.
*/
-static int reply_ust_register_channel(int sock, int sobjd, int cobjd,
+static int reply_ust_register_channel(int sock, int cobjd,
size_t nr_fields, struct ustctl_field *fields)
{
int ret, ret_code = 0;
- uint32_t chan_id, reg_count;
+ uint32_t chan_id;
uint64_t chan_reg_key;
enum ustctl_channel_header type;
struct ust_app *app;
assert(chan_reg);
if (!chan_reg->register_done) {
- reg_count = ust_registry_get_event_count(chan_reg);
- if (reg_count < 31) {
- type = USTCTL_CHANNEL_HEADER_COMPACT;
- } else {
- type = USTCTL_CHANNEL_HEADER_LARGE;
- }
-
+ /*
+ * TODO: eventually use the registry event count for
+ * this channel to better guess header type for per-pid
+ * buffers.
+ */
+ type = USTCTL_CHANNEL_HEADER_LARGE;
chan_reg->nr_ctx_fields = nr_fields;
chan_reg->ctx_fields = fields;
fields = NULL;
* that if needed it will be freed. After this, it's invalid to access
* fields or clean it up.
*/
- ret = reply_ust_register_channel(sock, sobjd, cobjd, nr_fields,
+ ret = reply_ust_register_channel(sock, cobjd, nr_fields,
fields);
if (ret < 0) {
goto error;
* Take a snapshot for a given UST session. The snapshot is sent to the given
* output.
*
- * Return 0 on success or else a negative value.
+ * Returns LTTNG_OK on success or a LTTNG_ERR error code.
*/
-int ust_app_snapshot_record(struct ltt_ust_session *usess,
+enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
struct snapshot_output *output, int wait,
uint64_t nb_packets_per_stream)
{
int ret = 0;
+ enum lttng_error_code status = LTTNG_OK;
struct lttng_ht_iter iter;
struct ust_app *app;
char pathname[PATH_MAX];
+ struct ltt_session *session = NULL;
+ uint64_t trace_archive_id;
assert(usess);
assert(output);
rcu_read_lock();
+ session = session_find_by_id(usess->id);
+ assert(session);
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+ trace_archive_id = session->current_archive_id;
+
switch (usess->buffer_type) {
case LTTNG_BUFFER_PER_UID:
{
struct buffer_reg_channel *reg_chan;
struct consumer_socket *socket;
+ if (!reg->registry->reg.ust->metadata_key) {
+ /* Skip since no metadata is present */
+ continue;
+ }
+
/* Get consumer socket to use to push the metadata.*/
socket = consumer_find_socket_by_bitness(reg->bits_per_long,
usess->consumer);
if (!socket) {
- ret = -EINVAL;
+ status = LTTNG_ERR_INVALID;
goto error;
}
reg->uid, reg->bits_per_long);
if (ret < 0) {
PERROR("snprintf snapshot path");
+ status = LTTNG_ERR_INVALID;
goto error;
}
/* Add the UST default trace dir to path. */
cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
reg_chan, node.node) {
- ret = consumer_snapshot_channel(socket, reg_chan->consumer_key,
- output, 0, usess->uid, usess->gid, pathname, wait,
- nb_packets_per_stream);
- if (ret < 0) {
+ status = consumer_snapshot_channel(socket,
+ reg_chan->consumer_key,
+ output, 0, usess->uid,
+ usess->gid, pathname, wait,
+ nb_packets_per_stream,
+ trace_archive_id);
+ if (status != LTTNG_OK) {
goto error;
}
}
- ret = consumer_snapshot_channel(socket,
+ status = consumer_snapshot_channel(socket,
reg->registry->reg.ust->metadata_key, output, 1,
- usess->uid, usess->gid, pathname, wait, 0);
- if (ret < 0) {
+ usess->uid, usess->gid, pathname, wait, 0,
+ trace_archive_id);
+ if (status != LTTNG_OK) {
goto error;
}
}
socket = consumer_find_socket_by_bitness(app->bits_per_long,
output->consumer);
if (!socket) {
- ret = -EINVAL;
+ status = LTTNG_ERR_INVALID;
goto error;
}
ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s",
ua_sess->path);
if (ret < 0) {
+ status = LTTNG_ERR_INVALID;
PERROR("snprintf snapshot path");
goto error;
}
cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
ua_chan, node.node) {
- ret = consumer_snapshot_channel(socket, ua_chan->key, output,
- 0, ua_sess->euid, ua_sess->egid, pathname, wait,
- nb_packets_per_stream);
- if (ret < 0) {
+ status = consumer_snapshot_channel(socket,
+ ua_chan->key, output,
+ 0, ua_sess->euid, ua_sess->egid,
+ pathname, wait,
+ nb_packets_per_stream,
+ trace_archive_id);
+ switch (status) {
+ case LTTNG_OK:
+ break;
+ case LTTNG_ERR_CHAN_NOT_FOUND:
+ continue;
+ default:
goto error;
}
}
registry = get_session_registry(ua_sess);
if (!registry) {
- DBG("Application session is being torn down. Abort snapshot record.");
- ret = -1;
- goto error;
+ DBG("Application session is being torn down. Skip application.");
+ continue;
}
- ret = consumer_snapshot_channel(socket, registry->metadata_key, output,
- 1, ua_sess->euid, ua_sess->egid, pathname, wait, 0);
- if (ret < 0) {
+ status = consumer_snapshot_channel(socket,
+ registry->metadata_key, output,
+ 1, ua_sess->euid, ua_sess->egid,
+ pathname, wait, 0,
+ trace_archive_id);
+ switch (status) {
+ case LTTNG_OK:
+ break;
+ case LTTNG_ERR_CHAN_NOT_FOUND:
+ continue;
+ default:
goto error;
}
}
error:
rcu_read_unlock();
- return ret;
+ if (session) {
+ session_put(session);
+ }
+ return status;
}
/*
/*
* Rotate all the channels of a session.
*
- * Return 0 on success or else a negative value.
+ * Return LTTNG_OK on success or else an LTTng error code.
*/
-int ust_app_rotate_session(struct ltt_session *session, bool *ust_active)
+enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
{
- int ret = 0;
+ int ret;
+ enum lttng_error_code cmd_ret = LTTNG_OK;
struct lttng_ht_iter iter;
struct ust_app *app;
struct ltt_ust_session *usess = session->ust_session;
socket = consumer_find_socket_by_bitness(reg->bits_per_long,
usess->consumer);
if (!socket) {
- ret = -EINVAL;
- goto error;
- }
-
- /*
- * Account the metadata channel first to make sure the
- * number of channels waiting for a rotation cannot
- * reach 0 before we complete the iteration over all
- * the channels.
- */
- ret = rotate_add_channel_pending(
- reg->registry->reg.ust->metadata_key,
- LTTNG_DOMAIN_UST, session);
- if (ret < 0) {
- ret = reg->bits_per_long == 32 ?
- -LTTNG_ERR_UST_CONSUMER32_FAIL :
- -LTTNG_ERR_UST_CONSUMER64_FAIL;
+ cmd_ret = LTTNG_ERR_INVALID;
goto error;
}
reg->uid, reg->bits_per_long);
if (ret < 0 || ret == sizeof(pathname)) {
PERROR("Failed to format rotation path");
+ cmd_ret = LTTNG_ERR_INVALID;
goto error;
}
/* Rotate the data channels. */
cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
reg_chan, node.node) {
- ret = rotate_add_channel_pending(
- reg_chan->consumer_key,
- LTTNG_DOMAIN_UST, session);
- if (ret < 0) {
- ret = reg->bits_per_long == 32 ?
- -LTTNG_ERR_UST_CONSUMER32_FAIL :
- -LTTNG_ERR_UST_CONSUMER64_FAIL;
- goto error;
- }
ret = consumer_rotate_channel(socket,
reg_chan->consumer_key,
usess->uid, usess->gid,
usess->consumer, pathname,
/* is_metadata_channel */ false,
- session->current_archive_id,
- &session->rotate_pending_relay);
+ session->current_archive_id);
if (ret < 0) {
+ cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
goto error;
}
}
usess->uid, usess->gid,
usess->consumer, pathname,
/* is_metadata_channel */ true,
- session->current_archive_id,
- &session->rotate_pending_relay);
+ session->current_archive_id);
if (ret < 0) {
+ cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
goto error;
}
- *ust_active = true;
}
break;
}
ua_sess->path);
if (ret < 0 || ret == sizeof(pathname)) {
PERROR("Failed to format rotation path");
+ cmd_ret = LTTNG_ERR_INVALID;
goto error;
}
socket = consumer_find_socket_by_bitness(app->bits_per_long,
usess->consumer);
if (!socket) {
- ret = -EINVAL;
+ cmd_ret = LTTNG_ERR_INVALID;
goto error;
}
registry = get_session_registry(ua_sess);
if (!registry) {
- DBG("Application session is being torn down. Abort snapshot record.");
- ret = -1;
- goto error;
+ DBG("Application session is being torn down. Skip application.");
+ continue;
}
- /*
- * Account the metadata channel first to make sure the
- * number of channels waiting for a rotation cannot
- * reach 0 before we complete the iteration over all
- * the channels.
- */
- ret = rotate_add_channel_pending(registry->metadata_key,
- LTTNG_DOMAIN_UST, session);
- if (ret < 0) {
- ret = app->bits_per_long == 32 ?
- -LTTNG_ERR_UST_CONSUMER32_FAIL :
- -LTTNG_ERR_UST_CONSUMER64_FAIL;
- goto error;
- }
/* Rotate the data channels. */
cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
ua_chan, node.node) {
- ret = rotate_add_channel_pending(
- ua_chan->key, LTTNG_DOMAIN_UST,
- session);
- if (ret < 0) {
- ret = app->bits_per_long == 32 ?
- -LTTNG_ERR_UST_CONSUMER32_FAIL :
- -LTTNG_ERR_UST_CONSUMER64_FAIL;
- goto error;
- }
ret = consumer_rotate_channel(socket, ua_chan->key,
ua_sess->euid, ua_sess->egid,
ua_sess->consumer, pathname,
/* is_metadata_channel */ false,
- session->current_archive_id,
- &session->rotate_pending_relay);
+ session->current_archive_id);
if (ret < 0) {
+ /* Per-PID buffer and application going away. */
+ if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
+ continue;
+ cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
goto error;
}
}
ua_sess->euid, ua_sess->egid,
ua_sess->consumer, pathname,
/* is_metadata_channel */ true,
- session->current_archive_id,
- &session->rotate_pending_relay);
+ session->current_archive_id);
if (ret < 0) {
+ /* Per-PID buffer and application going away. */
+ if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
+ continue;
+ cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
goto error;
}
- *ust_active = true;
}
break;
}
break;
}
- ret = LTTNG_OK;
+ cmd_ret = LTTNG_OK;
error:
rcu_read_unlock();
- return ret;
+ return cmd_ret;
}