9p: eliminate callback complexity
[linux-2.6.git] / kernel / marker.c
index 48a4ea5..7d1faec 100644 (file)
 #include <linux/rcupdate.h>
 #include <linux/marker.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 extern struct marker __start___markers[];
 extern struct marker __stop___markers[];
 
 /* Set to 1 to enable marker debug output */
-const int marker_debug;
+static const int marker_debug;
 
 /*
  * markers_mutex nests inside module_mutex. Markers mutex protects the builtin
@@ -54,8 +55,8 @@ static DEFINE_MUTEX(markers_mutex);
 struct marker_entry {
        struct hlist_node hlist;
        char *format;
-       void (*call)(const struct marker *mdata,        /* Probe wrapper */
-               void *call_private, const char *fmt, ...);
+                       /* Probe wrapper */
+       void (*call)(const struct marker *mdata, void *call_private, ...);
        struct marker_probe_closure single;
        struct marker_probe_closure *multi;
        int refcount;   /* Number of times armed. 0 if disarmed. */
@@ -90,42 +91,46 @@ EXPORT_SYMBOL_GPL(__mark_empty_function);
  * marker_probe_cb Callback that prepares the variable argument list for probes.
  * @mdata: pointer of type struct marker
  * @call_private: caller site private data
- * @fmt: format string
  * @...:  Variable argument list.
  *
  * Since we do not use "typical" pointer based RCU in the 1 argument case, we
  * need to put a full smp_rmb() in this branch. This is why we do not use
  * rcu_dereference() for the pointer read.
  */
-void marker_probe_cb(const struct marker *mdata, void *call_private,
-       const char *fmt, ...)
+void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
 {
        va_list args;
        char ptype;
 
        /*
-        * disabling preemption to make sure the teardown of the callbacks can
-        * be done correctly when they are in modules and they insure RCU read
-        * coherency.
+        * preempt_disable does two things : disabling preemption to make sure
+        * the teardown of the callbacks can be done correctly when they are in
+        * modules and they insure RCU read coherency.
         */
        preempt_disable();
-       ptype = ACCESS_ONCE(mdata->ptype);
+       ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
                /* Must read the ptype before ptr. They are not data dependant,
                 * so we put an explicit smp_rmb() here. */
                smp_rmb();
-               func = ACCESS_ONCE(mdata->single.func);
+               func = mdata->single.func;
                /* Must read the ptr before private data. They are not data
                 * dependant, so we put an explicit smp_rmb() here. */
                smp_rmb();
-               va_start(args, fmt);
-               func(mdata->single.probe_private, call_private, fmt, &args);
+               va_start(args, call_private);
+               func(mdata->single.probe_private, call_private, mdata->format,
+                       &args);
                va_end(args);
        } else {
                struct marker_probe_closure *multi;
                int i;
                /*
+                * Read mdata->ptype before mdata->multi.
+                */
+               smp_rmb();
+               multi = mdata->multi;
+               /*
                 * multi points to an array, therefore accessing the array
                 * depends on reading multi. However, even in this case,
                 * we must insure that the pointer is read _before_ the array
@@ -133,11 +138,10 @@ void marker_probe_cb(const struct marker *mdata, void *call_private,
                 * in the fast path, so put the explicit barrier here.
                 */
                smp_read_barrier_depends();
-               multi = ACCESS_ONCE(mdata->multi);
                for (i = 0; multi[i].func; i++) {
-                       va_start(args, fmt);
-                       multi[i].func(multi[i].probe_private, call_private, fmt,
-                               &args);
+                       va_start(args, call_private);
+                       multi[i].func(multi[i].probe_private, call_private,
+                               mdata->format, &args);
                        va_end(args);
                }
        }
@@ -149,33 +153,37 @@ EXPORT_SYMBOL_GPL(marker_probe_cb);
  * marker_probe_cb Callback that does not prepare the variable argument list.
  * @mdata: pointer of type struct marker
  * @call_private: caller site private data
- * @fmt: format string
  * @...:  Variable argument list.
  *
  * Should be connected to markers "MARK_NOARGS".
  */
-void marker_probe_cb_noarg(const struct marker *mdata,
-       void *call_private, const char *fmt, ...)
+void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
 {
        va_list args;   /* not initialized */
        char ptype;
 
        preempt_disable();
-       ptype = ACCESS_ONCE(mdata->ptype);
+       ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
                /* Must read the ptype before ptr. They are not data dependant,
                 * so we put an explicit smp_rmb() here. */
                smp_rmb();
-               func = ACCESS_ONCE(mdata->single.func);
+               func = mdata->single.func;
                /* Must read the ptr before private data. They are not data
                 * dependant, so we put an explicit smp_rmb() here. */
                smp_rmb();
-               func(mdata->single.probe_private, call_private, fmt, &args);
+               func(mdata->single.probe_private, call_private, mdata->format,
+                       &args);
        } else {
                struct marker_probe_closure *multi;
                int i;
                /*
+                * Read mdata->ptype before mdata->multi.
+                */
+               smp_rmb();
+               multi = mdata->multi;
+               /*
                 * multi points to an array, therefore accessing the array
                 * depends on reading multi. However, even in this case,
                 * we must insure that the pointer is read _before_ the array
@@ -183,10 +191,9 @@ void marker_probe_cb_noarg(const struct marker *mdata,
                 * in the fast path, so put the explicit barrier here.
                 */
                smp_read_barrier_depends();
-               multi = ACCESS_ONCE(mdata->multi);
                for (i = 0; multi[i].func; i++)
-                       multi[i].func(multi[i].probe_private, call_private, fmt,
-                               &args);
+                       multi[i].func(multi[i].probe_private, call_private,
+                               mdata->format, &args);
        }
        preempt_enable();
 }
