Cleanup ust-app.c and make it more modular
authorDavid Goulet <david.goulet@polymtl.ca>
Tue, 8 Nov 2011 23:08:00 +0000 (18:08 -0500)
committerDavid Goulet <david.goulet@polymtl.ca>
Tue, 8 Nov 2011 23:08:00 +0000 (18:08 -0500)
Signed-off-by: David Goulet <david.goulet@polymtl.ca>
lttng-sessiond/main.c
lttng-sessiond/ust-app.c
lttng-sessiond/ust-app.h

index 40ad9add84747538fe860662f95e5bf19f5a9a18..cc7885399c288a24cabf2c10dd9e431b6b0778de 100644 (file)
@@ -338,12 +338,6 @@ static void cleanup(void)
 
        DBG("Cleaning up");
 
-       /* <fun> */
-       MSG("%c[%d;%dm*** assert failed *** ==> %c[%dm%c[%d;%dm"
-               "Matthew, BEET driven development works!%c[%dm",
-               27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
-       /* </fun> */
-
        if (is_root) {
                DBG("Removing %s directory", LTTNG_RUNDIR);
                ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
@@ -388,6 +382,12 @@ static void cleanup(void)
 
        close(thread_quit_pipe[0]);
        close(thread_quit_pipe[1]);
+
+       /* <fun> */
+       MSG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
+                       "Matthew, BEET driven development works!%c[%dm",
+                       27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
+       /* </fun> */
 }
 
 /*
@@ -720,7 +720,9 @@ static void update_ust_app(int app_sock)
 
        /* For all tracing session(s) */
        cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
-               ust_app_global_update(sess->ust_session, app_sock);
+               if (sess->ust_session) {
+                       ust_app_global_update(sess->ust_session, app_sock);
+               }
        }
 }
 
@@ -1983,7 +1985,8 @@ static int cmd_enable_channel(struct ltt_session *session,
                        goto error;
                }
 
-               ret = ust_app_add_channel(usess, uchan);
+               /* Add channel to all registered applications */
+               ret = ust_app_add_channel_all(usess, uchan);
                if (ret != LTTCOMM_OK) {
                        goto error;
                }
@@ -2243,7 +2246,7 @@ static int cmd_enable_event(struct ltt_session *session, int domain,
                        }
                }
 
