Implement libcounter

[deliverable/lttng-ust.git] / liblttng-ust / lttng-events.c

diff --git a/liblttng-ust/lttng-events.c b/liblttng-ust/lttng-events.c
index 495536762407cc9dbe01163472bc3d279f0036cd..6a089122c8d1a2afee87f1a77e353aa4d7467736 100644 (file)
--- a/liblttng-ust/lttng-events.c
+++ b/liblttng-ust/lttng-events.c
@@ -59,12 +59,15 @@
 
 #include "tracepoint-internal.h"
 #include "string-utils.h"
+#include "lttng-bytecode.h"
 #include "lttng-tracer.h"
 #include "lttng-tracer-core.h"
 #include "lttng-ust-statedump.h"
+#include "context-internal.h"
 #include "ust-events-internal.h"
 #include "wait.h"
 #include "../libringbuffer/shm.h"
+#include "../libcounter/counter.h"
 #include "jhash.h"
 #include <lttng/ust-abi.h>
 
@@ -153,7 +156,7 @@ struct lttng_session *lttng_session_create(void)
        session = zmalloc(sizeof(struct lttng_session));
        if (!session)
                return NULL;
-       if (lttng_session_context_init(&session->ctx)) {
+       if (lttng_context_init_all(&session->ctx)) {
                free(session);
                return NULL;
        }
@@ -169,6 +172,46 @@ struct lttng_session *lttng_session_create(void)
        return session;
 }
 
+struct lttng_counter *lttng_ust_counter_create(
+               const char *counter_transport_name,
+               size_t number_dimensions, const struct lttng_counter_dimension *dimensions)
+{
+       struct lttng_counter_transport *counter_transport = NULL;
+       struct lttng_counter *counter = NULL;
+
+       counter_transport = lttng_counter_transport_find(counter_transport_name);
+       if (!counter_transport)
+               goto notransport;
+       counter = zmalloc(sizeof(struct lttng_counter));
+       if (!counter)
+               goto nomem;
+
+       counter->ops = &counter_transport->ops;
+       counter->transport = counter_transport;
+
+       counter->counter = counter->ops->counter_create(
+                       number_dimensions, dimensions, 0,
+                       -1, 0, NULL, false);
+       if (!counter->counter) {
+               goto create_error;
+       }
+
+       return counter;
+
+create_error:
+       free(counter);
+nomem:
+notransport:
+       return NULL;
+}
+
+static
+void lttng_ust_counter_destroy(struct lttng_counter *counter)
+{
+       counter->ops->counter_destroy(counter->counter);
+       free(counter);
+}
+
 struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
 {
        struct lttng_event_notifier_group *event_notifier_group;
@@ -178,6 +221,12 @@ struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
        if (!event_notifier_group)
                return NULL;
 
+       /* Add all contexts. */
+       if (lttng_context_init_all(&event_notifier_group->ctx)) {
+               free(event_notifier_group);
+               return NULL;
+       }
+
        CDS_INIT_LIST_HEAD(&event_notifier_group->enablers_head);
        CDS_INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
        for (i = 0; i < LTTNG_UST_EVENT_NOTIFIER_HT_SIZE; i++)
@@ -344,7 +393,10 @@ void lttng_event_notifier_group_destroy(
                        &event_notifier_group->event_notifiers_head, node)
                _lttng_event_notifier_destroy(notifier);
 
-       /* Close the notification fd to the listener of event notifiers. */
+       if (event_notifier_group->error_counter)
+               lttng_ust_counter_destroy(event_notifier_group->error_counter);
+
+       /* Close the notification fd to the listener of event_notifiers. */
 
        lttng_ust_lock_fd_tracker();
        close_ret = close(event_notifier_group->notification_fd);
@@ -365,7 +417,7 @@ void lttng_event_notifier_group_destroy(
 static
 void lttng_enabler_destroy(struct lttng_enabler *enabler)
 {
-       struct lttng_ust_filter_bytecode_node *filter_node, *tmp_filter_node;
+       struct lttng_ust_bytecode_node *filter_node, *tmp_filter_node;
        struct lttng_ust_excluder_node *excluder_node, *tmp_excluder_node;
 
        if (!enabler) {
@@ -818,6 +870,7 @@ int lttng_event_notifier_create(const struct lttng_event_desc *desc,
        event_notifier->registered = 0;
 
        CDS_INIT_LIST_HEAD(&event_notifier->filter_bytecode_runtime_head);
+       CDS_INIT_LIST_HEAD(&event_notifier->capture_bytecode_runtime_head);
        CDS_INIT_LIST_HEAD(&event_notifier->enablers_ref_head);
        event_notifier->desc = desc;
 
@@ -1222,7 +1275,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
                lttng_enabler_link_bytecode(event->desc,
                        &session->ctx,
                        &event->filter_bytecode_runtime_head,
-                       lttng_event_enabler_as_enabler(event_enabler));
+                       &lttng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head);
 
                /* TODO: merge event context. */
        }
@@ -1360,9 +1413,11 @@ struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
                return NULL;
        event_notifier_enabler->base.format_type = format_type;
        CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head);
+       CDS_INIT_LIST_HEAD(&event_notifier_enabler->capture_bytecode_head);
        CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.excluder_head);
 
        event_notifier_enabler->user_token = event_notifier_param->event.token;
+       event_notifier_enabler->num_captures = 0;
 
        memcpy(&event_notifier_enabler->base.event_param.name,
                event_notifier_param->event.name,
@@ -1403,14 +1458,14 @@ int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler)
 
 static
 void _lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler,
-               struct lttng_ust_filter_bytecode_node *bytecode)
+               struct lttng_ust_bytecode_node *bytecode)
 {
        bytecode->enabler = enabler;
        cds_list_add_tail(&bytecode->node, &enabler->filter_bytecode_head);
 }
 
 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler,
