Fix: leak of filter bytecode and expression on agent event re-enable
[lttng-tools.git] / src / bin / lttng-sessiond / event.c
index e4c79df74a4dca37f132478408caacd92d9f2577..b0b37bed777a4eb5b537b0739c14115b5e3020a2 100644 (file)
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2 only,
@@ -23,6 +24,8 @@
 #include <lttng/lttng.h>
 #include <common/error.h>
 #include <common/sessiond-comm/sessiond-comm.h>
+#include <common/filter.h>
+#include <common/context.h>
 
 #include "channel.h"
 #include "event.h"
@@ -116,23 +119,11 @@ int event_kernel_enable_event(struct ltt_kernel_channel *kchan,
        kevent = trace_kernel_find_event(event->name, kchan,
                        event->type, filter);
        if (kevent == NULL) {
-               ret = kernel_create_event(event, kchan,
-                       filter_expression, filter);
+               ret = kernel_create_event(event, kchan, filter_expression, filter);
                /* We have passed ownership */
                filter_expression = NULL;
                filter = NULL;
-               if (ret < 0) {
-                       switch (-ret) {
-                       case EEXIST:
-                               ret = LTTNG_ERR_KERN_EVENT_EXIST;
-                               break;
-                       case ENOSYS:
-                               ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
-                               break;
-                       default:
-                               ret = LTTNG_ERR_KERN_ENABLE_FAIL;
-                               break;
-                       }
+               if (ret) {
                        goto end;
                }
        } else if (kevent->enabled == 0) {
@@ -183,14 +174,13 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
        uevent = trace_ust_find_event(uchan->events, event->name, filter,
                        event->loglevel_type, event->loglevel, exclusion);
        if (!uevent) {
-               uevent = trace_ust_create_event(event, filter_expression,
-                               filter, exclusion, internal_event);
+               ret = trace_ust_create_event(event, filter_expression,
+                               filter, exclusion, internal_event, &uevent);
                /* We have passed ownership */
                filter_expression = NULL;
                filter = NULL;
                exclusion = NULL;
-               if (uevent == NULL) {
-                       ret = LTTNG_ERR_UST_ENABLE_FAIL;
+               if (ret != LTTNG_OK) {
                        goto error;
                }
 
@@ -205,6 +195,14 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
        }
 
        uevent->enabled = 1;
+       if (to_create) {
+               /* Add ltt ust event to channel */
+               add_unique_ust_event(uchan->events, uevent);
+       }
+
+       if (!usess->active) {
+               goto end;
+       }
 
        if (to_create) {
                /* Create event on all UST registered apps for session */
@@ -224,11 +222,6 @@ int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
                }
        }
 
-       if (to_create) {
-               /* Add ltt ust event to channel */
-               add_unique_ust_event(uchan->events, uevent);
-       }
-
        DBG("Event UST %s %s in channel %s", uevent->attr.name,
                        to_create ? "created" : "enabled", uchan->name);
 
@@ -301,17 +294,18 @@ int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
                        /* It's already disabled so everything is OK */
                        goto next;
                }
+               uevent->enabled = 0;
+               DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
+                               uchan->name);
 
+               if (!usess->active) {
+                       goto next;
+               }
                ret = ust_app_disable_event_glb(usess, uchan, uevent);
                if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
                        ret = LTTNG_ERR_UST_DISABLE_FAIL;
                        goto error;
                }
-               uevent->enabled = 0;
-
-               DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
-                               uchan->name);
-
 next:
                /* Get next duplicate event by name. */
                cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name,
@@ -416,6 +410,70 @@ error:
        return ret;
 }
 
