Fix enabled state when listing UST events

[lttng-tools.git] / lttng-sessiond / trace-ust.c

diff --git a/lttng-sessiond/trace-ust.c b/lttng-sessiond/trace-ust.c
index 3e1055a8ba8e990556ebd41b1a1f7748a6ff08d9..a0d3b1b4165fc26fa87149db9f8a1bf3075a7613 100644 (file)
--- a/lttng-sessiond/trace-ust.c
+++ b/lttng-sessiond/trace-ust.c
@@ -70,11 +70,12 @@ struct ltt_ust_event *trace_ust_find_event_by_name(struct cds_lfht *ht,
        }
        rcu_read_unlock();
 
-       DBG2("Found UST event by name %s", name);
+       DBG2("Trace UST event found by name %s", name);
 
        return caa_container_of(node, struct ltt_ust_event, node);
 
 error:
+       DBG2("Trace UST event NOT found by name %s", name);
        return NULL;
 }
 
@@ -92,13 +93,14 @@ struct ltt_ust_session *trace_ust_create_session(char *path, unsigned int uid,
        /* Allocate a new ltt ust session */
        lus = malloc(sizeof(struct ltt_ust_session));
        if (lus == NULL) {
-               perror("create ust session malloc");
+               PERROR("create ust session malloc");
                goto error;
        }
 
        /* Init data structure */
        lus->consumer_fds_sent = 0;
        lus->uid = uid;
+       lus->start_trace = 0;
 
        /* Alloc UST domain hash tables */
        lus->domain_pid = hashtable_new(0);
@@ -111,13 +113,15 @@ struct ltt_ust_session *trace_ust_create_session(char *path, unsigned int uid,
        ret = snprintf(lus->pathname, PATH_MAX, "%s/ust", path);
        if (ret < 0) {
                PERROR("snprintf kernel traces path");
-               goto error;
+               goto error_free_session;
        }
 
        DBG2("UST trace session create successful");
 
        return lus;
 
+error_free_session:
+       free(lus);
 error:
        return NULL;
 }
@@ -133,7 +137,7 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan,
        int ret;
        struct ltt_ust_channel *luc;
 
-       luc = malloc(sizeof(struct ltt_ust_channel));
+       luc = zmalloc(sizeof(struct ltt_ust_channel));
        if (luc == NULL) {
                perror("ltt_ust_channel malloc");
                goto error;
@@ -168,13 +172,15 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan,
        ret = snprintf(luc->pathname, PATH_MAX, "%s", path);
        if (ret < 0) {
                perror("asprintf ust create channel");
-               goto error;
+               goto error_free_channel;
        }
 
        DBG2("Trace UST channel %s created", luc->name);
 
        return luc;
 
+error_free_channel:
+       free(luc);
 error:
        return NULL;
 }
@@ -188,7 +194,7 @@ struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev)
 {
        struct ltt_ust_event *lue;
 
-       lue = malloc(sizeof(struct ltt_ust_event));
+       lue = zmalloc(sizeof(struct ltt_ust_event));
        if (lue == NULL) {
                PERROR("ust event malloc");
                goto error;
@@ -209,7 +215,7 @@ struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev)
                break;
        default:
                ERR("Unknown ust instrumentation type (%d)", ev->type);
-               goto error;
+               goto error_free_event;
        }
 
        /* Copy event name */
@@ -220,10 +226,14 @@ struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev)
        hashtable_node_init(&lue->node, (void *) lue->attr.name,
                        strlen(lue->attr.name));
        /* Alloc context hash tables */
-       lue->ctx = hashtable_new_str(5);
+       lue->ctx = hashtable_new_str(0);
+
+       DBG2("Trace UST event %s created", lue->attr.name);
 
        return lue;
 
+error_free_event:
+       free(lue);
 error:
        return NULL;
 }
@@ -238,7 +248,7 @@ struct ltt_ust_metadata *trace_ust_create_metadata(char *path)
        int ret;
        struct ltt_ust_metadata *lum;
 
-       lum = malloc(sizeof(struct ltt_ust_metadata));
+       lum = zmalloc(sizeof(struct ltt_ust_metadata));
        if (lum == NULL) {
                perror("ust metadata malloc");
                goto error;
@@ -257,11 +267,13 @@ struct ltt_ust_metadata *trace_ust_create_metadata(char *path)
        ret = snprintf(lum->pathname, PATH_MAX, "%s/metadata", path);
        if (ret < 0) {
                perror("asprintf ust metadata");
-               goto error;
+               goto error_free_metadata;
        }
 
        return lum;
 
+error_free_metadata:
+       free(lum);
 error:
        return NULL;
 }
@@ -288,14 +300,14 @@ static void destroy_context(struct cds_lfht *ht)
        struct cds_lfht_node *node;
        struct cds_lfht_iter iter;
 
