[SCSI] scsi: Added support for adapter and firmware reset
[linux-2.6.git] / kernel / tracepoint.c
index 42e86dd..b219f14 100644 (file)
 #include <linux/tracepoint.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/jump_label.h>
 
-extern struct tracepoint __start___tracepoints[];
-extern struct tracepoint __stop___tracepoints[];
+extern struct tracepoint * const __start___tracepoints_ptrs[];
+extern struct tracepoint * const __stop___tracepoints_ptrs[];
 
 /* Set to 1 to enable tracepoint debug output */
 static const int tracepoint_debug;
@@ -43,65 +45,67 @@ static DEFINE_MUTEX(tracepoints_mutex);
  */
 #define TRACEPOINT_HASH_BITS 6
 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
+static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
 
 /*
  * Note about RCU :
- * It is used to to delay the free of multiple probes array until a quiescent
+ * It is used to delay the free of multiple probes array until a quiescent
  * state is reached.
  * Tracepoint entries modifications are protected by the tracepoints_mutex.
  */
 struct tracepoint_entry {
        struct hlist_node hlist;
-       void **funcs;
+       struct tracepoint_func *funcs;
        int refcount;   /* Number of times armed. 0 if disarmed. */
-       struct rcu_head rcu;
-       void *oldptr;
-       unsigned char rcu_pending:1;
        char name[0];
 };
 
-static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
+struct tp_probes {
+       union {
+               struct rcu_head rcu;
+               struct list_head list;
+       } u;
+       struct tracepoint_func probes[0];
+};
 
-static void free_old_closure(struct rcu_head *head)
+static inline void *allocate_probes(int count)
 {
-       struct tracepoint_entry *entry = container_of(head,
-               struct tracepoint_entry, rcu);
-       kfree(entry->oldptr);
-       /* Make sure we free the data before setting the pending flag to 0 */
-       smp_wmb();
-       entry->rcu_pending = 0;
+       struct tp_probes *p  = kmalloc(count * sizeof(struct tracepoint_func)
+                       + sizeof(struct tp_probes), GFP_KERNEL);
+       return p == NULL ? NULL : p->probes;
 }
 
-static void tracepoint_entry_free_old(struct tracepoint_entry *entry, void *old)
+static void rcu_free_old_probes(struct rcu_head *head)
 {
-       if (!old)
-               return;
-       entry->oldptr = old;
-       entry->rcu_pending = 1;
-       /* write rcu_pending before calling the RCU callback */
-       smp_wmb();
-#ifdef CONFIG_PREEMPT_RCU
-       synchronize_sched();    /* Until we have the call_rcu_sched() */
-#endif
-       call_rcu(&entry->rcu, free_old_closure);
+       kfree(container_of(head, struct tp_probes, u.rcu));
+}
+
+static inline void release_probes(struct tracepoint_func *old)
+{
+       if (old) {
+               struct tp_probes *tp_probes = container_of(old,
+                       struct tp_probes, probes[0]);
+               call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
+       }
 }
 
 static void debug_print_probes(struct tracepoint_entry *entry)
 {
        int i;
 
-       if (!tracepoint_debug)
+       if (!tracepoint_debug || !entry->funcs)
                return;
 
-       for (i = 0; entry->funcs[i]; i++)
-               printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i]);
+       for (i = 0; entry->funcs[i].func; i++)
+               printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i].func);
 }
 
-static void *
-tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
+static struct tracepoint_func *
+tracepoint_entry_add_probe(struct tracepoint_entry *entry,
+                          void *probe, void *data)
 {
        int nr_probes = 0;
-       void **old, **new;
+       struct tracepoint_func *old, *new;
 
        WARN_ON(!probe);
 
@@ -109,17 +113,20 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
        old = entry->funcs;
        if (old) {
                /* (N -> N+1), (N != 0, 1) probes */
-               for (nr_probes = 0; old[nr_probes]; nr_probes++)
-                       if (old[nr_probes] == probe)
+               for (nr_probes = 0; old[nr_probes].func; nr_probes++)
+                       if (old[nr_probes].func == probe &&
+                           old[nr_probes].data == data)
                                return ERR_PTR(-EEXIST);
        }
        /* + 2 : one for new probe, one for NULL func */
-       new = kzalloc((nr_probes + 2) * sizeof(void *), GFP_KERNEL);
+       new = allocate_probes(nr_probes + 2);
        if (new == NULL)
                return ERR_PTR(-ENOMEM);
        if (old)
-               memcpy(new, old, nr_probes * sizeof(void *));
-       new[nr_probes] = probe;
+               memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
+       new[nr_probes].func = probe;
+       new[nr_probes].data = data;
+       new[nr_probes + 1].func = NULL;
        entry->refcount = nr_probes + 1;
        entry->funcs = new;
        debug_print_probes(entry);
@@ -127,17 +134,23 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
 }
 
 static void *
-tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
+tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
+                             void *probe, void *data)
 {
        int nr_probes = 0, nr_del = 0, i;
-       void **old, **new;
+       struct tracepoint_func *old, *new;
 
        old = entry->funcs;
 
+       if (!old)
+               return ERR_PTR(-ENOENT);
+
        debug_print_probes(entry);
        /* (N -> M), (N > 1, M >= 0) probes */
-       for (nr_probes = 0; old[nr_probes]; nr_probes++) {
-               if ((!probe || old[nr_probes] == probe))
+       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+               if (!probe ||
+                   (old[nr_probes].func == probe &&
+                    old[nr_probes].data == data))
                        nr_del++;
        }
 
@@ -151,13 +164,14 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
                int j = 0;
                /* N -> M, (N > 1, M > 0) */
                /* + 1 for NULL */
-               new = kzalloc((nr_probes - nr_del + 1)
-                       * sizeof(void *), GFP_KERNEL);
+               new = allocate_probes(nr_probes - nr_del + 1);
                if (new == NULL)
                        return ERR_PTR(-ENOMEM);
-               for (i = 0; old[i]; i++)
-                       if ((probe && old[i] != probe))
+               for (i = 0; old[i].func; i++)
+                       if (probe &&
+                           (old[i].func != probe || old[i].data != data))
                                new[j++] = old[i];
+               new[nr_probes - nr_del].func = NULL;
                entry->refcount = nr_probes - nr_del;
                entry->funcs = new;
        }
@@ -177,7 +191,7 @@ static struct tracepoint_entry *get_tracepoint(const char *name)
        struct tracepoint_entry *e;
        u32 hash = jhash(name, strlen(name), 0);
 
