Merge tag 'trace-v6.13-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...

Pull more tracing updates from Steven Rostedt:

 - Add trace flag for NEED_RESCHED_LAZY

   Now that NEED_RESCHED_LAZY is upstream, add it to the status bits of
   the common_flags. This will now show when the NEED_RESCHED_LAZY flag
   is set that is used for debugging latency issues in the kernel via a
   trace.

 - Remove leftover "__idx" variable when SRCU was removed from the
   tracepoint code

 - Add rcu_tasks_trace guard

   To add a guard() around the tracepoint code, a rcu_tasks_trace guard
   needs to be created first.

 - Remove __DO_TRACE() macro and just call __DO_TRACE_CALL() directly

   The DO_TRACE() macro has conditional locking depending on what was
   passed into the macro parameters. As the guts of the macro has been
   moved to __DO_TRACE_CALL() to handle static call logic, there's no
   reason to keep the __DO_TRACE() macro around.

   It is better to just do the locking in place without the conditionals
   and call __DO_TRACE_CALL() from those locations. The "cond" passed in
   can also be moved out of that macro. This simplifies the code.

 - Remove the "cond" from the system call tracepoint macros

   The "cond" variable was added to allow some tracepoints to check a
   condition within the static_branch (jump/nop) logic. The system calls
   do not need this. Removing it simplifies the code.

 - Replace scoped_guard() with just guard() in the tracepoint logic

   guard() works just as well as scoped_guard() in the tracepoint logic
   and the scoped_guard() causes some issues.

* tag 'trace-v6.13-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace:
  tracing: Use guard() rather than scoped_guard()
  tracing: Remove cond argument from __DECLARE_TRACE_SYSCALL
  tracing: Remove conditional locking from __DO_TRACE()
  rcupdate_trace: Define rcu_tasks_trace lock guard
  tracing: Remove __idx variable from __DO_TRACE
  tracing: Move it_func[0] comment to the relevant context
  tracing: Record task flag NEED_RESCHED_LAZY.

diff --cc include/linux/tracepoint.h
index 6073a8c7e38ce2ad9400365c9a1155dd25d388f8,e398f6e43f61ffb849352a50c7057eb73d4ea2cf..76d9055b2cff1cadaf402895524b8adeca090a15
--- 1/include/linux/tracepoint.h
--- 2/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@@ -209,48 -209,6 +209,18 @@@ static inline struct tracepoint *tracep
  #define __DO_TRACE_CALL(name, args)   __traceiter_##name(NULL, args)
  #endif /* CONFIG_HAVE_STATIC_CALL */
  
- /*
-  * it_func[0] is never NULL because there is at least one element in the array
-  * when the array itself is non NULL.
-  *
-  * With @syscall=0, the tracepoint callback array dereference is
-  * protected by disabling preemption.
-  * With @syscall=1, the tracepoint callback array dereference is
-  * protected by Tasks Trace RCU, which allows probes to handle page
-  * faults.
-  */
- #define __DO_TRACE(name, args, cond, syscall)                         \
-       do {                                                            \
-               int __maybe_unused __idx = 0;                           \
-                                                                       \
-               if (!(cond))                                            \
-                       return;                                         \
-                                                                       \
-               if (syscall)                                            \
-                       rcu_read_lock_trace();                          \
-               else                                                    \
-                       preempt_disable_notrace();                      \
-                                                                       \
-               __DO_TRACE_CALL(name, TP_ARGS(args));                   \
-                                                                       \
-               if (syscall)                                            \
-                       rcu_read_unlock_trace();                        \
-               else                                                    \
-                       preempt_enable_notrace();                       \
-       } while (0)
- 
 +/*
 + * Declare an exported function that Rust code can call to trigger this
 + * tracepoint. This function does not include the static branch; that is done
 + * in Rust to avoid a function call when the tracepoint is disabled.
 + */
 +#define DEFINE_RUST_DO_TRACE(name, proto, args)
 +#define __DEFINE_RUST_DO_TRACE(name, proto, args)                     \
 +      notrace void rust_do_trace_##name(proto)                        \
 +      {                                                               \
 +              __rust_do_trace_##name(args);                           \
 +      }
 +
  /*
   * Make sure the alignment of the structure in the __tracepoints section will
   * not add unwanted padding between the beginning of the section and the
@@@ -297,33 -254,23 +267,35 @@@
        }
  
  #define __DECLARE_TRACE(name, proto, args, cond, data_proto)          \
-       __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \
+       __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), PARAMS(data_proto)) \
 +      static inline void __rust_do_trace_##name(proto)                \
 +      {                                                               \
-               __DO_TRACE(name,                                        \
-                       TP_ARGS(args),                                  \
-                       TP_CONDITION(cond), 0);                         \
++              if (cond) {                                             \
++                      guard(preempt_notrace)();                       \
++                      __DO_TRACE_CALL(name, TP_ARGS(args));           \
++              }                                                       \
 +      }                                                               \
        static inline void trace_##name(proto)                          \
        {                                                               \
-               if (static_branch_unlikely(&__tracepoint_##name.key))   \
-                       __DO_TRACE(name,                                \
-                               TP_ARGS(args),                          \
-                               TP_CONDITION(cond), 0);                 \
+               if (static_branch_unlikely(&__tracepoint_##name.key)) { \
+                       if (cond) {                                     \
+                               guard(preempt_notrace)();               \
+                               __DO_TRACE_CALL(name, TP_ARGS(args));   \
+                       }                                               \
+               }                                                       \
                if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) {             \
                        WARN_ONCE(!rcu_is_watching(),                   \
                                  "RCU not watching for tracepoint");   \
                }                                                       \
        }
  
- #define __DECLARE_TRACE_SYSCALL(name, proto, args, cond, data_proto)  \
-       __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), cond, PARAMS(data_proto)) \
+ #define __DECLARE_TRACE_SYSCALL(name, proto, args, data_proto)                \
+       __DECLARE_TRACE_COMMON(name, PARAMS(proto), PARAMS(args), PARAMS(data_proto)) \
 +      static inline void __rust_do_trace_##name(proto)                \
 +      {                                                               \
-               __DO_TRACE(name,                                        \
-                       TP_ARGS(args),                                  \
-                       TP_CONDITION(cond), 1);                         \
++              guard(rcu_tasks_trace)();                               \
++              __DO_TRACE_CALL(name, TP_ARGS(args));                   \
 +      }                                                               \
        static inline void trace_##name(proto)                          \
        {                                                               \
                might_fault();                                          \