+ switch (itype) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ /* Event will be enabled by enabler sync. */
+ event_notifier->parent.enabled = 0;
+ event_notifier->priv->parent.registered = 0;
+ event_notifier->priv->parent.desc = lttng_event_desc_get(event_name);
+ if (!event_notifier->priv->parent.desc) {
+ ret = -ENOENT;
+ goto register_error;
+ }
+ /* Populate lttng_event_notifier structure before event registration. */
+ smp_wmb();
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ /*
+ * Needs to be explicitly enabled after creation, since
+ * we may want to apply filters.
+ */
+ event_notifier->parent.enabled = 0;
+ event_notifier->priv->parent.registered = 1;
+ /*
+ * Populate lttng_event_notifier structure before event
+ * registration.
+ */
+ smp_wmb();
+ ret = lttng_kprobes_register_event_notifier(
+ event_notifier_param->event.u.kprobe.symbol_name,
+ event_notifier_param->event.u.kprobe.offset,
+ event_notifier_param->event.u.kprobe.addr,
+ event_notifier);
+ if (ret) {
+ ret = -EINVAL;
+ goto register_error;
+ }
+ ret = try_module_get(event_notifier->priv->parent.desc->owner);
+ WARN_ON_ONCE(!ret);
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ /*
+ * Needs to be explicitly enabled after creation, since
+ * we may want to apply filters.
+ */
+ event_notifier->parent.enabled = 0;
+ event_notifier->priv->parent.registered = 0;
+ event_notifier->priv->parent.desc = event_desc;
+ switch (event_notifier_param->event.u.syscall.entryexit) {
+ case LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT:
+ ret = -EINVAL;
+ goto register_error;
+ case LTTNG_KERNEL_ABI_SYSCALL_ENTRY:
+ event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
+ break;
+ case LTTNG_KERNEL_ABI_SYSCALL_EXIT:
+ event_notifier->priv->parent.u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
+ break;
+ }
+ switch (event_notifier_param->event.u.syscall.abi) {
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL:
+ ret = -EINVAL;
+ goto register_error;
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE:
+ event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
+ break;
+ case LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT:
+ event_notifier->priv->parent.u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
+ break;
+ }
+
+ if (!event_notifier->priv->parent.desc) {
+ ret = -EINVAL;
+ goto register_error;
+ }
+ break;
+
+ case LTTNG_KERNEL_ABI_UPROBE:
+ /*
+ * Needs to be explicitly enabled after creation, since
+ * we may want to apply filters.
+ */
+ event_notifier->parent.enabled = 0;
+ event_notifier->priv->parent.registered = 1;
+
+ /*
+ * Populate lttng_event_notifier structure before
+ * event_notifier registration.
+ */
+ smp_wmb();
+
+ ret = lttng_uprobes_register_event_notifier(
+ event_notifier_param->event.name,
+ event_notifier_param->event.u.uprobe.fd,
+ event_notifier);
+ if (ret)
+ goto register_error;
+ ret = try_module_get(event_notifier->priv->parent.desc->owner);
+ WARN_ON_ONCE(!ret);
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ ret = -EINVAL;
+ goto register_error;
+ }
+
+ list_add(&event_notifier->priv->node, &event_notifier_group->event_notifiers_head);
+ hlist_add_head(&event_notifier->priv->hlist, head);
+
+ /*
+ * Clear the error counter bucket. The sessiond keeps track of which
+ * bucket is currently in use. We trust it. The session lock
+ * synchronizes against concurrent creation of the error
+ * counter.
+ */
+ error_counter = event_notifier_group->error_counter;
+ if (error_counter) {
+ size_t dimension_index[1];
+
+ /*
+ * Check that the index is within the boundary of the counter.
+ */
+ if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) {
+ printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
+ event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index);
+ ret = -EINVAL;
+ goto register_error;
+ }
+
+ dimension_index[0] = event_notifier->priv->error_counter_index;
+ ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
+ if (ret) {
+ printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
+ event_notifier->priv->error_counter_index);
+ goto register_error;
+ }
+ }
+
+ return event_notifier;
+
+register_error:
+ kmem_cache_free(event_notifier_private_cache, event_notifier_priv);
+cache_private_error:
+ kmem_cache_free(event_notifier_cache, event_notifier);
+cache_error:
+exist:
+type_error:
+ return ERR_PTR(ret);
+}
+
+int lttng_kernel_counter_read(struct lttng_counter *counter,
+ const size_t *dim_indexes, int32_t cpu,
+ int64_t *val, bool *overflow, bool *underflow)
+{
+ return counter->ops->counter_read(counter->counter, dim_indexes,
+ cpu, val, overflow, underflow);
+}
+
+int lttng_kernel_counter_aggregate(struct lttng_counter *counter,
+ const size_t *dim_indexes, int64_t *val,
+ bool *overflow, bool *underflow)
+{
+ return counter->ops->counter_aggregate(counter->counter, dim_indexes,
+ val, overflow, underflow);
+}
+
+int lttng_kernel_counter_clear(struct lttng_counter *counter,
+ const size_t *dim_indexes)
+{
+ return counter->ops->counter_clear(counter->counter, dim_indexes);
+}
+
+struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_channel *chan,
+ struct lttng_kernel_abi_event *event_param,
+ const struct lttng_kernel_event_desc *event_desc,
+ enum lttng_kernel_abi_instrumentation itype)
+{
+ struct lttng_kernel_event_recorder *event;
+
+ mutex_lock(&sessions_mutex);
+ event = _lttng_kernel_event_recorder_create(chan, event_param, event_desc, itype);
+ mutex_unlock(&sessions_mutex);
+ return event;
+}
+
+struct lttng_kernel_event_notifier *lttng_event_notifier_create(
+ const struct lttng_kernel_event_desc *event_desc,
+ uint64_t id, uint64_t error_counter_index,
+ struct lttng_event_notifier_group *event_notifier_group,
+ struct lttng_kernel_abi_event_notifier *event_notifier_param,
+ enum lttng_kernel_abi_instrumentation itype)
+{
+ struct lttng_kernel_event_notifier *event_notifier;
+
+ mutex_lock(&sessions_mutex);
+ event_notifier = _lttng_event_notifier_create(event_desc, id,
+ error_counter_index, event_notifier_group,
+ event_notifier_param, itype);
+ mutex_unlock(&sessions_mutex);
+ return event_notifier;
+}
+
+/* Only used for tracepoints for now. */
+static
+void register_event(struct lttng_kernel_event_recorder *event_recorder)
+{
+ const struct lttng_kernel_event_desc *desc;
+ int ret = -EINVAL;
+
+ if (event_recorder->priv->parent.registered)
+ return;
+
+ desc = event_recorder->priv->parent.desc;
+ switch (event_recorder->priv->parent.instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
+ desc->probe_callback,
+ event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ ret = lttng_syscall_filter_enable_event(event_recorder->chan, event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_UPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ if (!ret)
+ event_recorder->priv->parent.registered = 1;
+}
+
+/*
+ * Only used internally at session destruction.
+ */
+int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder)
+{
+ struct lttng_kernel_event_common_private *event_priv = &event_recorder->priv->parent;
+ const struct lttng_kernel_event_desc *desc;
+ int ret = -EINVAL;
+
+ if (!event_priv->registered)
+ return 0;
+
+ desc = event_priv->desc;
+ switch (event_priv->instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ ret = lttng_wrapper_tracepoint_probe_unregister(event_priv->desc->event_kname,
+ event_priv->desc->probe_callback,
+ event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_kprobes_unregister_event(event_recorder);
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ lttng_kretprobes_unregister(event_recorder);
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ ret = lttng_syscall_filter_disable_event(event_recorder->chan, event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_NOOP:
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_UPROBE:
+ lttng_uprobes_unregister_event(event_recorder);
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ if (!ret)
+ event_priv->registered = 0;
+ return ret;
+}
+
+/* Only used for tracepoints for now. */
+static
+void register_event_notifier(struct lttng_kernel_event_notifier *event_notifier)
+{
+ const struct lttng_kernel_event_desc *desc;
+ int ret = -EINVAL;
+
+ if (event_notifier->priv->parent.registered)
+ return;
+
+ desc = event_notifier->priv->parent.desc;
+ switch (event_notifier->priv->parent.instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
+ desc->probe_callback,
+ event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ ret = lttng_syscall_filter_enable_event_notifier(event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_UPROBE:
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ if (!ret)
+ event_notifier->priv->parent.registered = 1;
+}
+
+static
+int _lttng_event_notifier_unregister(
+ struct lttng_kernel_event_notifier *event_notifier)
+{
+ const struct lttng_kernel_event_desc *desc;
+ int ret = -EINVAL;
+
+ if (!event_notifier->priv->parent.registered)
+ return 0;
+
+ desc = event_notifier->priv->parent.desc;
+ switch (event_notifier->priv->parent.instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->priv->parent.desc->event_kname,
+ event_notifier->priv->parent.desc->probe_callback,
+ event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ lttng_kprobes_unregister_event_notifier(event_notifier);
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_UPROBE:
+ lttng_uprobes_unregister_event_notifier(event_notifier);
+ ret = 0;
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ ret = lttng_syscall_filter_disable_event_notifier(event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ if (!ret)
+ event_notifier->priv->parent.registered = 0;
+ return ret;
+}
+
+/*
+ * Only used internally at session destruction.
+ */
+static
+void _lttng_event_destroy(struct lttng_kernel_event_common *event)
+{
+ struct lttng_kernel_event_common_private *event_priv = event->priv;
+ struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
+
+ lttng_free_event_filter_runtime(event);
+ /* Free event enabler refs */
+ list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
+ &event_priv->enablers_ref_head, node)
+ kfree(enabler_ref);
+
+ switch (event->type) {
+ case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+ {
+ struct lttng_kernel_event_recorder *event_recorder =
+ container_of(event, struct lttng_kernel_event_recorder, parent);
+
+ switch (event_priv->instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ lttng_event_desc_put(event_priv->desc);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ module_put(event_priv->desc->owner);
+ lttng_kprobes_destroy_event_private(event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE:
+ module_put(event_priv->desc->owner);
+ lttng_kretprobes_destroy_private(event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ break;
+
+ case LTTNG_KERNEL_ABI_UPROBE:
+ module_put(event_priv->desc->owner);
+ lttng_uprobes_destroy_event_private(event_recorder);
+ break;
+
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ list_del(&event_recorder->priv->node);
+ kmem_cache_free(event_recorder_private_cache, event_recorder->priv);
+ kmem_cache_free(event_recorder_cache, event_recorder);
+ break;
+ }
+ case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+ {
+ struct lttng_kernel_event_notifier *event_notifier =
+ container_of(event, struct lttng_kernel_event_notifier, parent);
+
+ switch (event_notifier->priv->parent.instrumentation) {
+ case LTTNG_KERNEL_ABI_TRACEPOINT:
+ lttng_event_desc_put(event_notifier->priv->parent.desc);
+ break;
+
+ case LTTNG_KERNEL_ABI_KPROBE:
+ module_put(event_notifier->priv->parent.desc->owner);
+ lttng_kprobes_destroy_event_notifier_private(event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_SYSCALL:
+ break;
+
+ case LTTNG_KERNEL_ABI_UPROBE:
+ module_put(event_notifier->priv->parent.desc->owner);
+ lttng_uprobes_destroy_event_notifier_private(event_notifier);
+ break;
+
+ case LTTNG_KERNEL_ABI_KRETPROBE: /* Fall-through */
+ case LTTNG_KERNEL_ABI_FUNCTION: /* Fall-through */
+ case LTTNG_KERNEL_ABI_NOOP: /* Fall-through */
+ default:
+ WARN_ON_ONCE(1);
+ }
+ list_del(&event_notifier->priv->node);
+ kmem_cache_free(event_notifier_private_cache, event_notifier->priv);
+ kmem_cache_free(event_notifier_cache, event_notifier);
+ break;
+ }
+ default:
+ WARN_ON_ONCE(1);
+ }
+}
+
+struct lttng_id_tracker *get_tracker(struct lttng_session *session,
+ enum tracker_type tracker_type)