Refactoring: combine register_event common code

[lttng-modules.git] / src / lttng-events.c

diff --git a/src/lttng-events.c b/src/lttng-events.c
index b5b1bcec9fb164d24923eb7859d19ea0c6e407a9..9dec9d3816bf74266d0e664b7aa4833e360d4c12 100644 (file)
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -360,7 +360,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
        mutex_lock(&sessions_mutex);
        WRITE_ONCE(session->active, 0);
        list_for_each_entry(chan_priv, &session->priv->chan, node) {
-               ret = lttng_syscalls_unregister_channel(chan_priv->pub);
+               ret = lttng_syscalls_unregister_syscall_table(&chan_priv->parent.syscall_table);
                WARN_ON(ret);
        }
        list_for_each_entry(event_recorder_priv, &session->priv->events, node) {
@@ -369,7 +369,7 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
        }
        synchronize_trace();    /* Wait for in-flight events to complete */
        list_for_each_entry(chan_priv, &session->priv->chan, node) {
-               ret = lttng_syscalls_destroy_channel(chan_priv->pub);
+               ret = lttng_syscalls_destroy_syscall_table(&chan_priv->parent.syscall_table);
                WARN_ON(ret);
        }
        list_for_each_entry_safe(event_recorder_enabler, tmp_event_recorder_enabler,
@@ -410,7 +410,7 @@ void lttng_event_notifier_group_destroy(
 
        mutex_lock(&sessions_mutex);
 
-       ret = lttng_syscalls_unregister_event_notifier_group(event_notifier_group);
+       ret = lttng_syscalls_unregister_syscall_table(&event_notifier_group->syscall_table);
        WARN_ON(ret);
 
        list_for_each_entry_safe(event_notifier_priv, tmpevent_notifier_priv,
@@ -424,7 +424,8 @@ void lttng_event_notifier_group_destroy(
 
        irq_work_sync(&event_notifier_group->wakeup_pending);
 
-       kfree(event_notifier_group->syscall_table.sc_filter);
+       ret = lttng_syscalls_destroy_syscall_table(&event_notifier_group->syscall_table);
+       WARN_ON(ret);
 
        list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler,
                        &event_notifier_group->enablers_head, node)
@@ -980,7 +981,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                                event_param->u.kprobe.symbol_name,
                                event_param->u.kprobe.offset,
                                event_param->u.kprobe.addr,
-                               event_recorder);
+                               &event_recorder->parent);
                if (ret) {
                        ret = -EINVAL;
                        goto register_error;
@@ -1035,7 +1036,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                                event_param->u.kretprobe.symbol_name,
                                event_param->u.kretprobe.offset,
                                event_param->u.kretprobe.addr,
-                               event_recorder, event_recorder_return);
+                               &event_recorder->parent, &event_recorder_return->parent);
                if (ret) {
                        kmem_cache_free(event_recorder_private_cache, event_recorder_return_priv);
                        kmem_cache_free(event_recorder_cache, event_recorder_return);
@@ -1113,7 +1114,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 
                ret = lttng_uprobes_register_event(event_param->name,
                                event_param->u.uprobe.fd,
-                               event_recorder);
+                               &event_recorder->parent);
                if (ret)
                        goto register_error;
                ret = try_module_get(event_recorder->priv->parent.desc->owner);
