Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6

[linux-2.6-omap-h63xx.git] / kernel / marker.c

diff --git a/kernel/marker.c b/kernel/marker.c
index 9f76c4a622ec13bb50250b9b73272a8d668d03ce..e9c6b2bc9400627cf183382ee55933333f0ee83b 100644 (file)
--- a/kernel/marker.c
+++ b/kernel/marker.c
@@ -60,6 +60,9 @@ struct marker_entry {
        struct marker_probe_closure single;
        struct marker_probe_closure *multi;
        int refcount;   /* Number of times armed. 0 if disarmed. */
+       struct rcu_head rcu;
+       void *oldptr;
+       int rcu_pending;
        unsigned char ptype:1;
        char name[0];   /* Contains name'\0'format'\0' */
 };
@@ -100,11 +103,11 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
        char ptype;
 
        /*
-        * 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.
+        * rcu_read_lock_sched 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();
+       rcu_read_lock_sched();
        ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
@@ -142,7 +145,7 @@ void marker_probe_cb(const struct marker *mdata, void *call_private, ...)
                        va_end(args);
                }
        }
-       preempt_enable();
+       rcu_read_unlock_sched();
 }
 EXPORT_SYMBOL_GPL(marker_probe_cb);
 
@@ -159,7 +162,7 @@ void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
        va_list args;   /* not initialized */
        char ptype;
 
-       preempt_disable();
+       rcu_read_lock_sched();
        ptype = mdata->ptype;
        if (likely(!ptype)) {
                marker_probe_func *func;
@@ -192,10 +195,20 @@ void marker_probe_cb_noarg(const struct marker *mdata, void *call_private, ...)
                        multi[i].func(multi[i].probe_private, call_private,
                                mdata->format, &args);
        }
-       preempt_enable();
+       rcu_read_unlock_sched();
 }
 EXPORT_SYMBOL_GPL(marker_probe_cb_noarg);
 
+static void free_old_closure(struct rcu_head *head)
+{
+       struct marker_entry *entry = container_of(head,
+               struct marker_entry, rcu);
+       kfree(entry->oldptr);
+       /* Make sure we free the data before setting the pending flag to 0 */
+       smp_wmb();
+       entry->rcu_pending = 0;
+}
+
 static void debug_print_probes(struct marker_entry *entry)
 {
        int i;
@@ -404,6 +417,7 @@ static struct marker_entry *add_marker(const char *name, const char *format)
        e->multi = NULL;
        e->ptype = 0;
        e->refcount = 0;
+       e->rcu_pending = 0;
        hlist_add_head(&e->hlist, head);
        return e;
 }
@@ -433,6 +447,9 @@ static int remove_marker(const char *name)
        if (e->single.func != __mark_empty_function)
                return -EBUSY;
        hlist_del(&e->hlist);
+       /* Make sure the call_rcu has been executed */
+       if (e->rcu_pending)
+               rcu_barrier_sched();
        kfree(e);
        return 0;
 }
@@ -462,8 +479,12 @@ static int marker_set_format(struct marker_entry **entry, const char *format)
        e->multi = (*entry)->multi;
        e->ptype = (*entry)->ptype;
        e->refcount = (*entry)->refcount;
+       e->rcu_pending = 0;
        hlist_add_before(&e->hlist, &(*entry)->hlist);
        hlist_del(&(*entry)->hlist);
+       /* Make sure the call_rcu has been executed */
+       if ((*entry)->rcu_pending)
+               rcu_barrier_sched();
        kfree(*entry);
        *entry = e;
        trace_mark(core_marker_format, "name %s format %s",
@@ -539,7 +560,7 @@ static int set_marker(struct marker_entry **entry, struct marker *elem,
  * Disable a marker and its probe callback.
  * 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.
+ * by rcu_read_lock_sched around the call site.
  */
 static void disable_marker(struct marker *elem)
 {
@@ -632,11 +653,23 @@ int marker_probe_register(const char *name, const char *format,
        entry = get_marker(name);
        if (!entry) {
                entry = add_marker(name, format);
-               if (IS_ERR(entry)) {
+               if (IS_ERR(entry))
                        ret = PTR_ERR(entry);
-                       goto end;
-               }
+       } else if (format) {
+               if (!entry->format)
+                       ret = marker_set_format(&entry, format);
+               else if (strcmp(entry->format, format))
+                       ret = -EPERM;
        }
+       if (ret)
+               goto end;
+
+       /*
+        * If we detect that a call_rcu is pending for this marker,
+        * make sure it's executed now.
+        */
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
        old = marker_entry_add_probe(entry, probe, probe_private);
        if (IS_ERR(old)) {
                ret = PTR_ERR(old);
@@ -644,11 +677,16 @@ int marker_probe_register(const char *name, const char *format,
        }
        mutex_unlock(&markers_mutex);
        marker_update_probes();         /* may update entry */
-       synchronize_sched();
-       kfree(old);
        mutex_lock(&markers_mutex);
        entry = get_marker(name);
        WARN_ON(!entry);
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
+       entry->oldptr = old;
+       entry->rcu_pending = 1;
+       /* write rcu_pending before calling the RCU callback */
+       smp_wmb();
+       call_rcu_sched(&entry->rcu, free_old_closure);
 end:
        mutex_unlock(&markers_mutex);
        return ret;
@@ -678,15 +716,22 @@ int marker_probe_unregister(const char *name,
        entry = get_marker(name);
        if (!entry)
                goto end;
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, probe, probe_private);
        mutex_unlock(&markers_mutex);
        marker_update_probes();         /* may update entry */
-       synchronize_sched();
-       kfree(old);
        mutex_lock(&markers_mutex);
        entry = get_marker(name);
        if (!entry)
                goto end;
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
+       entry->oldptr = old;
+       entry->rcu_pending = 1;
+       /* write rcu_pending before calling the RCU callback */
+       smp_wmb();
+       call_rcu_sched(&entry->rcu, free_old_closure);
        remove_marker(name);    /* Ignore busy error message */
        ret = 0;
 end:
@@ -752,14 +797,21 @@ int marker_probe_unregister_private_data(marker_probe_func *probe,
                ret = -ENOENT;
                goto end;
        }
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
        old = marker_entry_remove_probe(entry, NULL, probe_private);
        mutex_unlock(&markers_mutex);
        marker_update_probes();         /* may update entry */
-       synchronize_sched();
-       kfree(old);
        mutex_lock(&markers_mutex);
        entry = get_marker_from_private_data(probe, probe_private);
        WARN_ON(!entry);
+       if (entry->rcu_pending)
+               rcu_barrier_sched();
+       entry->oldptr = old;
+       entry->rcu_pending = 1;
+       /* write rcu_pending before calling the RCU callback */
+       smp_wmb();
+       call_rcu_sched(&entry->rcu, free_old_closure);
        remove_marker(entry->name);     /* Ignore busy error message */
 end:
        mutex_unlock(&markers_mutex);