Fix: scsi: sd: Atomic write support added in 6.11-rc1

[lttng-modules.git] / include / lttng / tracepoint-event-impl.h

diff --git a/include/lttng/tracepoint-event-impl.h b/include/lttng/tracepoint-event-impl.h
index 8e55255666e12672d7a9ff01876ba4af72596cf4..a0053044f722cba42831e5babf4ab1d979cc98b8 100644 (file)
--- a/include/lttng/tracepoint-event-impl.h
+++ b/include/lttng/tracepoint-event-impl.h
@@ -11,12 +11,12 @@
 #include <linux/rculist.h>
 #include <asm/byteorder.h>
 #include <linux/swab.h>
+#include <linux/user_namespace.h>
 
 #include <wrapper/vmalloc.h>   /* for wrapper_vmalloc_sync_mappings() */
 #include <ringbuffer/frontend_types.h>
 #include <ringbuffer/backend.h>
 #include <wrapper/rcu.h>
-#include <wrapper/user_namespace.h>
 #include <lttng/types.h>
 #include <lttng/probe-user.h>
 #include <lttng/events.h>
@@ -1065,6 +1065,7 @@ static void __event_probe__##_name(_data_proto)                                           \
 {                                                                                      \
        struct probe_local_vars { _locvar };                                            \
        struct lttng_kernel_event_common *__event = __data;                             \
+       struct lttng_kernel_channel_common *__chan_common;                              \
        struct lttng_kernel_probe_ctx __lttng_probe_ctx = {                             \
                .event = __event,                                                       \
                .interruptible = !irqs_disabled(),                                      \
@@ -1079,20 +1080,18 @@ static void __event_probe__##_name(_data_proto)                                         \
                        &__tp_locvar;                                                   \
        bool __interpreter_stack_prepared = false;                                      \
                                                                                        \
-       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); \
-               struct lttng_kernel_channel_buffer *__chan = __event_recorder->chan;    \
-               struct lttng_kernel_session *__session = __chan->parent.session;        \
+       if (unlikely(!READ_ONCE(__event->enabled)))                                     \
+               return;                                                                 \
+       __chan_common = lttng_kernel_get_chan_common_from_event_common(__event);        \
+       if (__chan_common) {                                                            \
+               struct lttng_kernel_session *__session = __chan_common->session;        \
                struct lttng_kernel_id_tracker_rcu *__lf;                               \
                                                                                        \
                if (!_TP_SESSION_CHECK(session, __session))                             \
                        return;                                                         \
                if (unlikely(!LTTNG_READ_ONCE(__session->active)))                      \
                        return;                                                         \
-               if (unlikely(!LTTNG_READ_ONCE(__chan->parent.enabled)))                 \
+               if (unlikely(!LTTNG_READ_ONCE(__chan_common->enabled)))                 \
                        return;                                                         \
                __lf = lttng_rcu_dereference(__session->pid_tracker.p);                 \
                if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid)))      \
@@ -1102,29 +1101,21 @@ static void __event_probe__##_name(_data_proto)                                         \
                        return;                                                         \
                __lf = lttng_rcu_dereference(__session->uid_tracker.p);                 \
                if (__lf && likely(!lttng_id_tracker_lookup(__lf,                       \
-                               lttng_current_uid())))                                  \
+                               from_kuid_munged(&init_user_ns, current_uid()))))       \
                        return;                                                         \
                __lf = lttng_rcu_dereference(__session->vuid_tracker.p);                \
                if (__lf && likely(!lttng_id_tracker_lookup(__lf,                       \
-                               lttng_current_vuid())))                                 \
+                               from_kuid_munged(current_user_ns(), current_uid()))))   \
                        return;                                                         \
                __lf = lttng_rcu_dereference(__session->gid_tracker.p);                 \
                if (__lf && likely(!lttng_id_tracker_lookup(__lf,                       \
-                               lttng_current_gid())))                                  \
+                               from_kgid_munged(&init_user_ns, current_gid()))))       \
                        return;                                                         \
                __lf = lttng_rcu_dereference(__session->vgid_tracker.p);                \
                if (__lf && likely(!lttng_id_tracker_lookup(__lf,                       \
-                               lttng_current_vgid())))                                 \
+                               from_kgid_munged(current_user_ns(), current_gid()))))   \
                        return;                                                         \
-               break;                                                                  \
-       }                                                                               \
-       case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:                                          \
-               break;                                                                  \
-       default:                                                                        \
-               WARN_ON_ONCE(1);                                                        \
        }                                                                               \
-       if (unlikely(!READ_ONCE(__event->enabled)))                                     \
-               return;                                                                 \
        __orig_dynamic_len_offset = this_cpu_ptr(&lttng_dynamic_len_stack)->offset;     \
        __dynamic_len_idx = __orig_dynamic_len_offset;                                  \
        _code_pre                                                                       \
@@ -1180,6 +1171,24 @@ static void __event_probe__##_name(_data_proto)                                          \
                                &__notif_ctx);                                          \
                break;                                                                  \
        }                                                                               \
+       case LTTNG_KERNEL_EVENT_TYPE_COUNTER:                                           \
+       {                                                                               \
+               struct lttng_kernel_event_counter *__event_counter =                    \
+                       container_of(__event, struct lttng_kernel_event_counter, parent); \
+               struct lttng_kernel_event_counter_ctx __event_counter_ctx;              \
+                                                                                       \
+               __event_counter_ctx.args_available = LTTNG_READ_ONCE(__event_counter->use_args); \
+               if (unlikely(!__interpreter_stack_prepared && __event_counter_ctx.args_available)) \
+                       __event_prepare_interpreter_stack__##_name(                     \
+                                       __stackvar.__interpreter_stack_data,            \
+                                       _locvar_args);                                  \
+                                                                                       \
+               (void) __event_counter->chan->ops->counter_hit(__event_counter,         \
+                               __stackvar.__interpreter_stack_data,                    \
+                               &__lttng_probe_ctx,                                     \
+                               &__event_counter_ctx);                                  \
+               break;                                                                  \
+       }                                                                               \
        default:                                                                        \
                WARN_ON_ONCE(1);                                                        \
        }                                                                               \