#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>
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;
}
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;
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++)
&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);
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;
lttng_enabler_link_bytecode(event->desc,
&session->ctx,
&event->filter_bytecode_runtime_head,
- lttng_event_enabler_as_enabler(event_enabler));
+ <tng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head);
/* TODO: merge event context. */
}
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,
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)
/* 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();
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;
* 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,
+ <tng_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;
/* 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();