+/*
+ * Check if this event's filter requires the activation of application contexts
+ * and enable them in the agent.
+ * TODO: bytecode iterator does not support non-legacy application
+ * contexts yet. Not an issue for now, since they are not generated by
+ * the lttng-ctl library.
+ */
+static int add_filter_app_ctx(struct lttng_filter_bytecode *bytecode,
+               const char *filter_expression, struct agent *agt)
+{
+       int ret = LTTNG_OK;
+       char *provider_name = NULL, *ctx_name = NULL;
+       struct bytecode_symbol_iterator *it =
+                       bytecode_symbol_iterator_create(bytecode);
+
+       if (!it) {
+               ret = LTTNG_ERR_NOMEM;
+               goto end;
+       }
+
+       do {
+               struct lttng_event_context ctx;
+               const char *symbol_name =
+                               bytecode_symbol_iterator_get_name(it);
+
+               if (parse_application_context(symbol_name, &provider_name,
+                               &ctx_name)) {
+                       /* Not an application context. */
+                       continue;
+               }
+
+               ctx.ctx = LTTNG_EVENT_CONTEXT_APP_CONTEXT;
+               ctx.u.app_ctx.provider_name = provider_name;
+               ctx.u.app_ctx.ctx_name = ctx_name;
+
+               /* Recognized an application context. */
+               DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
+                               filter_expression, provider_name, ctx_name);
+
+               ret = agent_add_context(&ctx, agt);
+               if (ret != LTTNG_OK) {
+                       ERR("Failed to add application context %s:%s.",
+                                       provider_name, ctx_name);
+                       goto end;
+               }
+
+               ret = agent_enable_context(&ctx, agt->domain);
+               if (ret != LTTNG_OK) {
+                       ERR("Failed to enable application context %s:%s.",
+                                       provider_name, ctx_name);
+                       goto end;
+               }
+
+               free(provider_name);
+               free(ctx_name);
+               provider_name = ctx_name = NULL;
+       } while (bytecode_symbol_iterator_next(it) == 0);
+end:
+       free(provider_name);
+       free(ctx_name);
+       bytecode_symbol_iterator_destroy(it);
+       return ret;
+}
+
 /*
  * Enable a single agent event for a given UST session.
  *
@@ -439,7 +497,7 @@ int event_agent_enable(struct ltt_ust_session *usess,
                        filter_expression ? filter_expression : "NULL");
 
        aevent = agent_find_event(event->name, event->loglevel_type,
-               event->loglevel, filter_expression, agt);
+                       event->loglevel, filter_expression, agt);
        if (!aevent) {
                aevent = agent_create_event(event->name, event->loglevel_type,
                                event->loglevel, filter,
@@ -448,11 +506,21 @@ int event_agent_enable(struct ltt_ust_session *usess,
                        ret = LTTNG_ERR_NOMEM;
                        goto error;
                }
+               filter = NULL;
+               filter_expression = NULL;
                created = 1;
        }
 
+       if (created && filter) {
+               ret = add_filter_app_ctx(filter, filter_expression, agt);
+               if (ret != LTTNG_OK) {
+                       goto error;
+               }
+       }
+
        /* Already enabled? */
        if (aevent->enabled) {
+               ret = LTTNG_OK;
                goto end;
        }
 
@@ -466,13 +534,16 @@ int event_agent_enable(struct ltt_ust_session *usess,
                agent_add_event(aevent, agt);
        }
 
-end:
-       return LTTNG_OK;
+       ret = LTTNG_OK;
+       goto end;
 
 error:
        if (created) {
                agent_destroy_event(aevent);
        }
+end:
+       free(filter);
+       free(filter_expression);
        return ret;
 }
 
@@ -567,10 +638,12 @@ static int event_agent_disable_one(struct ltt_ust_session *usess,
        /* If the agent event exists, it must be available on the UST side. */
        assert(uevent);
 
-       ret = ust_app_disable_event_glb(usess, uchan, uevent);
-       if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
-               ret = LTTNG_ERR_UST_DISABLE_FAIL;
-               goto error;
+       if (usess->active) {
+               ret = ust_app_disable_event_glb(usess, uchan, uevent);
+               if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
+                       ret = LTTNG_ERR_UST_DISABLE_FAIL;
+                       goto error;
+               }
        }
 
        /*
This page took 0.027861 seconds and 5 git commands to generate.