-       hashtable_get_first(ht, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+       cds_lfht_for_each(ht, &iter, node) {
                ret = hashtable_del(ht, &iter);
                if (!ret) {
                        call_rcu(&node->head, destroy_context_rcu);
                }
-               hashtable_get_next(ht, &iter);
        }
+
+       hashtable_destroy(ht);
 }
 
 /*
@@ -305,6 +317,7 @@ void trace_ust_destroy_event(struct ltt_ust_event *event)
 {
        DBG2("Trace destroy UST event %s", event->attr.name);
        destroy_context(event->ctx);
+
        free(event);
 }
 
@@ -321,6 +334,25 @@ static void destroy_event_rcu(struct rcu_head *head)
        trace_ust_destroy_event(event);
 }
 
+/*
+ * Cleanup UST events hashtable.
+ */
+static void destroy_event(struct cds_lfht *events)
+{
+       int ret;
+       struct cds_lfht_node *node;
+       struct cds_lfht_iter iter;
+
+       cds_lfht_for_each(events, &iter, node) {
+               ret = hashtable_del(events, &iter);
+               if (!ret) {
+                       call_rcu(&node->head, destroy_event_rcu);
+               }
+       }
+
+       hashtable_destroy(events);
+}
+
 /*
  * Cleanup ust channel structure.
  */
@@ -334,16 +366,13 @@ void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
 
        rcu_read_lock();
 
-       hashtable_get_first(channel->events, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+       cds_lfht_for_each(channel->events, &iter, node) {
                ret = hashtable_del(channel->events, &iter);
                if (!ret) {
-                       call_rcu(&node->head, destroy_event_rcu);
+                       destroy_event(channel->events);
                }
-               hashtable_get_next(channel->events, &iter);
        }
 
-       free(channel->events);
        destroy_context(channel->ctx);
        free(channel);
 
@@ -382,14 +411,14 @@ static void destroy_channels(struct cds_lfht *channels)
        struct cds_lfht_node *node;
        struct cds_lfht_iter iter;
 
-       hashtable_get_first(channels, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+       cds_lfht_for_each(channels, &iter, node) {
                ret = hashtable_del(channels, &iter);
                if (!ret) {
                        call_rcu(&node->head, destroy_channel_rcu);
                }
-               hashtable_get_next(channels, &iter);
        }
+
+       hashtable_destroy(channels);
 }
 
 /*
@@ -398,19 +427,17 @@ static void destroy_channels(struct cds_lfht *channels)
 static void destroy_domain_pid(struct cds_lfht *ht)
 {
        int ret;
-       struct cds_lfht_node *node;
        struct cds_lfht_iter iter;
-       struct ltt_ust_domain_pid *d;
+       struct ltt_ust_domain_pid *dpid;
 
-       hashtable_get_first(ht, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+       cds_lfht_for_each_entry(ht, &iter, dpid, node) {
                ret = hashtable_del(ht , &iter);
                if (!ret) {
-                       d = caa_container_of(node, struct ltt_ust_domain_pid, node);
-                       destroy_channels(d->channels);
+                       destroy_channels(dpid->channels);
                }
-               hashtable_get_next(ht, &iter);
        }
+
+       hashtable_destroy(ht);
 }
 
 /*
@@ -419,19 +446,17 @@ static void destroy_domain_pid(struct cds_lfht *ht)
 static void destroy_domain_exec(struct cds_lfht *ht)
 {
        int ret;
-       struct cds_lfht_node *node;
        struct cds_lfht_iter iter;
-       struct ltt_ust_domain_exec *d;
+       struct ltt_ust_domain_exec *dexec;
 
-       hashtable_get_first(ht, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+       cds_lfht_for_each_entry(ht, &iter, dexec, node) {
                ret = hashtable_del(ht , &iter);
                if (!ret) {
-                       d = caa_container_of(node, struct ltt_ust_domain_exec, node);
-                       destroy_channels(d->channels);
+                       destroy_channels(dexec->channels);
                }
-               hashtable_get_next(ht, &iter);
        }
+
+       hashtable_destroy(ht);
 }
 
 /*
@@ -447,7 +472,7 @@ static void destroy_domain_global(struct ltt_ust_domain_global *dom)
  */
 void trace_ust_destroy_session(struct ltt_ust_session *session)
 {
-       /* Extra safety */
+       /* Extra protection */
        if (session == NULL) {
                return;
        }
@@ -456,10 +481,6 @@ void trace_ust_destroy_session(struct ltt_ust_session *session)
 
        DBG2("Trace UST destroy session %d", session->uid);
 
-       //if (session->metadata != NULL) {
-       //      trace_ust_destroy_metadata(session->metadata);
-       //}
-
        /* Cleaning up UST domain */
        destroy_domain_global(&session->domain_global);
        destroy_domain_pid(session->domain_pid);