-               ret = ust_app_add_event(usess, uchan, uevent);
+               ret = ust_app_add_event_all(usess, uchan, uevent);
                if (ret < 0) {
                        ret = LTTCOMM_UST_ENABLE_FAIL;
                        goto error;
@@ -2437,7 +2440,7 @@ static int cmd_start_trace(struct ltt_session *session)
        /* Flag session that trace should start automatically */
        usess->start_trace = 1;
 
-       ret = ust_app_start_trace(usess);
+       ret = ust_app_start_trace_all(usess);
        if (ret < 0) {
                ret = LTTCOMM_UST_START_FAIL;
                goto error;
index 72e3aeef2c68aee6d71b67f1a0c28393e8387e5c..d93dc90f579437d992ddb783edcafef57cffeec3 100644 (file)
@@ -46,6 +46,7 @@ static void delete_ust_app(struct ust_app *lta)
 
        rcu_read_lock();
 
+       /* TODO: clean session hashtable */
        free(lta->sessions);
        close(lta->key.sock);
 
@@ -99,7 +100,8 @@ static void delete_ust_app_rcu(struct rcu_head *head)
 }
 
 /*
- * Find an ust_app using the sock and return it.
+ * Find an ust_app using the sock and return it. RCU read side lock must be
+ * held before calling this helper function.
  */
 static struct ust_app *find_app_by_sock(int sock)
 {
@@ -107,8 +109,6 @@ static struct ust_app *find_app_by_sock(int sock)
        struct ust_app_key *key;
        struct cds_lfht_iter iter;
 
-       rcu_read_lock();
-
        node = hashtable_lookup(ust_app_sock_key_map,
                        (void *)((unsigned long) sock), sizeof(void *), &iter);
        if (node == NULL) {
@@ -126,7 +126,6 @@ static struct ust_app *find_app_by_sock(int sock)
                rcu_read_unlock();
                goto error;
        }
-       rcu_read_unlock();
 
        return caa_container_of(node, struct ust_app, node);
 
@@ -224,15 +223,31 @@ int ust_app_register(struct ust_register_msg *msg, int sock)
 void ust_app_unregister(int sock)
 {
        struct ust_app *lta;
+       struct cds_lfht_node *node;
+       struct cds_lfht_iter iter;
 
-       DBG2("UST app unregistering sock %d", sock);
-
+       rcu_read_lock();
        lta = find_app_by_sock(sock);
-       if (lta) {
-               DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
-               /* FIXME: Better use a call_rcu here ? */
-               delete_ust_app(lta);
+       if (lta == NULL) {
+               ERR("Unregister app sock %d not found!", sock);
+               goto error;
+       }
+
+       DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
+
+       /* Get the node reference for a call_rcu */
+       node = hashtable_lookup(ust_app_ht,
+                       (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
+       if (node == NULL) {
+               ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
+               goto error;
        }
+
+       call_rcu(&node->head, delete_ust_app_rcu);
+
+error:
+       rcu_read_unlock();
+       return;
 }
 
 /*
@@ -286,21 +301,19 @@ void ust_app_ht_alloc(void)
 /*
  * Alloc new UST app session.
  */
-static struct ust_app_session *alloc_app_session(void)
+static struct ust_app_session *alloc_ust_app_session(void)
 {
        struct ust_app_session *ua_sess;
 
+       /* Init most of the default value by allocating and zeroing */
        ua_sess = zmalloc(sizeof(struct ust_app_session));
        if (ua_sess == NULL) {
                PERROR("malloc");
                goto error;
        }
 
-       ua_sess->enabled = 0;
        ua_sess->handle = -1;
        ua_sess->channels = hashtable_new_str(0);
-       ua_sess->metadata = NULL;
-       ua_sess->obj = NULL;
 
        return ua_sess;
 
@@ -308,10 +321,14 @@ error:
        return NULL;
 }
 
-static struct ust_app_channel *alloc_app_channel(char *name)
+/*
+ * Alloc new UST app channel.
+ */
+static struct ust_app_channel *alloc_ust_app_channel(char *name)
 {
        struct ust_app_channel *ua_chan;
 
+       /* Init most of the default value by allocating and zeroing */
        ua_chan = zmalloc(sizeof(struct ust_app_channel));
        if (ua_chan == NULL) {
                PERROR("malloc");
@@ -320,9 +337,7 @@ static struct ust_app_channel *alloc_app_channel(char *name)
 
        strncpy(ua_chan->name, name, sizeof(ua_chan->name));
        ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
-       ua_chan->enabled = 0;
        ua_chan->handle = -1;
-       ua_chan->obj = NULL;
        ua_chan->ctx = hashtable_new(0);
        CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
        ua_chan->events = hashtable_new_str(0);
@@ -337,10 +352,14 @@ error:
        return NULL;
 }
 
-static struct ust_app_event *alloc_app_event(char *name)
+/*
+ * Alloc new UST app event.
+ */
+static struct ust_app_event *alloc_ust_app_event(char *name)
 {
        struct ust_app_event *ua_event;
 
+       /* Init most of the default value by allocating and zeroing */
        ua_event = zmalloc(sizeof(struct ust_app_event));
        if (ua_event == NULL) {
                PERROR("malloc");
@@ -361,7 +380,7 @@ error:
        return NULL;
 }
 
-static void shallow_copy_event(struct ust_app_event *ua_event,
+static void shadow_copy_event(struct ust_app_event *ua_event,
                struct ltt_ust_event *uevent)
 {
        strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
@@ -370,7 +389,7 @@ static void shallow_copy_event(struct ust_app_event *ua_event,
        /* TODO: support copy context */
 }
 
-static void shallow_copy_channel(struct ust_app_channel *ua_chan,
+static void shadow_copy_channel(struct ust_app_channel *ua_chan,
                struct ltt_ust_channel *uchan)
 {
        struct cds_lfht_iter iter;
@@ -378,13 +397,14 @@ static void shallow_copy_channel(struct ust_app_channel *ua_chan,
        struct ltt_ust_event *uevent;
        struct ust_app_event *ua_event;
 
-       DBG2("Shallow copy of UST app channel %s", ua_chan->name);
+       DBG2("Shadow copy of UST app channel %s", ua_chan->name);
 
        strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
        ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 
        /* TODO: support copy context */
 
+       /* Copy all events from ltt ust channel to ust app channel */
        hashtable_get_first(uchan->events, &iter);
        while ((node = hashtable_iter_get_node(&iter)) != NULL) {
                uevent = caa_container_of(node, struct ltt_ust_event, node);
@@ -392,27 +412,25 @@ static void shallow_copy_channel(struct ust_app_channel *ua_chan,
                ua_event_node = hashtable_lookup(ua_chan->events,
                                (void *) uevent->attr.name, strlen(uevent->attr.name), &iter);
                if (ua_event_node == NULL) {
-                       DBG2("UST event %s not found on shallow copy channel",
+                       DBG2("UST event %s not found on shadow copy channel",
                                        uevent->attr.name);
-                       ua_event = alloc_app_event(uevent->attr.name);
+                       ua_event = alloc_ust_app_event(uevent->attr.name);
                        if (ua_event == NULL) {
-                               continue;
+                               goto next;
                        }
+                       shadow_copy_event(ua_event, uevent);
                        hashtable_add_unique(ua_chan->events, &ua_event->node);
-               } else {
-                       ua_event = caa_container_of(node, struct ust_app_event, node);
                }
 
-               shallow_copy_event(ua_event, uevent);
-
+next:
                /* Get next UST events */
                hashtable_get_next(uchan->events, &iter);
        }
 
-       DBG3("Shallow copy channel done");
+       DBG3("Shadow copy channel done");
 }
 
-static void shallow_copy_session(struct ust_app_session *ua_sess,
+static void shadow_copy_session(struct ust_app_session *ua_sess,
                struct ltt_ust_session *usess)
 {
        struct cds_lfht_node *node, *ua_chan_node;
@@ -420,7 +438,7 @@ static void shallow_copy_session(struct ust_app_session *ua_sess,
        struct ltt_ust_channel *uchan;
        struct ust_app_channel *ua_chan;
 
-       DBG2("Shallow copy of session handle");
+       DBG2("Shadow copy of session handle %d", ua_sess->handle);
 
        ua_sess->uid = usess->uid;
 
@@ -432,27 +450,30 @@ static void shallow_copy_session(struct ust_app_session *ua_sess,
                uchan = caa_container_of(node, struct ltt_ust_channel, node);
 
                ua_chan_node = hashtable_lookup(ua_sess->channels,
-                               (void *) uchan->name, strlen(uchan->name), &iter);
+                               (void *)uchan->name, strlen(uchan->name), &iter);
                if (ua_chan_node == NULL) {
-                       DBG2("Channel %s not found on shallow session copy, creating it",
+                       DBG2("Channel %s not found on shadow session copy, creating it",
                                        uchan->name);
-                       ua_chan = alloc_app_channel(uchan->name);
+                       ua_chan = alloc_ust_app_channel(uchan->name);
                        if (ua_chan == NULL) {
                                /* malloc failed... continuing */
-                               continue;
+                               goto next;
                        }
+
+                       shadow_copy_channel(ua_chan, uchan);
                        hashtable_add_unique(ua_sess->channels, &ua_chan->node);
-               } else {
-                       ua_chan = caa_container_of(node, struct ust_app_channel, node);
                }
 
-               shallow_copy_channel(ua_chan, uchan);
-
+next:
                /* Next item in hash table */
                hashtable_get_next(usess->domain_global.channels, &iter);
        }
 }
 
+/*
+ * Return ust app session from the app session hashtable using the UST session
+ * uid.
+ */
 static struct ust_app_session *lookup_session_by_app(
                struct ltt_ust_session *usess, struct ust_app *app)
 {
@@ -461,8 +482,7 @@ static struct ust_app_session *lookup_session_by_app(
 
        /* Get right UST app session from app */
        node = hashtable_lookup(app->sessions,
-                       (void *) ((unsigned long) usess->uid),
-                       sizeof(void *), &iter);
+                       (void *) ((unsigned long) usess->uid), sizeof(void *), &iter);
        if (node == NULL) {
                goto error;
        }
@@ -473,207 +493,323 @@ error:
        return NULL;
 }
 
-int ust_app_add_channel(struct ltt_ust_session *usess,
+/*
+ * Create a UST session onto the tracer of app and add it the session
+ * hashtable.
+ *
+ * Return ust app session or NULL on error.
+ */
+static struct ust_app_session *create_ust_app_session(
+               struct ltt_ust_session *usess, struct ust_app *app)
+{
+       int ret;
+       struct ust_app_session *ua_sess;
+
+       ua_sess = lookup_session_by_app(usess, app);
+       if (ua_sess == NULL) {
+               DBG2("UST app pid: %d session uid %d not found, creating it",
+                               app->key.pid, usess->uid);
+               ua_sess = alloc_ust_app_session();
+               if (ua_sess == NULL) {
+                       /* Only malloc can failed so something is really wrong */
+                       goto error;
+               }
+               shadow_copy_session(ua_sess, usess);
+       }
+
+       if (ua_sess->handle == -1) {
+               ret = ustctl_create_session(app->key.sock);
+               if (ret < 0) {
+                       ERR("Error creating session for app pid %d, sock %d",
+                                       app->key.pid, app->key.sock);
+                       /* TODO: free() ua_sess */
+                       goto error;
+               }
+
+               DBG2("UST app ustctl create session handle %d", ret);
+               ua_sess->handle = ret;
+
+               /* Add ust app session to app's HT */
+               hashtable_node_init(&ua_sess->node,
+                               (void *)((unsigned long) ua_sess->uid), sizeof(void *));
+               hashtable_add_unique(app->sessions, &ua_sess->node);
+
+               DBG2("UST app session created successfully with handle %d", ret);
+       }
+
+       return ua_sess;
+
+error:
+       return NULL;
+}
+
+static struct ust_app_channel *create_ust_app_channel(
+               struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
+               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;
+
+       /* Lookup channel in the ust app session */
+       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);
+               ua_chan = alloc_ust_app_channel(uchan->name);
+               if (ua_chan == NULL) {
+                       goto error;
+               }
+               shadow_copy_channel(ua_chan, uchan);
+               hashtable_add_unique(ua_sess->channels, &ua_chan->node);
+       } else {
+               ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
+       }
+
+       /* TODO: remove cast and use lttng-ust-abi.h */
+       ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
+                       (struct lttng_ust_channel_attr *)&uchan->attr, &ua_chan->obj);
+       if (ret < 0) {
+               DBG("Error creating channel %s for app (pid: %d, sock: %d) "
+                               "and session handle %d with ret %d",
+                               ua_chan->name, app->key.pid, app->key.sock,
+                               ua_sess->handle, ret);
+               goto error;
+       }
+
+       ua_chan->handle = ua_chan->obj->handle;
+       ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
+       ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
+       ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
+
+       DBG2("Channel %s UST create successfully for pid:%d and sock:%d",
+                       ua_chan->name, app->key.pid, app->key.sock);
+
+       return ua_chan;
+
+error:
+       return NULL;
+}
+
+static struct ust_app_event *create_ust_app_event(
+               struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
+               struct ltt_ust_event *uevent, struct ust_app *app)
+{
+       int ret;
+       struct cds_lfht_iter iter;
+       struct cds_lfht_node *ua_event_node;
+       struct ust_app_event *ua_event;
+
+       /* Get event node */
+       ua_event_node = hashtable_lookup(ua_chan->events,
+                       (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
+       if (ua_event_node == NULL) {
+               DBG2("UST app event %s not found, creating it", uevent->attr.name);
+               /* Does not exist so create one */
+               ua_event = alloc_ust_app_event(uevent->attr.name);
+               if (ua_event == NULL) {
+                       /* Only malloc can failed so something is really wrong */
+                       goto error;
+               }
+               shadow_copy_event(ua_event, uevent);
+
+               hashtable_add_unique(ua_chan->events, &ua_event->node);
+       } else {
+               ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
+       }
+
+       /* Create UST event on tracer */
+       ret = ustctl_create_event(app->key.sock, &uevent->attr, ua_chan->obj,
+                       &ua_event->obj);
+       if (ret < 0) {
+               ERR("Error ustctl create event %s for app pid: %d with ret %d",
+                               uevent->attr.name, app->key.pid, ret);
+               /* TODO: free() ua_event */
+               goto error;
+       }
+       ua_event->handle = ua_event->obj->handle;
+       ua_event->enabled = 1;
+
+
+       DBG2("Event %s UST create successfully for pid:%d", uevent->attr.name,
+                       app->key.pid);
+
+       return ua_event;
+
+error:
+       return NULL;
+}
+
+static int create_ust_app_metadata(struct ust_app_session *ua_sess,
+               char *pathname, struct ust_app *app)
+{
+       int ret = 0;
+       struct lttng_ust_channel_attr uattr;
+
+       if (ua_sess->metadata == NULL) {
+               /* Allocate UST metadata */
+               ua_sess->metadata = trace_ust_create_metadata(pathname);
+               if (ua_sess->metadata == NULL) {
+                       ERR("UST app session %d creating metadata failed",
+                                       ua_sess->handle);
+                       goto error;
+               }
+
+               uattr.overwrite = ua_sess->metadata->attr.overwrite;
+               uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
+               uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
+               uattr.switch_timer_interval =
+                       ua_sess->metadata->attr.switch_timer_interval;
+               uattr.read_timer_interval =
+                       ua_sess->metadata->attr.read_timer_interval;
+               uattr.output = ua_sess->metadata->attr.output;
+
+               /* UST tracer metadata creation */
+               ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
+                               &ua_sess->metadata->obj);
+               if (ret < 0) {
+                       ERR("UST app open metadata failed for app pid:%d",
+                                       app->key.pid);
+                       goto error;
+               }
+
+               DBG2("UST metadata opened for app pid %d", app->key.pid);
+       }
+
+       /* Open UST metadata stream */
+       if (ua_sess->metadata->stream_obj == NULL) {
+               ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
+                               &ua_sess->metadata->stream_obj);
+               if (ret < 0) {
+                       ERR("UST create metadata stream failed");
+                       goto error;
+               }
+
+               ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
+                               pathname, app->name, app->key.pid);
+               if (ret < 0) {
+                       PERROR("asprintf UST create stream");
+                       goto error;
+               }
+
+               ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
+               if (ret < 0) {
+                       PERROR("mkdir UST metadata");
+                       goto error;
+               }
+
+               ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
+                               pathname, app->name, app->key.pid);
+               if (ret < 0) {
+                       PERROR("asprintf UST create stream");
+                       goto error;
+               }
+
+               DBG2("UST metadata stream object created for app pid %d",
+                               app->key.pid);
+       }
+
+       return 0;
+
+error:
+       return -1;
+}
+
+/*
+ * Add channel to all ust app session.
+ */
+int ust_app_add_channel_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan)
 {
        int ret = 0;
        struct cds_lfht_iter iter;
-       struct cds_lfht_node *node, *ua_chan_node;
+       struct cds_lfht_node *node;
        struct ust_app *app;
        struct ust_app_session *ua_sess;
        struct ust_app_channel *ua_chan;
 
+       if (usess == NULL || uchan == NULL) {
+               ERR("Adding UST global channel to NULL values");
+               ret = -1;
+               goto error;
+       }
+
        DBG2("UST app adding channel %s to global domain for session uid %d",
                        uchan->name, usess->uid);
 
        rcu_read_lock();
+
+       /* For every UST applications registered */
        hashtable_get_first(ust_app_ht, &iter);
        while ((node = hashtable_iter_get_node(&iter)) != NULL) {
                app = caa_container_of(node, struct ust_app, node);
 
-               ua_sess = lookup_session_by_app(usess, app);
-               if (ua_sess == NULL) {
-                       DBG2("UST app pid: %d session uid %d not found, creating one",
-                                       app->key.pid, usess->uid);
-                       ua_sess = alloc_app_session();
-                       if (ua_sess == NULL) {
-                               /* Only malloc can failed so something is really wrong */
-                               goto next;
-                       }
-                       shallow_copy_session(ua_sess, usess);
-               }
-
-               if (ua_sess->handle == -1) {
-                       ret = ustctl_create_session(app->key.sock);
-                       if (ret < 0) {
-                               DBG("Error creating session for app pid %d, sock %d",
-                                               app->key.pid, app->key.sock);
-                               /* TODO: free() ua_sess */
-                               goto next;
-                       }
-
-                       DBG2("UST app ustctl create session handle %d", ret);
-                       ua_sess->handle = ret;
-
-                       /* Add ust app session to app's HT */
-                       hashtable_node_init(&ua_sess->node,
-                                       (void *)((unsigned long) ua_sess->uid), sizeof(void *));
-                       hashtable_add_unique(app->sessions, &ua_sess->node);
-               }
-
-               /* Lookup channel in the ust app session */
-               ua_chan_node = hashtable_lookup(ua_sess->channels,
-                               (void *) uchan->name, strlen(uchan->name), &iter);
-               if (ua_chan_node == NULL) {
-                       ERR("Channel suppose to be present with the above shallow "
-                                       "session copy. Continuing...");
+               /* Create session on the tracer side and add it to app session HT */
+               ua_sess = create_ust_app_session(usess, app);
+               if (ret < 0) {
                        goto next;
                }
 
-               ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
-
-               /* TODO: remove cast and use lttng-ust-abi.h */
-               ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
-                               (struct lttng_ust_channel_attr *)&uchan->attr, &ua_chan->obj);
-               if (ret < 0) {
-                       DBG("Error creating channel %s for app (pid: %d, sock: %d) "
-                                       "and session handle %d with ret %d",
-                                       uchan->name, app->key.pid, app->key.sock,
-                                       ua_sess->handle, ret);
+               /* Create channel onto application */
+               ua_chan = create_ust_app_channel(ua_sess, uchan, app);
+               if (ua_chan == NULL) {
                        goto next;
                }
 
-               ua_chan->handle = ua_chan->obj->handle;
-               ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
-               ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
-               ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
-
-               DBG2("Channel %s UST create successfully for pid:%d and sock:%d",
-                               uchan->name, app->key.pid, app->key.sock);
-
 next:
                /* Next applications */
                hashtable_get_next(ust_app_ht, &iter);
        }
        rcu_read_unlock();
 
+error:
        return ret;
 }
 
-int ust_app_add_event(struct ltt_ust_session *usess,
+int ust_app_add_event_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 {
        int ret = 0;
        struct cds_lfht_iter iter;
-       struct cds_lfht_node *node, *ua_chan_node, *ua_event_node;
+       struct cds_lfht_node *node, *ua_chan_node;
        struct ust_app *app;
        struct ust_app_session *ua_sess;
        struct ust_app_channel *ua_chan;
        struct ust_app_event *ua_event;
-       struct lttng_ust_event ltt_uevent;
-       struct lttng_ust_object_data *obj_event;
 
        DBG2("UST app adding event %s to global domain for session uid %d",
                        uevent->attr.name, usess->uid);
 
        rcu_read_lock();
+
+       /* For all registered applications */
        hashtable_get_first(ust_app_ht, &iter);
        while ((node = hashtable_iter_get_node(&iter)) != NULL) {
                app = caa_container_of(node, struct ust_app, node);
 
-               ua_sess = lookup_session_by_app(usess, app);
-               if (ua_sess == NULL) {
-                       DBG2("UST app (pid: %d, sock: %d) session not found, creating one",
-                                       app->key.pid, app->key.sock);
-                       ua_sess = alloc_app_session();
-                       if (ua_sess == NULL) {
-                               /* Only malloc can failed so something is really wrong */
-                               goto next;
-                       }
-                       shallow_copy_session(ua_sess, usess);
-               }
-
-               if (ua_sess->handle == -1) {
-                       ret = ustctl_create_session(app->key.sock);
-                       if (ret < 0) {
-                               DBG("Error creating session for app pid %d, sock %d",
-                                               app->key.pid, app->key.sock);
-                               /* TODO: free() ua_sess */
-                               goto next;
-                       }
-
-                       DBG2("UST app ustctl create session handle %d", ret);
-                       ua_sess->handle = ret;
-                       /* Add ust app session to app's HT */
-                       hashtable_node_init(&ua_sess->node,
-                                       (void *)((unsigned long) ua_sess->uid), sizeof(void *));
-                       hashtable_add_unique(app->sessions, &ua_sess->node);
+               /* Create session on the tracer side and add it to app session HT */
+               ua_sess = create_ust_app_session(usess, app);
+               if (ret < 0) {
+                       goto next;
                }
 
                /* Lookup channel in the ust app session */
                ua_chan_node = hashtable_lookup(ua_sess->channels,
-                               (void *) uchan->name, strlen(uchan->name), &iter);
+                               (void *)uchan->name, strlen(uchan->name), &iter);
                if (ua_chan_node == NULL) {
-                       ERR("Channel suppose to be present with the above shallow "
-                                       "session copy. Continuing...");
+                       ERR("Channel %s not found in session uid %d. Skipping",
+                                       uchan->name, usess->uid);
                        goto next;
                }
-
                ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
 
-               /* Prepare lttng ust event */
-               strncpy(ltt_uevent.name, uevent->attr.name, sizeof(ltt_uevent.name));
-               ltt_uevent.name[sizeof(ltt_uevent.name) - 1] = '\0';
-               /* TODO: adjust to other instrumentation types */
-               ltt_uevent.instrumentation = LTTNG_UST_TRACEPOINT;
-
-               /* Get event node */
-               ua_event_node = hashtable_lookup(ua_chan->events,
-                               (void *) uevent->attr.name, strlen(uevent->attr.name), &iter);
-               if (ua_event_node == NULL) {
-                       DBG2("UST app event %s not found, creating one", uevent->attr.name);
-                       /* Does not exist so create one */
-                       ua_event = alloc_app_event(uevent->attr.name);
-                       if (ua_event == NULL) {
-                               /* Only malloc can failed so something is really wrong */
-                               goto next;
-                       }
-
-                       shallow_copy_event(ua_event, uevent);
-
-                       /* Create UST event on tracer */
-                       ret = ustctl_create_event(app->key.sock, &ltt_uevent, ua_chan->obj,
-                                       &obj_event);
-                       if (ret < 0) {
-                               ERR("Error ustctl create event %s for app pid: %d with ret %d",
-                                               uevent->attr.name, app->key.pid, ret);
-                               /* TODO: free() ua_event and obj_event */
-                               goto next;
-                       }
-                       ua_event->obj = obj_event;
-                       ua_event->handle = obj_event->handle;
-                       ua_event->enabled = 1;
-               } else {
-                       ua_event = caa_container_of(ua_event_node,
-                                       struct ust_app_event, node);
-
-                       if (ua_event->enabled == 0) {
-                               ret = ustctl_enable(app->key.sock, ua_event->obj);
-                               if (ret < 0) {
-                                       ERR("Error ustctl enable event %s for app "
-                                                       "pid: %d with ret %d", uevent->attr.name,
-                                                       app->key.pid, ret);
-                                       goto next;
-                               }
-                               ua_event->enabled = 1;
-                       }
+               ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
+               if (ua_event == NULL) {
+                       goto next;
                }
 
-               hashtable_add_unique(ua_chan->events, &ua_event->node);
-
-               DBG2("Event %s UST create successfully for pid:%d", uevent->attr.name,
-                               app->key.pid);
-
 next:
                /* Next applications */
                hashtable_get_next(ust_app_ht, &iter);
@@ -683,158 +819,108 @@ next:
        return ret;
 }
 
-int ust_app_start_trace(struct ltt_ust_session *usess)
+int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
 {
        int ret = 0;
        struct cds_lfht_iter iter;
-       struct cds_lfht_node *node, *ua_chan_node;
-       struct ust_app *app;
+       struct cds_lfht_node *node;
        struct ust_app_session *ua_sess;
        struct ust_app_channel *ua_chan;
-       struct lttng_ust_channel_attr uattr;
-       struct ltt_ust_channel *uchan;
 
-       DBG("Starting all UST traces");
+       DBG("Starting tracing for ust app pid %d", app->key.pid);
 
-       rcu_read_lock();
-       hashtable_get_first(ust_app_ht, &iter);
-       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
-               app = caa_container_of(node, struct ust_app, node);
+       ua_sess = lookup_session_by_app(usess, app);
+       if (ua_sess == NULL) {
+               /* Only malloc can failed so something is really wrong */
+               goto error;
+       }
 
-               ua_sess = lookup_session_by_app(usess, app);
-               if (ua_sess == NULL) {
-                       /* Only malloc can failed so something is really wrong */
-                       goto next;
-               }
+       ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
+       if (ret < 0) {
+               goto error;
+       }
 
-               if (ua_sess->metadata == NULL) {
-                       /* Allocate UST metadata */
-                       ua_sess->metadata = trace_ust_create_metadata(usess->pathname);
-                       if (ua_sess->metadata == NULL) {
-                               ERR("UST app session %d creating metadata failed",
-                                               ua_sess->handle);
-                               goto next;
-                       }
+       /* For each channel */
+       hashtable_get_first(ua_sess->channels, &iter);
+       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+               ua_chan = caa_container_of(node, struct ust_app_channel, node);
 
-                       uattr.overwrite = ua_sess->metadata->attr.overwrite;
-                       uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
-                       uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
-                       uattr.switch_timer_interval =
-                               ua_sess->metadata->attr.switch_timer_interval;
-                       uattr.read_timer_interval =
-                               ua_sess->metadata->attr.read_timer_interval;
-                       uattr.output = ua_sess->metadata->attr.output;
-
-                       /* UST tracer metadata creation */
-                       ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
-                                       &ua_sess->metadata->obj);
-                       if (ret < 0) {
-                               ERR("UST app open metadata failed for app pid:%d",
-                                               app->key.pid);
-                               goto next;
-                       }
+               /* Create all streams */
+               while (1) {
+                       struct ltt_ust_stream *ustream;
 
-                       DBG2("UST metadata opened for app pid %d", app->key.pid);
-               }
+                       ustream = zmalloc(sizeof(*ustream));
+                       if (ustream == NULL) {
+                               PERROR("zmalloc ust stream");
+                               continue;
+                       }
 
-               /* Open UST metadata stream */
-               if (ua_sess->metadata->stream_obj == NULL) {
-                       ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
-                                       &ua_sess->metadata->stream_obj);
+                       ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
+                                       &ustream->obj);
                        if (ret < 0) {
-                               ERR("UST create metadata stream failed");
-                               goto next;
+                               /* Got all streams */
+                               break;
                        }
+                       ustream->handle = ustream->obj->handle;
 
-                       ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
-                                       usess->pathname, app->name, app->key.pid);
+                       /* Order is important */
+                       cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
+                       ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
+                                       usess->pathname, app->name, app->key.pid,
+                                       ua_chan->name, ua_chan->streams.count++);
                        if (ret < 0) {
                                PERROR("asprintf UST create stream");
-                               goto next;
+                               continue;
                        }
+                       DBG2("UST stream %d ready at %s", ua_chan->streams.count,
+                                       ustream->pathname);
+               }
 
-                       ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
-                       if (ret < 0) {
-                               goto next;
-                       }
+               /* Next applications */
+               hashtable_get_next(ua_sess->channels, &iter);
+       }
 
-                       ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
-                                       usess->pathname, app->name, app->key.pid);
-                       if (ret < 0) {
-                               PERROR("asprintf UST create stream");
-                               goto next;
-                       }
+       /* Setup UST consumer socket and send fds to it */
+       ret = ust_consumer_send_session(usess->consumer_fd, ua_sess);
+       if (ret < 0) {
+               goto error;
+       }
 
-                       DBG2("UST metadata stream object created for app pid %d",
-                                       app->key.pid);
-               }
+       /* This start the UST tracing */
+       ret = ustctl_start_session(app->key.sock, ua_sess->handle);
+       if (ret < 0) {
+               ERR("Error starting tracing for app pid: %d", app->key.pid);
+               goto error;
+       }
 
-               /* For each channel */
-               hashtable_get_first(usess->domain_global.channels, &iter);
-               while ((node = hashtable_iter_get_node(&iter)) != NULL) {
-                       uchan = caa_container_of(node, struct ltt_ust_channel, node);
-
-                       /* Lookup channel in the ust app session */
-                       ua_chan_node = hashtable_lookup(ua_sess->channels,
-                                       (void *) uchan->name, strlen(uchan->name), &iter);
-                       if (ua_chan_node == NULL) {
-                               ERR("Channel suppose to be present with the above shallow "
-                                               "session copy. Continuing...");
-                               goto next;
-                       }
+       /* Quiescent wait after starting trace */
+       ustctl_wait_quiescent(app->key.sock);
 
-                       ua_chan = caa_container_of(ua_chan_node,
-                                       struct ust_app_channel, node);
-
-                       for (;;) {
-                               struct lttng_ust_object_data *obj;
-                               struct ltt_ust_stream *ustream;
-
-                               ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
-                                               &obj);
-                               if (ret < 0) {
-                                       /* Got all streams */
-                                       goto next_chan;
-                               }
-
-                               ustream = malloc(sizeof(*ustream));
-                               if (ustream == NULL) {
-                                       goto next_chan;
-                               }
-                               memset(ustream, 0, sizeof(struct ltt_ust_stream));
-                               ustream->obj = obj;
-                               ustream->handle = ustream->obj->handle;
-                               /* Order is important */
-                               cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
-                               ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
-                                               usess->pathname, app->name, app->key.pid,
-                                               uchan->name, ua_chan->streams.count++);
-                               if (ret < 0) {
-                                       PERROR("asprintf UST create stream");
-                                       goto next_chan;
-                               }
-                       }
+       return 0;
 
-next_chan:
-                       /* Next applications */
-                       hashtable_get_next(ua_sess->channels, &iter);
-               }
+error:
+       return -1;
+}
 
-               /* Setup UST consumer socket and send fds to it */
-               ret = ust_consumer_send_session(usess->consumer_fd, ua_sess);
-               if (ret < 0) {
-                       goto next;
-               }
+int ust_app_start_trace_all(struct ltt_ust_session *usess)
+{
+       int ret = 0;
+       struct cds_lfht_iter iter;
+       struct cds_lfht_node *node;
+       struct ust_app *app;
 
-               /* This start the UST tracing */
-               ret = ustctl_start_session(app->key.sock, ua_sess->handle);
+       DBG("Starting all UST traces");
+
+       rcu_read_lock();
+       hashtable_get_first(ust_app_ht, &iter);
+       while ((node = hashtable_iter_get_node(&iter)) != NULL) {
+               app = caa_container_of(node, struct ust_app, node);
+
+               ret = ust_app_start_trace(usess, app);
                if (ret < 0) {
-                       ERR("Error starting tracing for app pid: %d", app->key.pid);
                        goto next;
                }
 
-               /* Quiescent wait after starting trace */
-               ustctl_wait_quiescent(app->key.sock);
 next:
                /* Next applications */
                hashtable_get_next(ust_app_ht, &iter);
@@ -847,17 +933,14 @@ next:
 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
 {
        int ret = 0;
-       int session_existed = 1;
        struct cds_lfht_iter iter;
-       struct cds_lfht_node *node, *ua_chan_node;
+       struct cds_lfht_node *node;
        struct ust_app *app;
        struct ust_app_session *ua_sess;
        struct ust_app_channel *ua_chan;
        struct ust_app_event *ua_event;
-       struct lttng_ust_event ltt_uevent;
        struct ltt_ust_channel *uchan;
-       struct lttng_ust_object_data *obj_event;
-       struct lttng_ust_channel_attr uattr;
+       struct ltt_ust_event *uevent;
 
        rcu_read_lock();
 
@@ -875,226 +958,44 @@ void ust_app_global_update(struct ltt_ust_session *usess, int sock)
                goto error;
        }
 
-       ua_sess = lookup_session_by_app(usess, app);
+       ua_sess = create_ust_app_session(usess, app);
        if (ua_sess == NULL) {
-               DBG2("UST app pid: %d session uid %d not found, creating one",
-                               app->key.pid, usess->uid);
-               ua_sess = alloc_app_session();
-               if (ua_sess == NULL) {
-                       /* Only malloc can failed so something is really wrong */
-                       goto error;
-               }
-               shallow_copy_session(ua_sess, usess);
-               session_existed= 0;
-       }
-
-       if (ua_sess->handle == -1) {
-               ret = ustctl_create_session(app->key.sock);
-               if (ret < 0) {
-                       DBG("Error creating session for app pid %d, sock %d",
-                                       app->key.pid, app->key.sock);
-                       /* TODO: free() ua_sess */
-                       goto error;
-               }
-
-               DBG2("UST app ustctl create session handle %d", ret);
-               ua_sess->handle = ret;
-
-               /* Add ust app session to app's HT */
-               hashtable_node_init(&ua_sess->node,
-                               (void *)((unsigned long) ua_sess->uid), sizeof(void *));
-               hashtable_add_unique(app->sessions, &ua_sess->node);
-       }
-
-       if (session_existed) {
                goto error;
        }
 
-       if (ua_sess->metadata == NULL) {
-               /* Allocate UST metadata */
-               ua_sess->metadata = trace_ust_create_metadata(usess->pathname);
-               if (ua_sess->metadata == NULL) {
-                       ERR("UST app session %d creating metadata failed",
-                                       ua_sess->handle);
-                       goto error;
-               }
-
-               uattr.overwrite = ua_sess->metadata->attr.overwrite;
-               uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
-               uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
-               uattr.switch_timer_interval =
-                       ua_sess->metadata->attr.switch_timer_interval;
-               uattr.read_timer_interval =
-                       ua_sess->metadata->attr.read_timer_interval;
-               uattr.output = ua_sess->metadata->attr.output;
-
-               /* UST tracer metadata creation */
-               ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
-                               &ua_sess->metadata->obj);
-               if (ret < 0) {
-                       ERR("UST app open metadata failed for app pid:%d",
-                                       app->key.pid);
-                       goto error;
-               }
-
-               DBG2("UST metadata opened for app pid %d", app->key.pid);
-       }
-
-       /* Open UST metadata stream */
-       if (ua_sess->metadata->stream_obj == NULL) {
-               ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
-                               &ua_sess->metadata->stream_obj);
-               if (ret < 0) {
-                       ERR("UST create metadata stream failed");
-                       goto error;
-               }
-
-               ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
-                               usess->pathname, app->name, app->key.pid);
-               if (ret < 0) {
-                       PERROR("asprintf UST create stream");
-                       goto error;
-               }
-
-               ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
-               if (ret < 0) {
-                       PERROR("mkdir UST metadata");
-                       goto error;
-               }
-
-               ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
-                               usess->pathname, app->name, app->key.pid);
-               if (ret < 0) {
-                       PERROR("asprintf UST create stream");
-                       goto error;
-               }
-
-               DBG2("UST metadata stream object created for app pid %d",
-                               app->key.pid);
-       }
-
-
-       /* Iterate over all channels */
        hashtable_get_first(usess->domain_global.channels, &iter);
        while ((node = hashtable_iter_get_node(&iter)) != NULL) {
                uchan = caa_container_of(node, struct ltt_ust_channel, node);
 
-               /* Lookup channel in the ust app session */
-               ua_chan_node = hashtable_lookup(ua_sess->channels,
-                               (void *) uchan->name, strlen(uchan->name), &iter);
-               if (ua_chan_node == NULL) {
-                       ERR("UST app channel not found for uchan %s", uchan->name);
-                       goto next_chan;
-               }
-
-               ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
-
-               /* TODO: remove cast and use lttng-ust-abi.h */
-               ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
-                               (struct lttng_ust_channel_attr *)&uchan->attr, &ua_chan->obj);
-               if (ret < 0) {
-                       DBG("Error creating channel %s for app (pid: %d, sock: %d) "
-                                       "and session handle %d with ret %d",
-                                       uchan->name, app->key.pid, app->key.sock,
-                                       ua_sess->handle, ret);
+               ua_chan = create_ust_app_channel(ua_sess, uchan, app);
+               if (ua_chan == NULL) {
                        goto next_chan;
                }
 
-               ua_chan->handle = ua_chan->obj->handle;
-               ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
-               ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
-               ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
-
-               DBG2("Channel %s UST create successfully for pid:%d and sock:%d",
-                               uchan->name, app->key.pid, app->key.sock);
-
-               /* For each event(s) of that channel */
-               hashtable_get_first(ua_chan->events, &iter);
+               hashtable_get_first(uchan->events, &iter);
                while ((node = hashtable_iter_get_node(&iter)) != NULL) {
-                       ua_event = caa_container_of(node, struct ust_app_event, node);
-
-                       /* Prepare lttng ust event */
-                       memset(&ltt_uevent, 0, sizeof(ltt_uevent));
-                       strncpy(ltt_uevent.name, ua_event->name, sizeof(ltt_uevent.name));
-                       ltt_uevent.name[sizeof(ltt_uevent.name) - 1] = '\0';
+                       uevent = caa_container_of(node, struct ltt_ust_event, node);
 
-                       /* TODO: adjust to other instrumentation types */
-                       ltt_uevent.instrumentation = LTTNG_UST_TRACEPOINT;
-
-                       /* Create UST event on tracer */
-                       ret = ustctl_create_event(app->key.sock, &ltt_uevent, ua_chan->obj,
-                                       &obj_event);
-                       if (ret < 0) {
-                               ERR("Error ustctl create event %s for app pid: %d with ret %d",
-                                               ua_event->name, app->key.pid, ret);
-                               /* TODO: free() ua_event and obj_event */
+                       ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
+                       if (ua_event == NULL) {
                                goto next_event;
                        }
 
-                       ua_event->obj = obj_event;
-                       ua_event->handle = obj_event->handle;
-                       ua_event->enabled = 1;
-
-                       DBG2("Event %s UST create successfully for pid:%d",
-                                       ua_event->name, app->key.pid);
-
 next_event:
-                       hashtable_get_next(ua_chan->events, &iter);
-               }
-
-               for (;;) {
-                       struct lttng_ust_object_data *obj;
-                       struct ltt_ust_stream *ustream;
-
-                       ret = ustctl_create_stream(app->key.sock, ua_chan->obj, &obj);
-                       if (ret < 0) {
-                               /* Got all streams */
-                               break;
-                       }
-
-                       ustream = zmalloc(sizeof(*ustream));
-                       if (ustream == NULL) {
-                               PERROR("zmalloc ust stream");
-                               goto error;
-                       }
-
-                       ustream->obj = obj;
-                       ustream->handle = ustream->obj->handle;
-                       /* Order is important */
-                       cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
-
-                       ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
-                                       usess->pathname, app->name, app->key.pid,
-                                       uchan->name, ua_chan->streams.count++);
-                       if (ret < 0) {
-                               PERROR("asprintf UST create stream");
-                               goto error;
-                       }
+                       hashtable_get_next(uchan->events, &iter);
                }
 
 next_chan:
-               /* Next applications */
-               hashtable_get_next(ua_sess->channels, &iter);
+               /* Next item in hash table */
+               hashtable_get_next(usess->domain_global.channels, &iter);
        }
 
        if (usess->start_trace) {
-               /* Setup UST consumer socket and send fds to it */
-               ret = ust_consumer_send_session(usess->consumer_fd, ua_sess);
+               ret = ust_app_start_trace(usess, app);
                if (ret < 0) {
-                       ERR("UST consumer send session failed");
                        goto error;
                }
 
-               /* This start the UST tracing */
-               ret = ustctl_start_session(app->key.sock, ua_sess->handle);
-               if (ret < 0) {
-                       ERR("Error starting tracing for app pid: %d", app->key.pid);
-                       goto error;
-               }
-
-               /* Quiescent wait after starting trace */
-               ustctl_wait_quiescent(app->key.sock);
-
                DBG2("UST trace started for app pid %d", app->key.pid);
        }
 
index 39e5bb6d22aabf41a1dc1ffa3422abee2c8baf9e..76b81b29a1eb5a2560fe2e05148d601dc0788a3d 100644 (file)
@@ -101,12 +101,13 @@ struct ust_app {
 
 int ust_app_register(struct ust_register_msg *msg, int sock);
 void ust_app_unregister(int sock);
-int ust_app_add_channel(struct ltt_ust_session *usess,
+int ust_app_add_channel_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan);
-int ust_app_add_event(struct ltt_ust_session *usess,
+int ust_app_add_event_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent);
 unsigned long ust_app_list_count(void);
-int ust_app_start_trace(struct ltt_ust_session *usess);
+int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app);
+int ust_app_start_trace_all(struct ltt_ust_session *usess);
 void ust_app_global_update(struct ltt_ust_session *usess, int sock);
 
 void ust_app_clean_list(void);
@@ -117,7 +118,12 @@ struct ust_app *ust_app_find_by_pid(pid_t pid);
 #else /* HAVE_LIBLTTNG_UST_CTL */
 
 static inline
-int ust_app_start_trace(struct ltt_ust_session *usess)
+int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
+{
+       return 0;
+}
+static inline
+int ust_app_start_trace_all(struct ltt_ust_session *usess)
 {
        return 0;
 }
@@ -158,13 +164,13 @@ struct ust_app *ust_app_get_by_pid(pid_t pid)
        return NULL;
 }
 static inline
-int ust_app_add_channel(struct ltt_ust_session *usess,
+int ust_app_add_channel_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan)
 {
        return 0;
 }
 static inline
-int ust_app_add_event(struct ltt_ust_session *usess,
+int ust_app_add_event_all(struct ltt_ust_session *usess,
                struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 {
        return 0;
This page took 0.069548 seconds and 4 git commands to generate.