-       head = &tracepoint_table[hash & ((1 << TRACEPOINT_HASH_BITS)-1)];
+       head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
        hlist_for_each_entry(e, node, head, hlist) {
                if (!strcmp(name, e->name))
                        return e;
@@ -197,7 +211,7 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
        size_t name_len = strlen(name) + 1;
        u32 hash = jhash(name, name_len-1, 0);
 
-       head = &tracepoint_table[hash & ((1 << TRACEPOINT_HASH_BITS)-1)];
+       head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
        hlist_for_each_entry(e, node, head, hlist) {
                if (!strcmp(name, e->name)) {
                        printk(KERN_NOTICE
@@ -215,7 +229,6 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
        memcpy(&e->name[0], name, name_len);
        e->funcs = NULL;
        e->refcount = 0;
-       e->rcu_pending = 0;
        hlist_add_head(&e->hlist, head);
        return e;
 }
@@ -224,32 +237,10 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
  * Remove the tracepoint from the tracepoint hash table. Must be called with
  * mutex_lock held.
  */
-static int remove_tracepoint(const char *name)
+static inline void remove_tracepoint(struct tracepoint_entry *e)
 {
-       struct hlist_head *head;
-       struct hlist_node *node;
-       struct tracepoint_entry *e;
-       int found = 0;
-       size_t len = strlen(name) + 1;
-       u32 hash = jhash(name, len-1, 0);
-
-       head = &tracepoint_table[hash & ((1 << TRACEPOINT_HASH_BITS)-1)];
-       hlist_for_each_entry(e, node, head, hlist) {
-               if (!strcmp(name, e->name)) {
-                       found = 1;
-                       break;
-               }
-       }
-       if (!found)
-               return -ENOENT;
-       if (e->refcount)
-               return -EBUSY;
        hlist_del(&e->hlist);
-       /* Make sure the call_rcu has been executed */
-       if (e->rcu_pending)
-               rcu_barrier();
        kfree(e);
-       return 0;
 }
 
 /*
@@ -260,6 +251,11 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 {
        WARN_ON(strcmp((*entry)->name, elem->name) != 0);
 
+       if (elem->regfunc && !jump_label_enabled(&elem->key) && active)
+               elem->regfunc();
+       else if (elem->unregfunc && jump_label_enabled(&elem->key) && !active)
+               elem->unregfunc();
+
        /*
         * rcu_assign_pointer has a smp_wmb() which makes sure that the new
         * probe callbacks array is consistent before setting a pointer to it.
@@ -268,7 +264,10 @@ static void set_tracepoint(struct tracepoint_entry **entry,
         * is used.
         */
        rcu_assign_pointer(elem->funcs, (*entry)->funcs);
-       elem->state = active;
+       if (active && !jump_label_enabled(&elem->key))
+               jump_label_inc(&elem->key);
+       else if (!active && jump_label_enabled(&elem->key))
+               jump_label_dec(&elem->key);
 }
 
 /*
@@ -279,7 +278,12 @@ static void set_tracepoint(struct tracepoint_entry **entry,
  */
 static void disable_tracepoint(struct tracepoint *elem)
 {
-       elem->state = 0;
+       if (elem->unregfunc && jump_label_enabled(&elem->key))
+               elem->unregfunc();
+
+       if (jump_label_enabled(&elem->key))
+               jump_label_dec(&elem->key);
+       rcu_assign_pointer(elem->funcs, NULL);
 }
 
 /**
@@ -289,20 +293,23 @@ static void disable_tracepoint(struct tracepoint *elem)
  *
  * Updates the probe callback corresponding to a range of tracepoints.
  */
-void tracepoint_update_probe_range(struct tracepoint *begin,
-       struct tracepoint *end)
+void tracepoint_update_probe_range(struct tracepoint * const *begin,
+                                  struct tracepoint * const *end)
 {
-       struct tracepoint *iter;
+       struct tracepoint * const *iter;
        struct tracepoint_entry *mark_entry;
 
+       if (!begin)
+               return;
+
        mutex_lock(&tracepoints_mutex);
        for (iter = begin; iter < end; iter++) {
-               mark_entry = get_tracepoint(iter->name);
+               mark_entry = get_tracepoint((*iter)->name);
                if (mark_entry) {
-                       set_tracepoint(&mark_entry, iter,
+                       set_tracepoint(&mark_entry, *iter,
                                        !!mark_entry->refcount);
                } else {
-                       disable_tracepoint(iter);
+                       disable_tracepoint(*iter);
                }
        }
        mutex_unlock(&tracepoints_mutex);
@@ -314,12 +321,30 @@ void tracepoint_update_probe_range(struct tracepoint *begin,
 static void tracepoint_update_probes(void)
 {
        /* Core kernel tracepoints */
-       tracepoint_update_probe_range(__start___tracepoints,
-               __stop___tracepoints);
+       tracepoint_update_probe_range(__start___tracepoints_ptrs,
+               __stop___tracepoints_ptrs);
        /* tracepoints in modules. */
        module_update_tracepoints();
 }
 
+static struct tracepoint_func *
+tracepoint_add_probe(const char *name, void *probe, void *data)
+{
+       struct tracepoint_entry *entry;
+       struct tracepoint_func *old;
+
+       entry = get_tracepoint(name);
+       if (!entry) {
+               entry = add_tracepoint(name);
+               if (IS_ERR(entry))
+                       return (struct tracepoint_func *)entry;
+       }
+       old = tracepoint_entry_add_probe(entry, probe, data);
+       if (IS_ERR(old) && !entry->refcount)
+               remove_tracepoint(entry);
+       return old;
+}
+
 /**
  * tracepoint_probe_register -  Connect a probe to a tracepoint
  * @name: tracepoint name
@@ -328,44 +353,39 @@ static void tracepoint_update_probes(void)
  * Returns 0 if ok, error value on error.
  * The probe address must at least be aligned on the architecture pointer size.
  */
-int tracepoint_probe_register(const char *name, void *probe)
+int tracepoint_probe_register(const char *name, void *probe, void *data)
 {
-       struct tracepoint_entry *entry;
-       int ret = 0;
-       void *old;
+       struct tracepoint_func *old;
 
        mutex_lock(&tracepoints_mutex);
-       entry = get_tracepoint(name);
-       if (!entry) {
-               entry = add_tracepoint(name);
-               if (IS_ERR(entry)) {
-                       ret = PTR_ERR(entry);
-                       goto end;
-               }
-       }
-       /*
-        * If we detect that a call_rcu is pending for this tracepoint,
-        * make sure it's executed now.
-        */
-       if (entry->rcu_pending)
-               rcu_barrier();
-       old = tracepoint_entry_add_probe(entry, probe);
-       if (IS_ERR(old)) {
-               ret = PTR_ERR(old);
-               goto end;
-       }
+       old = tracepoint_add_probe(name, probe, data);
        mutex_unlock(&tracepoints_mutex);
+       if (IS_ERR(old))
+               return PTR_ERR(old);
+
        tracepoint_update_probes();             /* may update entry */
-       mutex_lock(&tracepoints_mutex);
-       entry = get_tracepoint(name);
-       WARN_ON(!entry);
-       tracepoint_entry_free_old(entry, old);
-end:
-       mutex_unlock(&tracepoints_mutex);
-       return ret;
+       release_probes(old);
+       return 0;
 }
 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 
+static struct tracepoint_func *
+tracepoint_remove_probe(const char *name, void *probe, void *data)
+{
+       struct tracepoint_entry *entry;
+       struct tracepoint_func *old;
+
+       entry = get_tracepoint(name);
+       if (!entry)
+               return ERR_PTR(-ENOENT);
+       old = tracepoint_entry_remove_probe(entry, probe, data);
+       if (IS_ERR(old))
+               return old;
+       if (!entry->refcount)
+               remove_tracepoint(entry);
+       return old;
+}
+
 /**
  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
  * @name: tracepoint name
@@ -376,33 +396,108 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_register);
  * itself uses stop_machine(), which insures that every preempt disabled section
  * have finished.
  */
-int tracepoint_probe_unregister(const char *name, void *probe)
+int tracepoint_probe_unregister(const char *name, void *probe, void *data)
 {
-       struct tracepoint_entry *entry;
-       void *old;
-       int ret = -ENOENT;
+       struct tracepoint_func *old;
 
        mutex_lock(&tracepoints_mutex);
-       entry = get_tracepoint(name);
-       if (!entry)
-               goto end;
-       if (entry->rcu_pending)
-               rcu_barrier();
-       old = tracepoint_entry_remove_probe(entry, probe);
+       old = tracepoint_remove_probe(name, probe, data);
        mutex_unlock(&tracepoints_mutex);
+       if (IS_ERR(old))
+               return PTR_ERR(old);
+
        tracepoint_update_probes();             /* may update entry */
+       release_probes(old);
+       return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+
+static LIST_HEAD(old_probes);
+static int need_update;
+
+static void tracepoint_add_old_probes(void *old)
+{
+       need_update = 1;
+       if (old) {
+               struct tp_probes *tp_probes = container_of(old,
+                       struct tp_probes, probes[0]);
+               list_add(&tp_probes->u.list, &old_probes);
+       }
+}
+
+/**
+ * tracepoint_probe_register_noupdate -  register a probe but not connect
+ * @name: tracepoint name
+ * @probe: probe handler
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_register_noupdate(const char *name, void *probe,
+                                      void *data)
+{
+       struct tracepoint_func *old;
+
        mutex_lock(&tracepoints_mutex);
-       entry = get_tracepoint(name);
-       if (!entry)
-               goto end;
-       tracepoint_entry_free_old(entry, old);
-       remove_tracepoint(name);        /* Ignore busy error message */
-       ret = 0;
-end:
+       old = tracepoint_add_probe(name, probe, data);
+       if (IS_ERR(old)) {
+               mutex_unlock(&tracepoints_mutex);
+               return PTR_ERR(old);
+       }
+       tracepoint_add_old_probes(old);
        mutex_unlock(&tracepoints_mutex);
-       return ret;
+       return 0;
 }
-EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
+
+/**
+ * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
+ * @name: tracepoint name
+ * @probe: probe function pointer
+ *
+ * caller must call tracepoint_probe_update_all()
+ */
+int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
+                                        void *data)
+{
+       struct tracepoint_func *old;
+
+       mutex_lock(&tracepoints_mutex);
+       old = tracepoint_remove_probe(name, probe, data);
+       if (IS_ERR(old)) {
+               mutex_unlock(&tracepoints_mutex);
+               return PTR_ERR(old);
+       }
+       tracepoint_add_old_probes(old);
+       mutex_unlock(&tracepoints_mutex);
+       return 0;
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
+
+/**
+ * tracepoint_probe_update_all -  update tracepoints
+ */
+void tracepoint_probe_update_all(void)
+{
+       LIST_HEAD(release_probes);
+       struct tp_probes *pos, *next;
+
+       mutex_lock(&tracepoints_mutex);
+       if (!need_update) {
+               mutex_unlock(&tracepoints_mutex);
+               return;
+       }
+       if (!list_empty(&old_probes))
+               list_replace_init(&old_probes, &release_probes);
+       need_update = 0;
+       mutex_unlock(&tracepoints_mutex);
+
+       tracepoint_update_probes();
+       list_for_each_entry_safe(pos, next, &release_probes, u.list) {
+               list_del(&pos->u.list);
+               call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
+       }
+}
+EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 
 /**
  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
@@ -414,8 +509,8 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
  * Will return the first tracepoint in the range if the input tracepoint is
  * NULL.
  */
-int tracepoint_get_iter_range(struct tracepoint **tracepoint,
-       struct tracepoint *begin, struct tracepoint *end)
+int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
+       struct tracepoint * const *begin, struct tracepoint * const *end)
 {
        if (!*tracepoint && begin != end) {
                *tracepoint = begin;
@@ -434,7 +529,8 @@ static void tracepoint_get_iter(struct tracepoint_iter *iter)
        /* Core kernel tracepoints */
        if (!iter->module) {
                found = tracepoint_get_iter_range(&iter->tracepoint,
-                               __start___tracepoints, __stop___tracepoints);
+                               __start___tracepoints_ptrs,
+                               __stop___tracepoints_ptrs);
                if (found)
                        goto end;
        }
@@ -474,3 +570,71 @@ void tracepoint_iter_reset(struct tracepoint_iter *iter)
        iter->tracepoint = NULL;
 }
 EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
+
+#ifdef CONFIG_MODULES
+
+int tracepoint_module_notify(struct notifier_block *self,
+                            unsigned long val, void *data)
+{
+       struct module *mod = data;
+
+       switch (val) {
+       case MODULE_STATE_COMING:
+       case MODULE_STATE_GOING:
+               tracepoint_update_probe_range(mod->tracepoints_ptrs,
+                       mod->tracepoints_ptrs + mod->num_tracepoints);
+               break;
+       }
+       return 0;
+}
+
+struct notifier_block tracepoint_module_nb = {
+       .notifier_call = tracepoint_module_notify,
+       .priority = 0,
+};
+
+static int init_tracepoints(void)
+{
+       return register_module_notifier(&tracepoint_module_nb);
+}
+__initcall(init_tracepoints);
+
+#endif /* CONFIG_MODULES */
+
+#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
+
+/* NB: reg/unreg are called while guarded with the tracepoints_mutex */
+static int sys_tracepoint_refcount;
+
+void syscall_regfunc(void)
+{
+       unsigned long flags;
+       struct task_struct *g, *t;
+
+       if (!sys_tracepoint_refcount) {
+               read_lock_irqsave(&tasklist_lock, flags);
+               do_each_thread(g, t) {
+                       /* Skip kernel threads. */
+                       if (t->mm)
+                               set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
+               } while_each_thread(g, t);
+               read_unlock_irqrestore(&tasklist_lock, flags);
+       }
+       sys_tracepoint_refcount++;
+}
+
+void syscall_unregfunc(void)
+{
+       unsigned long flags;
+       struct task_struct *g, *t;
+
+       sys_tracepoint_refcount--;
+       if (!sys_tracepoint_refcount) {
+               read_lock_irqsave(&tasklist_lock, flags);
+               do_each_thread(g, t) {
+                       clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
+               } while_each_thread(g, t);
+               read_unlock_irqrestore(&tasklist_lock, flags);
+       }
+}
+#endif