kernel/tracepoint.c

   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 tracepoint_entry *e;
 196         u32 hash = jhash(name, strlen(name), 0);
 197
 198         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
 199         hlist_for_each_entry(e, head, hlist) {
 200                 if (!strcmp(name, e->name))
 201                         return e;
 202         }
 203         return NULL;
 204 }
 205
 206 /*
 207  * Add the tracepoint to the tracepoint hash table. Must be called with
 208  * tracepoints_mutex held.
 209  */
 210 static struct tracepoint_entry *add_tracepoint(const char *name)
 211 {
 212         struct hlist_head *head;
 213         struct tracepoint_entry *e;
 214         size_t name_len = strlen(name) + 1;
 215         u32 hash = jhash(name, name_len-1, 0);
 216
 217         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
 218         hlist_for_each_entry(e, head, hlist) {
 219                 if (!strcmp(name, e->name)) {
 220                         printk(KERN_NOTICE
 221                                 "tracepoint %s busy\n", name);
 222                         return ERR_PTR(-EEXIST);        /* Already there */
 223                 }
 224         }
 225         /*
 226          * Using kmalloc here to allocate a variable length element. Could
 227          * cause some memory fragmentation if overused.
 228          */
 229         e = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
 230         if (!e)
 231                 return ERR_PTR(-ENOMEM);
 232         memcpy(&e->name[0], name, name_len);
 233         e->funcs = NULL;
 234         e->refcount = 0;
 235         hlist_add_head(&e->hlist, head);
 236         return e;
 237 }
 238
 239 /*
 240  * Remove the tracepoint from the tracepoint hash table. Must be called with
 241  * mutex_lock held.
 242  */
 243 static inline void remove_tracepoint(struct tracepoint_entry *e)
 244 {
 245         hlist_del(&e->hlist);
 246         kfree(e);
 247 }
 248
 249 /*
 250  * Sets the probe callback corresponding to one tracepoint.
 251  */
 252 static void set_tracepoint(struct tracepoint_entry **entry,
 253         struct tracepoint *elem, int active)
 254 {
 255         WARN_ON(strcmp((*entry)->name, elem->name) != 0);
 256
 257         if (elem->regfunc && !static_key_enabled(&elem->key) && active)
 258                 elem->regfunc();
 259         else if (elem->unregfunc && static_key_enabled(&elem->key) && !active)
 260                 elem->unregfunc();
 261
 262         /*
 263          * rcu_assign_pointer has a smp_wmb() which makes sure that the new
 264          * probe callbacks array is consistent before setting a pointer to it.
 265          * This array is referenced by __DO_TRACE from
 266          * include/linux/tracepoints.h. A matching smp_read_barrier_depends()
 267          * is used.
 268          */
 269         rcu_assign_pointer(elem->funcs, (*entry)->funcs);
 270         if (active && !static_key_enabled(&elem->key))
 271                 static_key_slow_inc(&elem->key);
 272         else if (!active && static_key_enabled(&elem->key))
 273                 static_key_slow_dec(&elem->key);
 274 }
 275
 276 /*
 277  * Disable a tracepoint and its probe callback.
 278  * Note: only waiting an RCU period after setting elem->call to the empty
 279  * function insures that the original callback is not used anymore. This insured
 280  * by preempt_disable around the call site.
 281  */
 282 static void disable_tracepoint(struct tracepoint *elem)
 283 {
 284         if (elem->unregfunc && static_key_enabled(&elem->key))
 285                 elem->unregfunc();
 286
 287         if (static_key_enabled(&elem->key))
 288                 static_key_slow_dec(&elem->key);
 289         rcu_assign_pointer(elem->funcs, NULL);
 290 }
 291
 292 /**
 293  * tracepoint_update_probe_range - Update a probe range
 294  * @begin: beginning of the range
 295  * @end: end of the range
 296  *
 297  * Updates the probe callback corresponding to a range of tracepoints.
 298  * Called with tracepoints_mutex held.
 299  */
 300 static void tracepoint_update_probe_range(struct tracepoint * const *begin,
 301                                           struct tracepoint * const *end)
 302 {
 303         struct tracepoint * const *iter;
 304         struct tracepoint_entry *mark_entry;
 305
 306         if (!begin)
 307                 return;
 308
 309         for (iter = begin; iter < end; iter++) {
 310                 mark_entry = get_tracepoint((*iter)->name);
 311                 if (mark_entry) {
 312                         set_tracepoint(&mark_entry, *iter,
 313                                         !!mark_entry->refcount);
 314                 } else {
 315                         disable_tracepoint(*iter);
 316                 }
 317         }
 318 }
 319
 320 #ifdef CONFIG_MODULES
 321 void module_update_tracepoints(void)
 322 {
 323         struct tp_module *tp_mod;
 324
 325         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
 326                 tracepoint_update_probe_range(tp_mod->tracepoints_ptrs,
 327                         tp_mod->tracepoints_ptrs + tp_mod->num_tracepoints);
 328 }
 329 #else /* CONFIG_MODULES */
 330 void module_update_tracepoints(void)
 331 {
 332 }
 333 #endif /* CONFIG_MODULES */
 334
 335
 336 /*
 337  * Update probes, removing the faulty probes.
 338  * Called with tracepoints_mutex held.
 339  */
 340 static void tracepoint_update_probes(void)
 341 {
 342         /* Core kernel tracepoints */
 343         tracepoint_update_probe_range(__start___tracepoints_ptrs,
 344                 __stop___tracepoints_ptrs);
 345         /* tracepoints in modules. */
 346         module_update_tracepoints();
 347 }
 348
 349 static struct tracepoint_func *
 350 tracepoint_add_probe(const char *name, void *probe, void *data)
 351 {
 352         struct tracepoint_entry *entry;
 353         struct tracepoint_func *old;
 354
 355         entry = get_tracepoint(name);
 356         if (!entry) {
 357                 entry = add_tracepoint(name);
 358                 if (IS_ERR(entry))
 359                         return (struct tracepoint_func *)entry;
 360         }
 361         old = tracepoint_entry_add_probe(entry, probe, data);
 362         if (IS_ERR(old) && !entry->refcount)
 363                 remove_tracepoint(entry);
 364         return old;
 365 }
 366
 367 /**
 368  * tracepoint_probe_register -  Connect a probe to a tracepoint
 369  * @name: tracepoint name
 370  * @probe: probe handler
 371  *
 372  * Returns 0 if ok, error value on error.
 373  * The probe address must at least be aligned on the architecture pointer size.
 374  */
 375 int tracepoint_probe_register(const char *name, void *probe, void *data)
 376 {
 377         struct tracepoint_func *old;
 378
 379         mutex_lock(&tracepoints_mutex);
 380         old = tracepoint_add_probe(name, probe, data);
 381         if (IS_ERR(old)) {
 382                 mutex_unlock(&tracepoints_mutex);
 383                 return PTR_ERR(old);
 384         }
 385         tracepoint_update_probes();             /* may update entry */
 386         mutex_unlock(&tracepoints_mutex);
 387         release_probes(old);
 388         return 0;
 389 }
 390 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 391
 392 static struct tracepoint_func *
 393 tracepoint_remove_probe(const char *name, void *probe, void *data)
 394 {
 395         struct tracepoint_entry *entry;
 396         struct tracepoint_func *old;
 397
 398         entry = get_tracepoint(name);
 399         if (!entry)
 400                 return ERR_PTR(-ENOENT);
 401         old = tracepoint_entry_remove_probe(entry, probe, data);
 402         if (IS_ERR(old))
 403                 return old;
 404         if (!entry->refcount)
 405                 remove_tracepoint(entry);
 406         return old;
 407 }
 408
 409 /**
 410  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
 411  * @name: tracepoint name
 412  * @probe: probe function pointer
 413  *
 414  * We do not need to call a synchronize_sched to make sure the probes have
 415  * finished running before doing a module unload, because the module unload
 416  * itself uses stop_machine(), which insures that every preempt disabled section
 417  * have finished.
 418  */
 419 int tracepoint_probe_unregister(const char *name, void *probe, void *data)
 420 {
 421         struct tracepoint_func *old;
 422
 423         mutex_lock(&tracepoints_mutex);
 424         old = tracepoint_remove_probe(name, probe, data);
 425         if (IS_ERR(old)) {
 426                 mutex_unlock(&tracepoints_mutex);
 427                 return PTR_ERR(old);
 428         }
 429         tracepoint_update_probes();             /* may update entry */
 430         mutex_unlock(&tracepoints_mutex);
 431         release_probes(old);
 432         return 0;
 433 }
 434 EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 435
 436 static LIST_HEAD(old_probes);
 437 static int need_update;
 438
 439 static void tracepoint_add_old_probes(void *old)
 440 {
 441         need_update = 1;
 442         if (old) {
 443                 struct tp_probes *tp_probes = container_of(old,
 444                         struct tp_probes, probes[0]);
 445                 list_add(&tp_probes->u.list, &old_probes);
 446         }
 447 }
 448
 449 /**
 450  * tracepoint_probe_register_noupdate -  register a probe but not connect
 451  * @name: tracepoint name
 452  * @probe: probe handler
 453  *
 454  * caller must call tracepoint_probe_update_all()
 455  */
 456 int tracepoint_probe_register_noupdate(const char *name, void *probe,
 457                                        void *data)
 458 {
 459         struct tracepoint_func *old;
 460
 461         mutex_lock(&tracepoints_mutex);
 462         old = tracepoint_add_probe(name, probe, data);
 463         if (IS_ERR(old)) {
 464                 mutex_unlock(&tracepoints_mutex);
 465                 return PTR_ERR(old);
 466         }
 467         tracepoint_add_old_probes(old);
 468         mutex_unlock(&tracepoints_mutex);
 469         return 0;
 470 }
 471 EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
 472
 473 /**
 474  * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
 475  * @name: tracepoint name
 476  * @probe: probe function pointer
 477  *
 478  * caller must call tracepoint_probe_update_all()
 479  */
 480 int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 481                                          void *data)
 482 {
 483         struct tracepoint_func *old;
 484
 485         mutex_lock(&tracepoints_mutex);
 486         old = tracepoint_remove_probe(name, probe, data);
 487         if (IS_ERR(old)) {
 488                 mutex_unlock(&tracepoints_mutex);
 489                 return PTR_ERR(old);
 490         }
 491         tracepoint_add_old_probes(old);
 492         mutex_unlock(&tracepoints_mutex);
 493         return 0;
 494 }
 495 EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
 496
 497 /**
 498  * tracepoint_probe_update_all -  update tracepoints
 499  */
 500 void tracepoint_probe_update_all(void)
 501 {
 502         LIST_HEAD(release_probes);
 503         struct tp_probes *pos, *next;
 504
 505         mutex_lock(&tracepoints_mutex);
 506         if (!need_update) {
 507                 mutex_unlock(&tracepoints_mutex);
 508                 return;
 509         }
 510         if (!list_empty(&old_probes))
 511                 list_replace_init(&old_probes, &release_probes);
 512         need_update = 0;
 513         tracepoint_update_probes();
 514         mutex_unlock(&tracepoints_mutex);
 515         list_for_each_entry_safe(pos, next, &release_probes, u.list) {
 516                 list_del(&pos->u.list);
 517                 call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
 518         }
 519 }
 520 EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 521
 522 /**
 523  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
 524  * @tracepoint: current tracepoints (in), next tracepoint (out)
 525  * @begin: beginning of the range
 526  * @end: end of the range
 527  *
 528  * Returns whether a next tracepoint has been found (1) or not (0).
 529  * Will return the first tracepoint in the range if the input tracepoint is
 530  * NULL.
 531  */
 532 static int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
 533         struct tracepoint * const *begin, struct tracepoint * const *end)
 534 {
 535         if (!*tracepoint && begin != end) {
 536                 *tracepoint = begin;
 537                 return 1;
 538         }
 539         if (*tracepoint >= begin && *tracepoint < end)
 540                 return 1;
 541         return 0;
 542 }
 543
 544 #ifdef CONFIG_MODULES
 545 static void tracepoint_get_iter(struct tracepoint_iter *iter)
 546 {
 547         int found = 0;
 548         struct tp_module *iter_mod;
 549
 550         /* Core kernel tracepoints */
 551         if (!iter->module) {
 552                 found = tracepoint_get_iter_range(&iter->tracepoint,
 553                                 __start___tracepoints_ptrs,
 554                                 __stop___tracepoints_ptrs);
 555                 if (found)
 556                         goto end;
 557         }
 558         /* Tracepoints in modules */
 559         mutex_lock(&tracepoints_mutex);
 560         list_for_each_entry(iter_mod, &tracepoint_module_list, list) {
 561                 /*
 562                  * Sorted module list
 563                  */
 564                 if (iter_mod < iter->module)
 565                         continue;
 566                 else if (iter_mod > iter->module)
 567                         iter->tracepoint = NULL;
 568                 found = tracepoint_get_iter_range(&iter->tracepoint,
 569                         iter_mod->tracepoints_ptrs,
 570                         iter_mod->tracepoints_ptrs
 571                                 + iter_mod->num_tracepoints);
 572                 if (found) {
 573                         iter->module = iter_mod;
 574                         break;
 575                 }
 576         }
 577         mutex_unlock(&tracepoints_mutex);
 578 end:
 579         if (!found)
 580                 tracepoint_iter_reset(iter);
 581 }
 582 #else /* CONFIG_MODULES */
 583 static void tracepoint_get_iter(struct tracepoint_iter *iter)
 584 {
 585         int found = 0;
 586
 587         /* Core kernel tracepoints */
 588         found = tracepoint_get_iter_range(&iter->tracepoint,
 589                         __start___tracepoints_ptrs,
 590                         __stop___tracepoints_ptrs);
 591         if (!found)
 592                 tracepoint_iter_reset(iter);
 593 }
 594 #endif /* CONFIG_MODULES */
 595
 596 void tracepoint_iter_start(struct tracepoint_iter *iter)
 597 {
 598         tracepoint_get_iter(iter);
 599 }
 600 EXPORT_SYMBOL_GPL(tracepoint_iter_start);
 601
 602 void tracepoint_iter_next(struct tracepoint_iter *iter)
 603 {
 604         iter->tracepoint++;
 605         /*
 606          * iter->tracepoint may be invalid because we blindly incremented it.
 607          * Make sure it is valid by marshalling on the tracepoints, getting the
 608          * tracepoints from following modules if necessary.
 609          */
 610         tracepoint_get_iter(iter);
 611 }
 612 EXPORT_SYMBOL_GPL(tracepoint_iter_next);
 613
 614 void tracepoint_iter_stop(struct tracepoint_iter *iter)
 615 {
 616 }
 617 EXPORT_SYMBOL_GPL(tracepoint_iter_stop);
 618
 619 void tracepoint_iter_reset(struct tracepoint_iter *iter)
 620 {
 621 #ifdef CONFIG_MODULES
 622         iter->module = NULL;
 623 #endif /* CONFIG_MODULES */
 624         iter->tracepoint = NULL;
 625 }
 626 EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
 627
 628 #ifdef CONFIG_MODULES
 629 static int tracepoint_module_coming(struct module *mod)
 630 {
 631         struct tp_module *tp_mod, *iter;
 632         int ret = 0;
 633
 634         /*
 635          * We skip modules that taint the kernel, especially those with different
 636          * module headers (for forced load), to make sure we don't cause a crash.
 637          * Staging and out-of-tree GPL modules are fine.
 638          */
 639         if (mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP)))
 640                 return 0;
 641         mutex_lock(&tracepoints_mutex);
 642         tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
 643         if (!tp_mod) {
 644                 ret = -ENOMEM;
 645                 goto end;
 646         }
 647         tp_mod->num_tracepoints = mod->num_tracepoints;
 648         tp_mod->tracepoints_ptrs = mod->tracepoints_ptrs;
 649
 650         /*
 651          * tracepoint_module_list is kept sorted by struct module pointer
 652          * address for iteration on tracepoints from a seq_file that can release
 653          * the mutex between calls.
 654          */
 655         list_for_each_entry_reverse(iter, &tracepoint_module_list, list) {
 656                 BUG_ON(iter == tp_mod); /* Should never be in the list twice */
 657                 if (iter < tp_mod) {
 658                         /* We belong to the location right after iter. */
 659                         list_add(&tp_mod->list, &iter->list);
 660                         goto module_added;
 661                 }
 662         }
 663         /* We belong to the beginning of the list */
 664         list_add(&tp_mod->list, &tracepoint_module_list);
 665 module_added:
 666         tracepoint_update_probe_range(mod->tracepoints_ptrs,
 667                 mod->tracepoints_ptrs + mod->num_tracepoints);
 668 end:
 669         mutex_unlock(&tracepoints_mutex);
 670         return ret;
 671 }
 672
 673 static int tracepoint_module_going(struct module *mod)
 674 {
 675         struct tp_module *pos;
 676
 677         mutex_lock(&tracepoints_mutex);
 678         tracepoint_update_probe_range(mod->tracepoints_ptrs,
 679                 mod->tracepoints_ptrs + mod->num_tracepoints);
 680         list_for_each_entry(pos, &tracepoint_module_list, list) {
 681                 if (pos->tracepoints_ptrs == mod->tracepoints_ptrs) {
 682                         list_del(&pos->list);
 683                         kfree(pos);
 684                         break;
 685                 }
 686         }
 687         /*
 688          * In the case of modules that were tainted at "coming", we'll simply
 689          * walk through the list without finding it. We cannot use the "tainted"
 690          * flag on "going", in case a module taints the kernel only after being
 691          * loaded.
 692          */
 693         mutex_unlock(&tracepoints_mutex);
 694         return 0;
 695 }
 696
 697 int tracepoint_module_notify(struct notifier_block *self,
 698                              unsigned long val, void *data)
 699 {
 700         struct module *mod = data;
 701         int ret = 0;
 702
 703         switch (val) {
 704         case MODULE_STATE_COMING:
 705                 ret = tracepoint_module_coming(mod);
 706                 break;
 707         case MODULE_STATE_LIVE:
 708                 break;
 709         case MODULE_STATE_GOING:
 710                 ret = tracepoint_module_going(mod);
 711                 break;
 712         }
 713         return ret;
 714 }
 715
 716 struct notifier_block tracepoint_module_nb = {
 717         .notifier_call = tracepoint_module_notify,
 718         .priority = 0,
 719 };
 720
 721 static int init_tracepoints(void)
 722 {
 723         return register_module_notifier(&tracepoint_module_nb);
 724 }
 725 __initcall(init_tracepoints);
 726 #endif /* CONFIG_MODULES */
 727
 728 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 729
 730 /* NB: reg/unreg are called while guarded with the tracepoints_mutex */
 731 static int sys_tracepoint_refcount;
 732
 733 void syscall_regfunc(void)
 734 {
 735         unsigned long flags;
 736         struct task_struct *g, *t;
 737
 738         if (!sys_tracepoint_refcount) {
 739                 read_lock_irqsave(&tasklist_lock, flags);
 740                 do_each_thread(g, t) {
 741                         /* Skip kernel threads. */
 742                         if (t->mm)
 743                                 set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
 744                 } while_each_thread(g, t);
 745                 read_unlock_irqrestore(&tasklist_lock, flags);
 746         }
 747         sys_tracepoint_refcount++;
 748 }
 749
 750 void syscall_unregfunc(void)
 751 {
 752         unsigned long flags;
 753         struct task_struct *g, *t;
 754
 755         sys_tracepoint_refcount--;
 756         if (!sys_tracepoint_refcount) {
 757                 read_lock_irqsave(&tasklist_lock, flags);
 758                 do_each_thread(g, t) {
 759                         clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
 760                 } while_each_thread(g, t);
 761                 read_unlock_irqrestore(&tasklist_lock, flags);
 762         }
 763 }
 764 #endif