-               struct lttng_ust_filter_bytecode_node *bytecode)
+               struct lttng_ust_bytecode_node *bytecode)
 {
        _lttng_enabler_attach_filter_bytecode(
                lttng_event_enabler_as_enabler(event_enabler), bytecode);
@@ -1457,7 +1512,7 @@ int lttng_event_notifier_enabler_disable(
 
 int lttng_event_notifier_enabler_attach_filter_bytecode(
                struct lttng_event_notifier_enabler *event_notifier_enabler,
-               struct lttng_ust_filter_bytecode_node *bytecode)
+               struct lttng_ust_bytecode_node *bytecode)
 {
        _lttng_enabler_attach_filter_bytecode(
                lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
@@ -1467,6 +1522,20 @@ int lttng_event_notifier_enabler_attach_filter_bytecode(
        return 0;
 }
 
+int lttng_event_notifier_enabler_attach_capture_bytecode(
+               struct lttng_event_notifier_enabler *event_notifier_enabler,
+               struct lttng_ust_bytecode_node *bytecode)
+{
+       bytecode->enabler = lttng_event_notifier_enabler_as_enabler(
+                       event_notifier_enabler);
+       cds_list_add_tail(&bytecode->node,
+                       &event_notifier_enabler->capture_bytecode_head);
+       event_notifier_enabler->num_captures++;
+
+       lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
+       return 0;
+}
+
 int lttng_event_notifier_enabler_attach_exclusion(
                struct lttng_event_notifier_enabler *event_notifier_enabler,
                struct lttng_ust_excluder_node *excluder)
@@ -1635,7 +1704,7 @@ void lttng_session_sync_event_enablers(struct lttng_session *session)
                /* Enable filters */
                cds_list_for_each_entry(runtime,
                                &event->filter_bytecode_runtime_head, node) {
-                       lttng_filter_sync_state(runtime);
+                       lttng_bytecode_filter_sync_state(runtime);
                }
        }
        __tracepoint_probe_prune_release_queue();
@@ -1662,6 +1731,7 @@ void lttng_create_event_notifier_if_missing(
                        struct cds_hlist_node *node;
 
                        desc = probe_desc->event_desc[i];
+
                        if (!lttng_desc_match_enabler(desc,
                                        lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)))
                                continue;
@@ -1754,8 +1824,18 @@ int lttng_event_notifier_enabler_ref_event_notifiers(
                 * Link filter bytecodes if not linked yet.
                 */
                lttng_enabler_link_bytecode(event_notifier->desc,
-                       &event_notifier_group->ctx, &event_notifier->filter_bytecode_runtime_head,
-                       lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
+                       &event_notifier_group->ctx,
+                       &event_notifier->filter_bytecode_runtime_head,
+                       &lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
+
+               /*
+                * Link capture bytecodes if not linked yet.
+                */
+               lttng_enabler_link_bytecode(event_notifier->desc,
+                       &event_notifier_group->ctx, &event_notifier->capture_bytecode_runtime_head,
+                       &event_notifier_enabler->capture_bytecode_head);
+
+               event_notifier->num_captures = event_notifier_enabler->num_captures;
        }
 end:
        return 0;
@@ -1816,7 +1896,13 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
                /* Enable filters */
                cds_list_for_each_entry(runtime,
                                &event_notifier->filter_bytecode_runtime_head, node) {
-                       lttng_filter_sync_state(runtime);
+                       lttng_bytecode_filter_sync_state(runtime);
+               }
+
+               /* Enable captures. */
+               cds_list_for_each_entry(runtime,
+                               &event_notifier->capture_bytecode_runtime_head, node) {
+                       lttng_bytecode_capture_sync_state(runtime);
                }
        }
        __tracepoint_probe_prune_release_queue();