Linux Kernel Markers: support multiple probes

RCU style multiple probes support for the Linux Kernel Markers.  Common case
(one probe) is still fast and does not require dynamic allocation or a
supplementary pointer dereference on the fast path.

- Move preempt disable from the marker site to the callback.

Since we now have an internal callback, move the preempt disable/enable to the
callback instead of the marker site.

Since the callback change is done asynchronously (passing from a handler that
supports arguments to a handler that does not setup the arguments is no
arguments are passed), we can safely update it even if it is outside the
preempt disable section.

- Move probe arm to probe connection. Now, a connected probe is automatically
  armed.

Remove MARK_MAX_FORMAT_LEN, unused.

This patch modifies the Linux Kernel Markers API : it removes the probe
"arm/disarm" and changes the probe function prototype : it now expects a
va_list * instead of a "...".

If we want to have more than one probe connected to a marker at a given
time (LTTng, or blktrace, ssytemtap) then we need this patch. Without it,
connecting a second probe handler to a marker will fail.

It allow us, for instance, to do interesting combinations :

Do standard tracing with LTTng and, eventually, to compute statistics
with SystemTAP, or to have a special trigger on an event that would call
a systemtap script which would stop flight recorder tracing.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Mike Mason <mmlnx@us.ibm.com>
Cc: Dipankar Sarma <dipankar@in.ibm.com>
Cc: David Smith <dsmith@redhat.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Cc: "Frank Ch. Eigler" <fche@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 9 insertions, 16 deletions

diff --git a/samples/markers/probe-example.c b/samples/markers/probe-example.c
index a36797535615..c8e099d4d1fd 100644
--- a/samples/markers/probe-example.c
+++ b/samples/markers/probe-example.c
@@ -20,31 +20,27 @@ struct probe_data {
         marker_probe_func *probe_func;
 };
 
-void probe_subsystem_event(const struct marker *mdata, void *private,
-        const char *format, ...)
+void probe_subsystem_event(void *probe_data, void *call_data,
+        const char *format, va_list *args)
 {
-        va_list ap;
         /* Declare args */
         unsigned int value;
         const char *mystr;
 
         /* Assign args */
-        va_start(ap, format);
-        value = va_arg(ap, typeof(value));
-        mystr = va_arg(ap, typeof(mystr));
+        value = va_arg(*args, typeof(value));
+        mystr = va_arg(*args, typeof(mystr));
 
         /* Call printk */
-        printk(KERN_DEBUG "Value %u, string %s\n", value, mystr);
+        printk(KERN_INFO "Value %u, string %s\n", value, mystr);
 
         /* or count, check rights, serialize data in a buffer */
-
-        va_end(ap);
 }
 
 atomic_t eventb_count = ATOMIC_INIT(0);
 
-void probe_subsystem_eventb(const struct marker *mdata, void *private,
-        const char *format, ...)
+void probe_subsystem_eventb(void *probe_data, void *call_data,
+        const char *format, va_list *args)
 {
         /* Increment counter */
         atomic_inc(&eventb_count);
@@ -72,10 +68,6 @@ static int __init probe_init(void)
                 if (result)
                         printk(KERN_INFO "Unable to register probe %s\n",
                                 probe_array[i].name);
-                result = marker_arm(probe_array[i].name);
-                if (result)
-                        printk(KERN_INFO "Unable to arm probe %s\n",
-                                probe_array[i].name);
         }
         return 0;
 }
@@ -85,7 +77,8 @@ static void __exit probe_fini(void)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(probe_array); i++)
-                marker_probe_unregister(probe_array[i].name);
+                marker_probe_unregister(probe_array[i].name,
+                        probe_array[i].probe_func, &probe_array[i]);
         printk(KERN_INFO "Number of event b : %u\n",
                         atomic_read(&eventb_count));
 }