rcu: Event-trace markers for computing RCU CPU utilization

This commit adds the trace_rcu_utilization() marker that is to be
used to allow postprocessing scripts compute RCU's CPU utilization,
give or take event-trace overhead.  Note that we do not include RCU's
dyntick-idle interface because event tracing requires RCU protection,
which is not available in dyntick-idle mode.

Signed-off-by: Paul E. McKenney <paul.mckenney@linaro.org>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>

1 files changed, 53 insertions, 20 deletions

diff --git a/include/trace/events/rcu.h b/include/trace/events/rcu.h
index db3f6e9e63e6..ab458eb689fb 100644
--- a/include/trace/events/rcu.h
+++ b/include/trace/events/rcu.h
@@ -7,29 +7,58 @@
 #include <linux/tracepoint.h>
 
 /*
- * Tracepoint for calling rcu_do_batch, performed to start callback invocation:
+ * Tracepoint for start/end markers used for utilization calculations.
+ * By convention, the string is of the following forms:
+ *
+ * "Start <activity>" -- Mark the start of the specified activity,
+ *                       such as "context switch".  Nesting is permitted.
+ * "End <activity>" -- Mark the end of the specified activity.
+ */
+TRACE_EVENT(rcu_utilization,
+
+        TP_PROTO(char *s),
+
+        TP_ARGS(s),
+
+        TP_STRUCT__entry(
+                __field(char *, s)
+        ),
+
+        TP_fast_assign(
+                __entry->s = s;
+        ),
+
+        TP_printk("%s", __entry->s)
+);
+
+/*
+ * Tracepoint for marking the beginning rcu_do_batch, performed to start
+ * RCU callback invocation.  The first argument is the total number of
+ * callbacks (including those that are not yet ready to be invoked),
+ * and the second argument is the current RCU-callback batch limit.
  */
 TRACE_EVENT(rcu_batch_start,
 
-        TP_PROTO(long callbacks_ready, int blimit),
+        TP_PROTO(long qlen, int blimit),
 
-        TP_ARGS(callbacks_ready, blimit),
+        TP_ARGS(qlen, blimit),
 
         TP_STRUCT__entry(
-                __field(        long,   callbacks_ready         )
-                __field(        int,    blimit                  )
+                __field(long, qlen)
+                __field(int, blimit)
         ),
 
         TP_fast_assign(
-                __entry->callbacks_ready        = callbacks_ready;
-                __entry->blimit                 = blimit;
+                __entry->qlen = qlen;
+                __entry->blimit = blimit;
         ),
 
-        TP_printk("CBs=%ld bl=%d", __entry->callbacks_ready, __entry->blimit)
+        TP_printk("CBs=%ld bl=%d", __entry->qlen, __entry->blimit)
 );
 
 /*
- * Tracepoint for the invocation of a single RCU callback
+ * Tracepoint for the invocation of a single RCU callback function.
+ * The argument is a pointer to the RCU callback itself.
  */
 TRACE_EVENT(rcu_invoke_callback,
 
@@ -38,20 +67,23 @@ TRACE_EVENT(rcu_invoke_callback,
         TP_ARGS(rhp),
 
         TP_STRUCT__entry(
-                __field(        void *, rhp     )
-                __field(        void *, func    )
+                __field(void *, rhp)
+                __field(void *, func)
         ),
 
         TP_fast_assign(
-                __entry->rhp    = rhp;
-                __entry->func   = rhp->func;
+                __entry->rhp = rhp;
+                __entry->func = rhp->func;
         ),
 
         TP_printk("rhp=%p func=%pf", __entry->rhp, __entry->func)
 );
 
 /*
- * Tracepoint for the invocation of a single RCU kfree callback
+ * Tracepoint for the invocation of a single RCU callback of the special
+ * kfree() form.  The first argument is a pointer to the RCU callback
+ * and the second argument is the offset of the callback within the
+ * enclosing RCU-protected data structure.
  */
 TRACE_EVENT(rcu_invoke_kfree_callback,
 
@@ -60,12 +92,12 @@ TRACE_EVENT(rcu_invoke_kfree_callback,
         TP_ARGS(rhp, offset),
 
         TP_STRUCT__entry(
-                __field(void *, rhp     )
-                __field(unsigned long,  offset  )
+                __field(void *, rhp)
+                __field(unsigned long, offset)
         ),
 
         TP_fast_assign(
-                __entry->rhp    = rhp;
+                __entry->rhp = rhp;
                 __entry->offset = offset;
         ),
 
@@ -73,7 +105,8 @@ TRACE_EVENT(rcu_invoke_kfree_callback,
 );
 
 /*
- * Tracepoint for leaving rcu_do_batch, performed after callback invocation:
+ * Tracepoint for exiting rcu_do_batch after RCU callbacks have been
+ * invoked.  The first argument is the number of callbacks actually invoked.
  */
 TRACE_EVENT(rcu_batch_end,
 
@@ -82,11 +115,11 @@ TRACE_EVENT(rcu_batch_end,
         TP_ARGS(callbacks_invoked),
 
         TP_STRUCT__entry(
-                __field(        int,    callbacks_invoked               )
+                __field(int, callbacks_invoked)
         ),
 
         TP_fast_assign(
-                __entry->callbacks_invoked      = callbacks_invoked;
+                __entry->callbacks_invoked = callbacks_invoked;
         ),
 
         TP_printk("CBs-invoked=%d", __entry->callbacks_invoked)