tracepoint.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (C) 2008 Mathieu Desnoyers
    3  *
    4  * This program is free software; you can redistribute it and/or modify
    5  * it under the terms of the GNU General Public License as published by
    6  * the Free Software Foundation; either version 2 of the License, or
    7  * (at your option) any later version.
    8  *
    9  * This program is distributed in the hope that it will be useful,
   10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12  * GNU General Public License for more details.
   13  *
   14  * You should have received a copy of the GNU General Public License
   15  * along with this program; if not, write to the Free Software
   16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   17  */
   18 #include <linux/module.h>
   19 #include <linux/mutex.h>
   20 #include <linux/types.h>
   21 #include <linux/jhash.h>
   22 #include <linux/list.h>
   23 #include <linux/rcupdate.h>
   24 #include <linux/tracepoint.h>
   25 #include <linux/err.h>
   26 #include <linux/slab.h>
   27 #include <linux/sched.h>
   28 #include <linux/static_key.h>
   29 
   30 extern struct tracepoint * const __start___tracepoints_ptrs[];
   31 extern struct tracepoint * const __stop___tracepoints_ptrs[];
   32 
   33 /* Set to 1 to enable tracepoint debug output */
   34 static const int tracepoint_debug;
   35 
   36 /*
   37  * Tracepoints mutex protects the builtin and module tracepoints and the hash
   38  * table, as well as the local module list.
   39  */
   40 static DEFINE_MUTEX(tracepoints_mutex);
   41 
   42 #ifdef CONFIG_MODULES
   43 /* Local list of struct module */
   44 static LIST_HEAD(tracepoint_module_list);
   45 #endif /* CONFIG_MODULES */
   46 
   47 /*
   48  * Tracepoint hash table, containing the active tracepoints.
   49  * Protected by tracepoints_mutex.
   50  */
   51 #define TRACEPOINT_HASH_BITS 6
   52 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
   53 static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
   54 
   55 /*
   56  * Note about RCU :
   57  * It is used to delay the free of multiple probes array until a quiescent
   58  * state is reached.
   59  * Tracepoint entries modifications are protected by the tracepoints_mutex.
   60  */
   61 struct tracepoint_entry {
   62         struct hlist_node hlist;
   63         struct tracepoint_func *funcs;
   64         int refcount;   /* Number of times armed. 0 if disarmed. */
   65         char name[0];
   66 };
   67 
   68 struct tp_probes {
   69         union {
   70                 struct rcu_head rcu;
   71                 struct list_head list;
   72         } u;
   73         struct tracepoint_func probes[0];
   74 };
   75 
   76 static inline void *allocate_probes(int count)
   77 {
   78         struct tp_probes *p  = kmalloc(count * sizeof(struct tracepoint_func)
   79                         + sizeof(struct tp_probes), GFP_KERNEL);
   80         return p == NULL ? NULL : p->probes;
   81 }
   82 
   83 static void rcu_free_old_probes(struct rcu_head *head)
   84 {
   85         kfree(container_of(head, struct tp_probes, u.rcu));
   86 }
   87 
   88 static inline void release_probes(struct tracepoint_func *old)
   89 {
   90         if (old) {
   91                 struct tp_probes *tp_probes = container_of(old,
   92                         struct tp_probes, probes[0]);
   93                 call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
   94         }
   95 }
   96 
   97 static void debug_print_probes(struct tracepoint_entry *entry)
   98 {
   99         int i;
  100 
  101         if (!tracepoint_debug || !entry->funcs)
  102                 return;
  103 
  104         for (i = 0; entry->funcs[i].func; i++)
  105                 printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i].func);
  106 }
  107 
  108 static struct tracepoint_func *
  109 tracepoint_entry_add_probe(struct tracepoint_entry *entry,
  110                            void *probe, void *data)
  111 {
  112         int nr_probes = 0;
  113         struct tracepoint_func *old, *new;
  114 
  115         WARN_ON(!probe);
  116 
  117         debug_print_probes(entry);
  118         old = entry->funcs;
  119         if (old) {
  120                 /* (N -> N+1), (N != 0, 1) probes */
  121                 for (nr_probes = 0; old[nr_probes].func; nr_probes++)
  122                         if (old[nr_probes].func == probe &&
  123                             old[nr_probes].data == data)
  124                                 return ERR_PTR(-EEXIST);
  125         }
  126         /* + 2 : one for new probe, one for NULL func */
  127         new = allocate_probes(nr_probes + 2);
  128         if (new == NULL)
  129                 return ERR_PTR(-ENOMEM);
  130         if (old)
  131                 memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
  132         new[nr_probes].func = probe;
  133         new[nr_probes].data = data;
  134         new[nr_probes + 1].func = NULL;
  135         entry->refcount = nr_probes + 1;
  136         entry->funcs = new;
  137         debug_print_probes(entry);
  138         return old;
  139 }
  140 
  141 static void *
  142 tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
  143                               void *probe, void *data)
  144 {
  145         int nr_probes = 0, nr_del = 0, i;
  146         struct tracepoint_func *old, *new;
  147 
  148         old = entry->funcs;
  149 
  150         if (!old)
  151                 return ERR_PTR(-ENOENT);
  152 
  153         debug_print_probes(entry);
  154         /* (N -> M), (N > 1, M >= 0) probes */
  155         for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
  156                 if (!probe ||
  157                     (old[nr_probes].func == probe &&
  158                      old[nr_probes].data == data))
  159                         nr_del++;
  160         }
  161 
  162         if (nr_probes - nr_del == 0) {
  163                 /* N -> 0, (N > 1) */
  164                 entry->funcs = NULL;
  165                 entry->refcount = 0;
  166                 debug_print_probes(entry);
  167                 return old;
  168         } else {
  169                 int j = 0;
  170                 /* N -> M, (N > 1, M > 0) */
  171                 /* + 1 for NULL */
  172                 new = allocate_probes(nr_probes - nr_del + 1);
  173                 if (new == NULL)
  174                         return ERR_PTR(-ENOMEM);
  175                 for (i = 0; old[i].func; i++)
  176                         if (probe &&
  177                             (old[i].func != probe || old[i].data != data))
  178                                 new[j++] = old[i];
  179                 new[nr_probes - nr_del].func = NULL;
  180                 entry->refcount = nr_probes - nr_del;
  181                 entry->funcs = new;
  182         }
  183         debug_print_probes(entry);
  184         return old;
  185 }
  186 
  187 /*
  188  * Get tracepoint if the tracepoint is present in the tracepoint hash table.
  189  * Must be called with tracepoints_mutex held.
  190  * Returns NULL if not present.
  191  */
  192 static struct tracepoint_entry *get_tracepoint(const char *name)
  193 {
  194         struct hlist_head *head;
  195         struct hlist_node *node;
  196         struct tracepoint_entry *e;
  197         u32 hash = jhash(name, strlen(name), 0);
  198 
  199         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
  200         hlist_for_each_entry(e, node, head, hlist) {
  201                 if (!strcmp(name, e->name))
  202                         return e;
  203         }
  204         return NULL;
  205 }
  206 
  207 /*
  208  * Add the tracepoint to the tracepoint hash table. Must be called with
  209  * tracepoints_mutex held.
  210  */
  211 static struct tracepoint_entry *add_tracepoint(const char *name)
  212 {
  213         struct hlist_head *head;
  214         struct hlist_node *node;
  215         struct tracepoint_entry *e;
  216         size_t name_len = strlen(name) + 1;
  217         u32 hash = jhash(name, name_len-1, 0);
  218 
  219         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
  220         hlist_for_each_entry(e, node, head, hlist) {
  221                 if (!strcmp(name, e->name)) {
  222                         printk(KERN_NOTICE
  223                                 "tracepoint %s busy\n", name);
  224                         return ERR_PTR(-EEXIST);        /* Already there */
  225                 }
  226         }
  227         /*
  228          * Using kmalloc here to allocate a variable length element. Could
  229          * cause some memory fragmentation if overused.
  230          */
  231         e = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
  232         if (!e)
  233                 return ERR_PTR(-ENOMEM);
  234         memcpy(&e->name[0], name, name_len);
  235         e->funcs = NULL;
  236         e->refcount = 0;
  237         hlist_add_head(&e->hlist, head);
  238         return e;
  239 }
  240 
  241 /*
  242  * Remove the tracepoint from the tracepoint hash table. Must be called with
  243  * mutex_lock held.
  244  */
  245 static inline void remove_tracepoint(struct tracepoint_entry *e)
  246 {
  247         hlist_del(&e->hlist);
  248         kfree(e);
  249 }
  250 
  251 /*
  252  * Sets the probe callback corresponding to one tracepoint.
  253  */
  254 static void set_tracepoint(struct tracepoint_entry **entry,
  255         struct tracepoint *elem, int active)
  256 {
  257         WARN_ON(strcmp((*entry)->name, elem->name) != 0);
  258 
  259         if (elem->regfunc && !static_key_enabled(&elem->key) && active)
  260                 elem->regfunc();
  261         else if (elem->unregfunc && static_key_enabled(&elem->key) && !active)
  262                 elem->unregfunc();
  263 
  264         /*
  265          * rcu_assign_pointer has a smp_wmb() which makes sure that the new
  266          * probe callbacks array is consistent before setting a pointer to it.
  267          * This array is referenced by __DO_TRACE from
  268          * include/linux/tracepoints.h. A matching smp_read_barrier_depends()
  269          * is used.
  270          */
  271         rcu_assign_pointer(elem->funcs, (*entry)->funcs);
  272         if (active && !static_key_enabled(&elem->key))
  273                 static_key_slow_inc(&elem->key);
  274         else if (!active && static_key_enabled(&elem->key))
  275                 static_key_slow_dec(&elem->key);
  276 }
  277 
  278 /*
  279  * Disable a tracepoint and its probe callback.
  280  * Note: only waiting an RCU period after setting elem->call to the empty
  281  * function insures that the original callback is not used anymore. This insured
  282  * by preempt_disable around the call site.
  283  */
  284 static void disable_tracepoint(struct tracepoint *elem)
  285 {
  286         if (elem->unregfunc && static_key_enabled(&elem->key))
  287                 elem->unregfunc();
  288 
  289         if (static_key_enabled(&elem->key))
  290                 static_key_slow_dec(&elem->key);
  291         rcu_assign_pointer(elem->funcs, NULL);
  292 }
  293 
  294 /**
  295  * tracepoint_update_probe_range - Update a probe range
  296  * @begin: beginning of the range
  297  * @end: end of the range
  298  *
  299  * Updates the probe callback corresponding to a range of tracepoints.
  300  * Called with tracepoints_mutex held.
  301  */
  302 static void tracepoint_update_probe_range(struct tracepoint * const *begin,
  303                                           struct tracepoint * const *end)
  304 {
  305         struct tracepoint * const *iter;
  306         struct tracepoint_entry *mark_entry;
  307 
  308         if (!begin)
  309                 return;
  310 
  311         for (iter = begin; iter < end; iter++) {
  312                 mark_entry = get_tracepoint((*iter)->name);
  313                 if (mark_entry) {
  314                         set_tracepoint(&mark_entry, *iter,
  315                                         !!mark_entry->refcount);
  316                 } else {
  317                         disable_tracepoint(*iter);
  318                 }
  319         }
  320 }
  321 
  322 #ifdef CONFIG_MODULES
  323 void module_update_tracepoints(void)
  324 {
  325         struct tp_module *tp_mod;
  326 
  327         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
  328                 tracepoint_update_probe_range(tp_mod->tracepoints_ptrs,
  329                         tp_mod->tracepoints_ptrs + tp_mod->num_tracepoints);
  330 }
  331 #else /* CONFIG_MODULES */
  332 void module_update_tracepoints(void)
  333 {
  334 }
  335 #endif /* CONFIG_MODULES */
  336 
  337 
  338 /*
  339  * Update probes, removing the faulty probes.
  340  * Called with tracepoints_mutex held.
  341  */
  342 static void tracepoint_update_probes(void)
  343 {
  344         /* Core kernel tracepoints */
  345         tracepoint_update_probe_range(__start___tracepoints_ptrs,
  346                 __stop___tracepoints_ptrs);
  347         /* tracepoints in modules. */
  348         module_update_tracepoints();
  349 }
  350 
  351 static struct tracepoint_func *
  352 tracepoint_add_probe(const char *name, void *probe, void *data)
  353 {
  354         struct tracepoint_entry *entry;
  355         struct tracepoint_func *old;
  356 
  357         entry = get_tracepoint(name);
  358         if (!entry) {
  359                 entry = add_tracepoint(name);
  360                 if (IS_ERR(entry))
  361                         return (struct tracepoint_func *)entry;
  362         }
  363         old = tracepoint_entry_add_probe(entry, probe, data);
  364         if (IS_ERR(old) && !entry->refcount)
  365                 remove_tracepoint(entry);
  366         return old;
  367 }
  368 
  369 /**
  370  * tracepoint_probe_register -  Connect a probe to a tracepoint
  371  * @name: tracepoint name
  372  * @probe: probe handler
  373  *
  374  * Returns 0 if ok, error value on error.
  375  * The probe address must at least be aligned on the architecture pointer size.
  376  */
  377 int tracepoint_probe_register(const char *name, void *probe, void *data)
  378 {
  379         struct tracepoint_func *old;
  380 
  381         mutex_lock(&tracepoints_mutex);
  382         old = tracepoint_add_probe(name, probe, data);
  383         if (IS_ERR(old)) {
  384                 mutex_unlock(&tracepoints_mutex);
  385                 return PTR_ERR(old);
  386         }
  387         tracepoint_update_probes();             /* may update entry */
  388         mutex_unlock(&tracepoints_mutex);
  389         release_probes(old);
  390         return 0;
  391 }
  392 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
  393 
  394 static struct tracepoint_func *
  395 tracepoint_remove_probe(const char *name, void *probe, void *data)
  396 {
  397         struct tracepoint_entry *entry;
  398         struct tracepoint_func *old;
  399 
  400         entry = get_tracepoint(name);
  401         if (!entry)
  402                 return ERR_PTR(-ENOENT);
  403         old = tracepoint_entry_remove_probe(entry, probe, data);
  404         if (IS_ERR(old))
  405                 return old;
  406         if (!entry->refcount)
  407                 remove_tracepoint(entry);
  408         return old;
  409 }
  410 
  411 /**
  412  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
  413  * @name: tracepoint name
  414  * @probe: probe function pointer
  415  *
  416  * We do not need to call a synchronize_sched to make sure the probes have
  417  * finished running before doing a module unload, because the module unload
  418  * itself uses stop_machine(), which insures that every preempt disabled section
  419  * have finished.
  420  */
  421 int tracepoint_probe_unregister(const char *name, void *probe, void *data)
  422 {
  423         struct tracepoint_func *old;
  424 
  425         mutex_lock(&tracepoints_mutex);
  426         old = tracepoint_remove_probe(name, probe, data);
  427         if (IS_ERR(old)) {
  428                 mutex_unlock(&tracepoints_mutex);
  429                 return PTR_ERR(old);
  430         }
  431         tracepoint_update_probes();             /* may update entry */
  432         mutex_unlock(&tracepoints_mutex);
  433         release_probes(old);
  434         return 0;
  435 }
  436 EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
  437 
  438 static LIST_HEAD(old_probes);
  439 static int need_update;
  440 
  441 static void tracepoint_add_old_probes(void *old)
  442 {
  443         need_update = 1;
  444         if (old) {
  445                 struct tp_probes *tp_probes = container_of(old,
  446                         struct tp_probes, probes[0]);
  447                 list_add(&tp_probes->u.list, &old_probes);
  448         }
  449 }
  450 
  451 /**
  452  * tracepoint_probe_register_noupdate -  register a probe but not connect
  453  * @name: tracepoint name
  454  * @probe: probe handler
  455  *
  456  * caller must call tracepoint_probe_update_all()
  457  */
  458 int tracepoint_probe_register_noupdate(const char *name, void *probe,
  459                                        void *data)
  460 {
  461         struct tracepoint_func *old;
  462 
  463         mutex_lock(&tracepoints_mutex);
  464         old = tracepoint_add_probe(name, probe, data);
  465         if (IS_ERR(old)) {
  466                 mutex_unlock(&tracepoints_mutex);
  467                 return PTR_ERR(old);
  468         }
  469         tracepoint_add_old_probes(old);
  470         mutex_unlock(&tracepoints_mutex);
  471         return 0;
  472 }
  473 EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
  474 
  475 /**
  476  * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
  477  * @name: tracepoint name
  478  * @probe: probe function pointer
  479  *
  480  * caller must call tracepoint_probe_update_all()
  481  */
  482 int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
  483                                          void *data)
  484 {
  485         struct tracepoint_func *old;
  486 
  487         mutex_lock(&tracepoints_mutex);
  488         old = tracepoint_remove_probe(name, probe, data);
  489         if (IS_ERR(old)) {
  490                 mutex_unlock(&tracepoints_mutex);
  491                 return PTR_ERR(old);
  492         }
  493         tracepoint_add_old_probes(old);
  494         mutex_unlock(&tracepoints_mutex);
  495         return 0;
  496 }
  497 EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
  498 
  499 /**
  500  * tracepoint_probe_update_all -  update tracepoints
  501  */
  502 void tracepoint_probe_update_all(void)
  503 {
  504         LIST_HEAD(release_probes);
  505         struct tp_probes *pos, *next;
  506 
  507         mutex_lock(&tracepoints_mutex);
  508         if (!need_update) {
  509                 mutex_unlock(&tracepoints_mutex);
  510                 return;
  511         }
  512         if (!list_empty(&old_probes))
  513                 list_replace_init(&old_probes, &release_probes);
  514         need_update = 0;
  515         tracepoint_update_probes();
  516         mutex_unlock(&tracepoints_mutex);
  517         list_for_each_entry_safe(pos, next, &release_probes, u.list) {
  518                 list_del(&pos->u.list);
  519                 call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
  520         }
  521 }
  522 EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
  523 
  524 /**
  525  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
  526  * @tracepoint: current tracepoints (in), next tracepoint (out)
  527  * @begin: beginning of the range
  528  * @end: end of the range
  529  *
  530  * Returns whether a next tracepoint has been found (1) or not (0).
  531  * Will return the first tracepoint in the range if the input tracepoint is
  532  * NULL.
  533  */
  534 static int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
  535         struct tracepoint * const *begin, struct tracepoint * const *end)
  536 {
  537         if (!*tracepoint && begin != end) {
  538                 *tracepoint = begin;
  539                 return 1;
  540         }
  541         if (*tracepoint >= begin && *tracepoint < end)
  542                 return 1;
  543         return 0;
  544 }
  545 
  546 #ifdef CONFIG_MODULES
  547 static void tracepoint_get_iter(struct tracepoint_iter *iter)
  548 {
  549         int found = 0;
  550         struct tp_module *iter_mod;
  551 
  552         /* Core kernel tracepoints */
  553         if (!iter->module) {
  554                 found = tracepoint_get_iter_range(&iter->tracepoint,
  555                                 __start___tracepoints_ptrs,
  556                                 __stop___tracepoints_ptrs);
  557                 if (found)
  558                         goto end;
  559         }
  560         /* Tracepoints in modules */
  561         mutex_lock(&tracepoints_mutex);
  562         list_for_each_entry(iter_mod, &tracepoint_module_list, list) {
  563                 /*
  564                  * Sorted module list
  565                  */
  566                 if (iter_mod < iter->module)
  567                         continue;
  568                 else if (iter_mod > iter->module)
  569                         iter->tracepoint = NULL;
  570                 found = tracepoint_get_iter_range(&iter->tracepoint,
  571                         iter_mod->tracepoints_ptrs,
  572                         iter_mod->tracepoints_ptrs
  573                                 + iter_mod->num_tracepoints);
  574                 if (found) {
  575                         iter->module = iter_mod;
  576                         break;
  577                 }
  578         }
  579         mutex_unlock(&tracepoints_mutex);
  580 end:
  581         if (!found)
  582                 tracepoint_iter_reset(iter);
  583 }
  584 #else /* CONFIG_MODULES */
  585 static void tracepoint_get_iter(struct tracepoint_iter *iter)
  586 {
  587         int found = 0;
  588 
  589         /* Core kernel tracepoints */
  590         found = tracepoint_get_iter_range(&iter->tracepoint,
  591                         __start___tracepoints_ptrs,
  592                         __stop___tracepoints_ptrs);
  593         if (!found)
  594                 tracepoint_iter_reset(iter);
  595 }
  596 #endif /* CONFIG_MODULES */
  597 
  598 void tracepoint_iter_start(struct tracepoint_iter *iter)
  599 {
  600         tracepoint_get_iter(iter);
  601 }
  602 EXPORT_SYMBOL_GPL(tracepoint_iter_start);
  603 
  604 void tracepoint_iter_next(struct tracepoint_iter *iter)
  605 {
  606         iter->tracepoint++;
  607         /*
  608          * iter->tracepoint may be invalid because we blindly incremented it.
  609          * Make sure it is valid by marshalling on the tracepoints, getting the
  610          * tracepoints from following modules if necessary.
  611          */
  612         tracepoint_get_iter(iter);
  613 }
  614 EXPORT_SYMBOL_GPL(tracepoint_iter_next);
  615 
  616 void tracepoint_iter_stop(struct tracepoint_iter *iter)
  617 {
  618 }
  619 EXPORT_SYMBOL_GPL(tracepoint_iter_stop);
  620 
  621 void tracepoint_iter_reset(struct tracepoint_iter *iter)
  622 {
  623 #ifdef CONFIG_MODULES
  624         iter->module = NULL;
  625 #endif /* CONFIG_MODULES */
  626         iter->tracepoint = NULL;
  627 }
  628 EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
  629 
  630 #ifdef CONFIG_MODULES
  631 static int tracepoint_module_coming(struct module *mod)
  632 {
  633         struct tp_module *tp_mod, *iter;
  634         int ret = 0;
  635 
  636         /*
  637          * We skip modules that taint the kernel, especially those with different
  638          * module headers (for forced load), to make sure we don't cause a crash.
  639          * Staging and out-of-tree GPL modules are fine.
  640          */
  641         if (mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP)))
  642                 return 0;
  643         mutex_lock(&tracepoints_mutex);
  644         tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
  645         if (!tp_mod) {
  646                 ret = -ENOMEM;
  647                 goto end;
  648         }
  649         tp_mod->num_tracepoints = mod->num_tracepoints;
  650         tp_mod->tracepoints_ptrs = mod->tracepoints_ptrs;
  651 
  652         /*
  653          * tracepoint_module_list is kept sorted by struct module pointer
  654          * address for iteration on tracepoints from a seq_file that can release
  655          * the mutex between calls.
  656          */
  657         list_for_each_entry_reverse(iter, &tracepoint_module_list, list) {
  658                 BUG_ON(iter == tp_mod); /* Should never be in the list twice */
  659                 if (iter < tp_mod) {
  660                         /* We belong to the location right after iter. */
  661                         list_add(&tp_mod->list, &iter->list);
  662                         goto module_added;
  663                 }
  664         }
  665         /* We belong to the beginning of the list */
  666         list_add(&tp_mod->list, &tracepoint_module_list);
  667 module_added:
  668         tracepoint_update_probe_range(mod->tracepoints_ptrs,
  669                 mod->tracepoints_ptrs + mod->num_tracepoints);
  670 end:
  671         mutex_unlock(&tracepoints_mutex);
  672         return ret;
  673 }
  674 
  675 static int tracepoint_module_going(struct module *mod)
  676 {
  677         struct tp_module *pos;
  678 
  679         mutex_lock(&tracepoints_mutex);
  680         tracepoint_update_probe_range(mod->tracepoints_ptrs,
  681                 mod->tracepoints_ptrs + mod->num_tracepoints);
  682         list_for_each_entry(pos, &tracepoint_module_list, list) {
  683                 if (pos->tracepoints_ptrs == mod->tracepoints_ptrs) {
  684                         list_del(&pos->list);
  685                         kfree(pos);
  686                         break;
  687                 }
  688         }
  689         /*
  690          * In the case of modules that were tainted at "coming", we'll simply
  691          * walk through the list without finding it. We cannot use the "tainted"
  692          * flag on "going", in case a module taints the kernel only after being
  693          * loaded.
  694          */
  695         mutex_unlock(&tracepoints_mutex);
  696         return 0;
  697 }
  698 
  699 int tracepoint_module_notify(struct notifier_block *self,
  700                              unsigned long val, void *data)
  701 {
  702         struct module *mod = data;
  703         int ret = 0;
  704 
  705         switch (val) {
  706         case MODULE_STATE_COMING:
  707                 ret = tracepoint_module_coming(mod);
  708                 break;
  709         case MODULE_STATE_LIVE:
  710                 break;
  711         case MODULE_STATE_GOING:
  712                 ret = tracepoint_module_going(mod);
  713                 break;
  714         }
  715         return ret;
  716 }
  717 
  718 struct notifier_block tracepoint_module_nb = {
  719         .notifier_call = tracepoint_module_notify,
  720         .priority = 0,
  721 };
  722 
  723 static int init_tracepoints(void)
  724 {
  725         return register_module_notifier(&tracepoint_module_nb);
  726 }
  727 __initcall(init_tracepoints);
  728 #endif /* CONFIG_MODULES */
  729 
  730 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
  731 
  732 /* NB: reg/unreg are called while guarded with the tracepoints_mutex */
  733 static int sys_tracepoint_refcount;
  734 
  735 void syscall_regfunc(void)
  736 {
  737         unsigned long flags;
  738         struct task_struct *g, *t;
  739 
  740         if (!sys_tracepoint_refcount) {
  741                 read_lock_irqsave(&tasklist_lock, flags);
  742                 do_each_thread(g, t) {
  743                         /* Skip kernel threads. */
  744                         if (t->mm)
  745                                 set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
  746                 } while_each_thread(g, t);
  747                 read_unlock_irqrestore(&tasklist_lock, flags);
  748         }
  749         sys_tracepoint_refcount++;
  750 }
  751 
  752 void syscall_unregfunc(void)
  753 {
  754         unsigned long flags;
  755         struct task_struct *g, *t;
  756 
  757         sys_tracepoint_refcount--;
  758         if (!sys_tracepoint_refcount) {
  759                 read_lock_irqsave(&tasklist_lock, flags);
  760                 do_each_thread(g, t) {
  761                         clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
  762                 } while_each_thread(g, t);
  763                 read_unlock_irqrestore(&tasklist_lock, flags);
  764         }
  765 }
  766 #endif
Cache object: 84ce960a08dc5f1f718542101ffde6a7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/kernel/tracepoint.c

FreeBSD/Linux Kernel Cross Reference
sys/kernel/tracepoint.c