@@ -442,7 +449,7 @@ static int remove_marker(const char *name)
        hlist_del(&e->hlist);
        /* Make sure the call_rcu has been executed */
        if (e->rcu_pending)
-               rcu_barrier();
+               rcu_barrier_sched();
        kfree(e);
        return 0;
 }
@@ -477,7 +484,7 @@ static int marker_set_format(struct marker_entry **entry, const char *format)
        hlist_del(&(*entry)->hlist);
        /* Make sure the call_rcu has been executed */
        if ((*entry)->rcu_pending)
-               rcu_barrier();
+               rcu_barrier_sched();
        kfree(*entry);
        *entry = e;
        trace_mark(core_marker_format, "name %s format %s",
@@ -551,9 +558,9 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
 
 /*
  * Disable a marker and its probe callback.
- * Note: only after a synchronize_sched() issued after setting elem->call to the
- * empty function insures that the original callback is not used anymore. This
- * insured by preemption disabling around the call site.
+ * Note: only waiting an RCU period after setting elem->call to the empty
+ * function insures that the original callback is not used anymore. This insured
+ * by preempt_disable around the call site.
  */
 static void disable_marker(struct marker *elem)
 {
@@ -565,8 +572,8 @@ static void disable_marker(struct marker *elem)
        elem->ptype = 0;        /* single probe */
        /*
         * Leave the private data and id there, because removal is racy and
-        * should be done only after a synchronize_sched(). These are never used
-        * until the next initialization anyway.
+        * should be done only after an RCU period. These are never used until
+        * the next initialization anyway.
         */
 }
 
@@ -601,9 +608,6 @@ void marker_update_probe_range(struct marker *begin,
 
 /*
  * Update probes, removing the faulty probes.
- * Issues a synchronize_sched() when no reference to the module passed
- * as parameter is found in the probes so the probe module can be
- * safely unloaded from now on.
  *
  * Internal callback only changed before the first probe is connected to it.
  * Single probe private data can only be changed on 0 -> 1 and 2 -> 1
@@ -659,7 +663,7 @@ int marker_probe_register(const char *name, const char *format,
         * make sure it's executed now.
         */
        if (entry->rcu_pending)
-               rcu_barrier();
+               rcu_barrier_sched();
        old = marker_entry_add_probe(entry, probe, probe_private);
        if (IS_ERR(old)) {
                ret = PTR_ERR(old);
@@ -674,7 +678,7 @@ int marker_probe_register(const char *name, const char *format,
        entry->rcu_pending = 1;
        /* write rcu_pending before calling the RCU callback */
        smp_wmb();
-       call_rcu(&entry->rcu, free_old_closure);
+       call_rcu_sched(&entry->rcu, free_old_closure);
 end:
        mutex_unlock(&markers_mutex);
        return ret;
@@ -705,7 +709,7 @@ int marker_probe_unregister(const char *name,
        if (!entry)
                goto end;
        if (entry->rcu_pending)
-               rcu_barrier();
+               rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, probe, probe_private);
        mutex_unlock(&markers_mutex);
        marker_update_probes();         /* may update entry */
@@ -717,7 +721,7 @@ int marker_probe_unregister(const char *name,
        entry->rcu_pending = 1;
        /* write rcu_pending before calling the RCU callback */
        smp_wmb();
-       call_rcu(&entry->rcu, free_old_closure);
+       call_rcu_sched(&entry->rcu, free_old_closure);
        remove_marker(name);    /* Ignore busy error message */
        ret = 0;
 end:
@@ -784,7 +788,7 @@ int marker_probe_unregister_private_data(marker_probe_func *probe,
                goto end;
        }
        if (entry->rcu_pending)
-               rcu_barrier();
+               rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, NULL, probe_private);
        mutex_unlock(&markers_mutex);
        marker_update_probes();         /* may update entry */
@@ -795,7 +799,7 @@ int marker_probe_unregister_private_data(marker_probe_func *probe,
        entry->rcu_pending = 1;
        /* write rcu_pending before calling the RCU callback */
        smp_wmb();
-       call_rcu(&entry->rcu, free_old_closure);
+       call_rcu_sched(&entry->rcu, free_old_closure);
        remove_marker(entry->name);     /* Ignore busy error message */
 end:
        mutex_unlock(&markers_mutex);