/* TODO : remove channel context */
//cds_lfht_for_each_entry(ltc->ctx, &iter, ltctx, node) {
- // hashtable_del(ltc->ctx, &iter);
+ // ret = hashtable_del(ltc->ctx, &iter);
+ // assert(!ret);
// delete_ust_app_ctx(sock, ltctx);
//}
//ret = hashtable_destroy(ltc->ctx);
cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
- hashtable_del(ua_chan->events, &iter);
+ ret = hashtable_del(ua_chan->events, &iter);
+ assert(!ret);
delete_ust_app_event(sock, ua_event);
}
}
cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
- hashtable_del(ua_sess->channels, &iter);
+ ret = hashtable_del(ua_sess->channels, &iter);
+ assert(!ret);
delete_ust_app_channel(sock, ua_chan);
}
app->key.sock = -1;
cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
- hashtable_del(app->sessions, &iter);
+ ret = hashtable_del(app->sessions, &iter);
+ assert(!ret);
delete_ust_app_session(app->key.sock, ua_sess);
}
goto error;
}
- ua_chan->enabled = 0;
-
DBG2("UST app channel %s disabled successfully for app (pid: %d)",
ua_chan->name, app->key.pid);
DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
ua_chan->name, app->key.pid, app->key.sock);
+ /* If channel is not enabled, disable it on the tracer */
+ if (!ua_chan->enabled) {
+ ret = disable_ust_channel(app, ua_sess, ua_chan);
+ if (ret < 0) {
+ goto error;
+ }
+ }
+
error:
return ret;
}
}
ua_event->handle = ua_event->obj->handle;
- ua_event->enabled = 1;
DBG2("UST app event %s created successfully for pid:%d",
ua_event->attr.name, app->key.pid);
+ /* If event not enabled, disable it on the tracer */
+ if (!ua_event->enabled) {
+ ret = disable_ust_event(app, ua_sess, ua_event);
+ if (ret < 0) {
+ goto error;
+ }
+ }
+
error:
return ret;
}
strncpy(ua_chan->name, name, sizeof(ua_chan->name));
ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
+ ua_chan->enabled = 1;
ua_chan->handle = -1;
ua_chan->ctx = hashtable_new(0);
ua_chan->events = hashtable_new_str(0);
goto error;
}
+ ua_event->enabled = 1;
strncpy(ua_event->name, name, sizeof(ua_event->name));
ua_event->name[sizeof(ua_event->name) - 1] = '\0';
ua_event->ctx = hashtable_new(0);
/*
* Lookup ust app channel for session and disable it on the tracer side.
*/
-static int disable_ust_app_channel(struct ust_app_session *ua_sess,
- struct ltt_ust_channel *uchan, struct ust_app *app)
+static
+int disable_ust_app_channel(struct ust_app_session *ua_sess,
+ struct ust_app_channel *ua_chan, struct ust_app *app)
{
- int ret = 0;
- struct cds_lfht_iter iter;
- struct cds_lfht_node *ua_chan_node;
- struct ust_app_channel *ua_chan;
-
- ua_chan_node = hashtable_lookup(ua_sess->channels,
- (void *)uchan->name, strlen(uchan->name), &iter);
- if (ua_chan_node == NULL) {
- DBG2("Unable to find channel %s in ust session uid %u",
- uchan->name, ua_sess->uid);
- goto error;
- }
-
- ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
+ int ret;
ret = disable_ust_channel(app, ua_sess, ua_chan);
if (ret < 0) {
goto error;
}
+ ua_chan->enabled = 0;
+
error:
return ret;
}
goto error;
}
+ ua_event->enabled = 1;
+
hashtable_add_unique(ua_chan->events, &ua_event->node);
end:
struct ust_app *lta;
struct cds_lfht_node *node;
struct cds_lfht_iter iter;
+ int ret;
rcu_read_lock();
lta = find_app_by_sock(sock);
goto error;
}
- hashtable_del(ust_app_ht, &iter);
+ ret = hashtable_del(ust_app_ht, &iter);
+ assert(!ret);
call_rcu(&node->head, delete_ust_app_rcu);
error:
rcu_read_unlock();
cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
ret = hashtable_del(ust_app_ht, &iter);
- if (!ret) {
- call_rcu(&node->head, delete_ust_app_rcu);
- }
+ assert(!ret);
+ call_rcu(&node->head, delete_ust_app_rcu);
}
hashtable_destroy(ust_app_ht);
{
int ret = 0;
struct cds_lfht_iter iter;
+ struct cds_lfht_node *ua_chan_node;
struct ust_app *app;
struct ust_app_session *ua_sess;
+ struct ust_app_channel *ua_chan;
if (usess == NULL || uchan == NULL) {
ERR("Disabling UST global channel with NULL values");
goto error;
}
- DBG2("UST app disablling channel %s from global domain for session uid %d",
+ DBG2("UST app disabling channel %s from global domain for session uid %d",
uchan->name, usess->uid);
rcu_read_lock();
continue;
}
- /* Create channel onto application */
- ret = disable_ust_app_channel(ua_sess, uchan, app);
+ /* Get channel */
+ ua_chan_node = hashtable_lookup(ua_sess->channels,
+ (void *)uchan->name, strlen(uchan->name), &iter);
+ /* If the session if found for the app, the channel must be there */
+ assert(ua_chan_node);
+
+ ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
+ /* The channel must not be already disabled */
+ assert(ua_chan->enabled == 1);
+
+ /* Disable channel onto application */
+ ret = disable_ust_app_channel(ua_sess, ua_chan, app);
if (ret < 0) {
/* XXX: We might want to report this error at some point... */
continue;
struct lttng_ust_object_data obj;
struct cds_lfht_iter iter;
struct cds_lfht_node *node;
+ int ret;
DBG("Destroy tracing for ust app pid %d", app->key.pid);
goto error_rcu_unlock;
}
ua_sess = caa_container_of(node, struct ust_app_session, node);
- hashtable_del(app->sessions, &iter);
+ ret = hashtable_del(app->sessions, &iter);
+ assert(!ret);
delete_ust_app_session(app->key.sock, ua_sess);
obj.handle = ua_sess->handle;
obj.shm_fd = -1;