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