@@ -1256,11 +1257,11 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create(
                 * registration.
                 */
                smp_wmb();
-               ret = lttng_kprobes_register_event_notifier(
+               ret = lttng_kprobes_register_event(event_notifier_param->event.u.kprobe.symbol_name,
                                event_notifier_param->event.u.kprobe.symbol_name,
                                event_notifier_param->event.u.kprobe.offset,
                                event_notifier_param->event.u.kprobe.addr,
-                               event_notifier);
+                               &event_notifier->parent);
                if (ret) {
                        ret = -EINVAL;
                        goto register_error;
@@ -1320,10 +1321,9 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create(
                 */
                smp_wmb();
 
-               ret = lttng_uprobes_register_event_notifier(
-                               event_notifier_param->event.name,
+               ret = lttng_uprobes_register_event(event_notifier_param->event.name,
                                event_notifier_param->event.u.uprobe.fd,
-                               event_notifier);
+                               &event_notifier->parent);
                if (ret)
                        goto register_error;
                ret = try_module_get(event_notifier->priv->parent.desc->owner);
@@ -1438,32 +1438,40 @@ struct lttng_kernel_event_notifier *lttng_event_notifier_create(
 
 /* Only used for tracepoints for now. */
 static
-void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder)
+void register_event(struct lttng_kernel_event_common *event)
 {
        const struct lttng_kernel_event_desc *desc;
        int ret = -EINVAL;
 
-       if (event_recorder->priv->parent.registered)
+       if (event->priv->registered)
                return;
 
-       desc = event_recorder->priv->parent.desc;
-       switch (event_recorder->priv->parent.instrumentation) {
+       desc = event->priv->desc;
+       switch (event->priv->instrumentation) {
        case LTTNG_KERNEL_ABI_TRACEPOINT:
                ret = lttng_wrapper_tracepoint_probe_register(desc->event_kname,
                                                  desc->tp_class->probe_callback,
-                                                 event_recorder);
+                                                 event);
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               ret = lttng_syscall_filter_enable_event_recorder(event_recorder);
+               ret = lttng_syscall_filter_enable_event(event);
                break;
 
        case LTTNG_KERNEL_ABI_KPROBE:
                lttng_fallthrough;
        case LTTNG_KERNEL_ABI_UPROBE:
-               lttng_fallthrough;
-       case LTTNG_KERNEL_ABI_KRETPROBE:
                ret = 0;
+
+       case LTTNG_KERNEL_ABI_KRETPROBE:
+               switch (event->type) {
+               case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+                       ret = 0;
+                       break;
+               case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+                       WARN_ON_ONCE(1);
+                       break;
+               }
                break;
 
        case LTTNG_KERNEL_ABI_FUNCTION:
@@ -1474,7 +1482,7 @@ void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder)
                WARN_ON_ONCE(1);
        }
        if (!ret)
-               event_recorder->priv->parent.registered = 1;
+               event->priv->registered = 1;
 }
 
 /*
@@ -1494,21 +1502,21 @@ int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_r
        case LTTNG_KERNEL_ABI_TRACEPOINT:
                ret = lttng_wrapper_tracepoint_probe_unregister(event_priv->desc->event_kname,
                                                  event_priv->desc->tp_class->probe_callback,
-                                                 event_recorder);
+                                                 &event_recorder->parent);
                break;
 
        case LTTNG_KERNEL_ABI_KPROBE:
-               lttng_kprobes_unregister_event(event_recorder);
+               lttng_kprobes_unregister_event(&event_recorder->parent);
                ret = 0;
                break;
 
        case LTTNG_KERNEL_ABI_KRETPROBE:
-               lttng_kretprobes_unregister(event_recorder);
+               lttng_kretprobes_unregister(&event_recorder->parent);
                ret = 0;
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               ret = lttng_syscall_filter_disable_event_recorder(event_recorder);
+               ret = lttng_syscall_filter_disable_event(&event_recorder->parent);
                break;
 
        case LTTNG_KERNEL_ABI_NOOP:
@@ -1516,7 +1524,7 @@ int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_r
                break;
 
        case LTTNG_KERNEL_ABI_UPROBE:
-               lttng_uprobes_unregister_event(event_recorder);
+               lttng_uprobes_unregister_event(&event_recorder->parent);
                ret = 0;
                break;
 
@@ -1530,47 +1538,6 @@ int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_r
        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->tp_class->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:
-               lttng_fallthrough;
-       case LTTNG_KERNEL_ABI_UPROBE:
-               ret = 0;
-               break;
-
-       case LTTNG_KERNEL_ABI_KRETPROBE:
-               lttng_fallthrough;
-       case LTTNG_KERNEL_ABI_FUNCTION:
-               lttng_fallthrough;
-       case LTTNG_KERNEL_ABI_NOOP:
-               lttng_fallthrough;
-       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)
@@ -1586,21 +1553,21 @@ int _lttng_event_notifier_unregister(
        case LTTNG_KERNEL_ABI_TRACEPOINT:
                ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->priv->parent.desc->event_kname,
                                                  event_notifier->priv->parent.desc->tp_class->probe_callback,
-                                                 event_notifier);
+                                                 &event_notifier->parent);
                break;
 
        case LTTNG_KERNEL_ABI_KPROBE:
-               lttng_kprobes_unregister_event_notifier(event_notifier);
+               lttng_kprobes_unregister_event(&event_notifier->parent);
                ret = 0;
                break;
 
        case LTTNG_KERNEL_ABI_UPROBE:
-               lttng_uprobes_unregister_event_notifier(event_notifier);
+               lttng_uprobes_unregister_event(&event_notifier->parent);
                ret = 0;
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               ret = lttng_syscall_filter_disable_event_notifier(event_notifier);
+               ret = lttng_syscall_filter_disable_event(&event_notifier->parent);
                break;
 
        case LTTNG_KERNEL_ABI_KRETPROBE:
@@ -1645,12 +1612,12 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event)
 
                case LTTNG_KERNEL_ABI_KPROBE:
                        module_put(event_priv->desc->owner);
-                       lttng_kprobes_destroy_event_private(event_recorder);
+                       lttng_kprobes_destroy_event_private(&event_recorder->parent);
                        break;
 
                case LTTNG_KERNEL_ABI_KRETPROBE:
                        module_put(event_priv->desc->owner);
-                       lttng_kretprobes_destroy_private(event_recorder);
+                       lttng_kretprobes_destroy_private(&event_recorder->parent);
                        break;
 
                case LTTNG_KERNEL_ABI_SYSCALL:
@@ -1658,7 +1625,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event)
 
                case LTTNG_KERNEL_ABI_UPROBE:
                        module_put(event_priv->desc->owner);
-                       lttng_uprobes_destroy_event_private(event_recorder);
+                       lttng_uprobes_destroy_event_private(&event_recorder->parent);
                        break;
 
                case LTTNG_KERNEL_ABI_FUNCTION:
@@ -1685,7 +1652,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event)
 
                case LTTNG_KERNEL_ABI_KPROBE:
                        module_put(event_notifier->priv->parent.desc->owner);
-                       lttng_kprobes_destroy_event_notifier_private(event_notifier);
+                       lttng_kprobes_destroy_event_private(&event_notifier->parent);
                        break;
 
                case LTTNG_KERNEL_ABI_SYSCALL:
@@ -1693,7 +1660,7 @@ void _lttng_event_destroy(struct lttng_kernel_event_common *event)
 
                case LTTNG_KERNEL_ABI_UPROBE:
                        module_put(event_notifier->priv->parent.desc->owner);
-                       lttng_uprobes_destroy_event_notifier_private(event_notifier);
+                       lttng_uprobes_destroy_event_private(&event_notifier->parent);
                        break;
 
                case LTTNG_KERNEL_ABI_KRETPROBE:
@@ -2238,7 +2205,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi
 }
 
 static
-void lttng_create_syscall_event_if_missing(struct lttng_event_recorder_enabler *event_enabler)
+void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler)
 {
        int ret;
 
@@ -2246,17 +2213,6 @@ void lttng_create_syscall_event_if_missing(struct lttng_event_recorder_enabler *
        WARN_ON_ONCE(ret);
 }
 
-static
-void lttng_create_syscall_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
-{
-       int ret;
-
-       ret = lttng_syscalls_register_event_notifier(event_notifier_enabler);
-       WARN_ON_ONCE(ret);
-       ret = lttng_syscalls_create_matching_event_notifiers(event_notifier_enabler);
-       WARN_ON_ONCE(ret);
-}
-
 /*
  * Create struct lttng_kernel_event_recorder if it is missing and present in the list of
  * tracepoint probes.
@@ -2271,7 +2227,7 @@ void lttng_create_event_if_missing(struct lttng_event_recorder_enabler *event_en
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               lttng_create_syscall_event_if_missing(event_enabler);
+               lttng_create_syscall_event_if_missing(&event_enabler->parent);
                break;
 
        default:
@@ -2357,7 +2313,7 @@ void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler);
+               lttng_create_syscall_event_if_missing(&event_notifier_enabler->parent);
                break;
 
        default:
@@ -2787,7 +2743,7 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session)
                 * state.
                 */
                if (enabled) {
-                       register_event_recorder(event_recorder);
+                       register_event(&event_recorder->parent);
                } else {
                        _lttng_event_recorder_unregister(event_recorder);
                }
@@ -2877,7 +2833,7 @@ void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group
                 */
                if (enabled) {
                        if (!event_notifier_priv->parent.registered)
-                               register_event_notifier(event_notifier);
+                               register_event(&event_notifier->parent);
                } else {
                        if (event_notifier_priv->parent.registered)
                                _lttng_event_notifier_unregister(event_notifier);