end:
rcu_read_unlock();
+ if (session) {
+ session_put(session);
+ }
}
/*
ust_registry_channel_del_free(registry, ua_chan->key,
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);
}
int ret;
struct buffer_reg_uid *reg_uid;
struct buffer_reg_channel *reg_chan;
- struct ltt_session *session;
+ struct ltt_session *session = NULL;
enum lttng_error_code notification_ret;
struct ust_registry_channel *chan_reg;
}
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;
}
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;
+ struct ltt_session *session = NULL;
assert(ua_sess);
assert(app);
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;
}
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) {
}
rcu_read_unlock();
+end:
return ret;
}
* 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;
+ struct ltt_session *session = NULL;
uint64_t trace_archive_id;
assert(usess);
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,
+ 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 (ret < 0) {
+ 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,
trace_archive_id);
- if (ret < 0) {
+ 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,
+ 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);
- if (ret < 0) {
- if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
- continue;
- }
+ switch (status) {
+ case LTTNG_OK:
+ break;
+ case LTTNG_ERR_CHAN_NOT_FOUND:
+ continue;
+ default:
goto error;
}
}
DBG("Application session is being torn down. Skip application.");
continue;
}
- ret = consumer_snapshot_channel(socket,
+ status = consumer_snapshot_channel(socket,
registry->metadata_key, output,
1, ua_sess->euid, ua_sess->egid,
pathname, wait, 0,
trace_archive_id);
- if (ret < 0) {
- if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
- continue;
- }
+ 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;
}
/*
projects / lttng-tools.git / blobdiff