Auto creation of chan/event on apps registration
authorDavid Goulet <david.goulet@polymtl.ca>
Mon, 7 Nov 2011 21:21:22 +0000 (16:21 -0500)
committerDavid Goulet <david.goulet@polymtl.ca>
Mon, 7 Nov 2011 21:21:22 +0000 (16:21 -0500)
On UST apps registration, all channel(s) and event(s) from the UST
global domain are created on the apps.

Adds a new check for urcu wait-free queue in configure.ac

Signed-off-by: David Goulet <david.goulet@polymtl.ca>
configure.ac
lttng-sessiond/main.c
lttng-sessiond/ust-app.c
lttng-sessiond/ust-app.h

index 8c0eb54d345d6561281793d01f5012cc5db4243e..cd1e0d152f6d6b16214eb84e536c442bc38a8a76 100644 (file)
@@ -34,6 +34,9 @@ AC_CHECK_DECL([cds_list_add], [],
 AC_CHECK_DECL([cds_wfq_init], [],
        [AC_MSG_ERROR([liburcu $liburcu_version or newer is needed])], [[#include <urcu/wfqueue.h>]]
 )
+AC_CHECK_DECL([cds_wfq_dequeue_blocking], [],
+    [AC_MSG_ERROR([liburcu $liburcu_version or newer is needed])], [[#include <urcu/wfqueue.h>]]
+)
 AC_CHECK_DECL([futex_async], [],
        [AC_MSG_ERROR([liburcu $liburcu_version or newer is needed])], [[#include <urcu/futex.h>]]
 )
index ea3853c1a6f19b5a0132e86f287e82b3d313073a..f13571ab37159fc00d9aac331444eab9cb68db42 100644 (file)
@@ -711,6 +711,19 @@ error:
        return ret;
 }
 
+/*
+ * For each tracing session, update newly registered apps.
+ */
+static void update_ust_app(int app_sock)
+{
+       struct ltt_session *sess, *stmp;
+
+       /* 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);
+       }
+}
+
 /*
  * This thread manage event coming from the kernel.
  *
@@ -1062,6 +1075,12 @@ static void *thread_manage_apps(void *data)
                                                DBG("Apps with sock %d added to poll set",
                                                                ust_cmd.sock);
                                        }
+
+                                       /*
+                                        * Add channel(s) and event(s) to newly registered apps
+                                        * from lttng global UST domain.
+                                        */
+                                       update_ust_app(ust_cmd.sock);
                                        break;
                                }
                        } else {
@@ -2228,6 +2247,10 @@ static int cmd_enable_event(struct ltt_session *session, int domain,
                        ret = LTTCOMM_UST_ENABLE_FAIL;
                        goto error;
                }
+
+               rcu_read_lock();
+               hashtable_add_unique(uchan->events, &uevent->node);
+               rcu_read_unlock();
                break;
        }
        case LTTNG_DOMAIN_UST_EXEC_NAME:
index 9e6b3468b61a6131e652bd3b9b38eb670ac81adf..58ca9d3f235639847d7c17710940e9f3a6f5a8e7 100644 (file)
@@ -827,3 +827,140 @@ next:
 
        return 0;
 }
+
+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 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;
+
+       DBG2("UST app global update for app sock %d for session uid %d", sock,
+                       usess->uid);
+
+       rcu_read_lock();
+       app = find_app_by_sock(sock);
+       if (app == NULL) {
+               ERR("Failed to update app sock %d", sock);
+               goto error;
+       }
+
+       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 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;
+       }
+
+       /* 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);
+                       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);
+               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';
+
+                       /* 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 */
+                               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);
+               }
+
+next_chan:
+               /* Next applications */
+               hashtable_get_next(ua_sess->channels, &iter);
+       }
+
+error:
+       rcu_read_unlock();
+       return;
+}
index 7d198ee3ee9f138ca3121fa022861a1d26bdc980..753639270af84e9f4febdb9471cb6d3a9b38f860 100644 (file)
@@ -107,6 +107,7 @@ int ust_app_add_event(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);
+void ust_app_global_update(struct ltt_ust_session *usess, int sock);
 
 void ust_app_clean_list(void);
 void ust_app_ht_alloc(void);
@@ -177,6 +178,10 @@ static inline
 void ust_app_ht_alloc(void)
 {
 }
+static inline
+void ust_app_global_update(struct ltt_ust_session *usess, int sock)
+{
+}
 
 #endif /* HAVE_LIBLTTNG_UST_CTL */
 
This page took 0.043876 seconds and 4 git commands to generate.