kernel/tracepoint.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2008-2014 Mathieu Desnoyers
   4  */
   5 #include <linux/module.h>
   6 #include <linux/mutex.h>
   7 #include <linux/types.h>
   8 #include <linux/jhash.h>
   9 #include <linux/list.h>
  10 #include <linux/rcupdate.h>
  11 #include <linux/tracepoint.h>
  12 #include <linux/err.h>
  13 #include <linux/slab.h>
  14 #include <linux/sched/signal.h>
  15 #include <linux/sched/task.h>
  16 #include <linux/static_key.h>
  17
  18 enum tp_func_state {
  19         TP_FUNC_0,
  20         TP_FUNC_1,
  21         TP_FUNC_2,
  22         TP_FUNC_N,
  23 };
  24
  25 extern tracepoint_ptr_t __start___tracepoints_ptrs[];
  26 extern tracepoint_ptr_t __stop___tracepoints_ptrs[];
  27
  28 DEFINE_SRCU(tracepoint_srcu);
  29 EXPORT_SYMBOL_GPL(tracepoint_srcu);
  30
  31 enum tp_transition_sync {
  32         TP_TRANSITION_SYNC_1_0_1,
  33         TP_TRANSITION_SYNC_N_2_1,
  34
  35         _NR_TP_TRANSITION_SYNC,
  36 };
  37
  38 struct tp_transition_snapshot {
  39         unsigned long rcu;
  40         unsigned long srcu;
  41         bool ongoing;
  42 };
  43
  44 /* Protected by tracepoints_mutex */
  45 static struct tp_transition_snapshot tp_transition_snapshot[_NR_TP_TRANSITION_SYNC];
  46
  47 static void tp_rcu_get_state(enum tp_transition_sync sync)
  48 {
  49         struct tp_transition_snapshot *snapshot = &tp_transition_snapshot[sync];
  50
  51         /* Keep the latest get_state snapshot. */
  52         snapshot->rcu = get_state_synchronize_rcu();
  53         snapshot->srcu = start_poll_synchronize_srcu(&tracepoint_srcu);
  54         snapshot->ongoing = true;
  55 }
  56
  57 static void tp_rcu_cond_sync(enum tp_transition_sync sync)
  58 {
  59         struct tp_transition_snapshot *snapshot = &tp_transition_snapshot[sync];
  60
  61         if (!snapshot->ongoing)
  62                 return;
  63         cond_synchronize_rcu(snapshot->rcu);
  64         if (!poll_state_synchronize_srcu(&tracepoint_srcu, snapshot->srcu))
  65                 synchronize_srcu(&tracepoint_srcu);
  66         snapshot->ongoing = false;
  67 }
  68
  69 /* Set to 1 to enable tracepoint debug output */
  70 static const int tracepoint_debug;
  71
  72 #ifdef CONFIG_MODULES
  73 /*
  74  * Tracepoint module list mutex protects the local module list.
  75  */
  76 static DEFINE_MUTEX(tracepoint_module_list_mutex);
  77
  78 /* Local list of struct tp_module */
  79 static LIST_HEAD(tracepoint_module_list);
  80 #endif /* CONFIG_MODULES */
  81
  82 /*
  83  * tracepoints_mutex protects the builtin and module tracepoints.
  84  * tracepoints_mutex nests inside tracepoint_module_list_mutex.
  85  */
  86 static DEFINE_MUTEX(tracepoints_mutex);
  87
  88 static struct rcu_head *early_probes;
  89 static bool ok_to_free_tracepoints;
  90
  91 /*
  92  * Note about RCU :
  93  * It is used to delay the free of multiple probes array until a quiescent
  94  * state is reached.
  95  */
  96 struct tp_probes {
  97         struct rcu_head rcu;
  98         struct tracepoint_func probes[];
  99 };
 100
 101 /* Called in removal of a func but failed to allocate a new tp_funcs */
 102 static void tp_stub_func(void)
 103 {
 104         return;
 105 }
 106
 107 static inline void *allocate_probes(int count)
 108 {
 109         struct tp_probes *p  = kmalloc(struct_size(p, probes, count),
 110                                        GFP_KERNEL);
 111         return p == NULL ? NULL : p->probes;
 112 }
 113
 114 static void srcu_free_old_probes(struct rcu_head *head)
 115 {
 116         kfree(container_of(head, struct tp_probes, rcu));
 117 }
 118
 119 static void rcu_free_old_probes(struct rcu_head *head)
 120 {
 121         call_srcu(&tracepoint_srcu, head, srcu_free_old_probes);
 122 }
 123
 124 static __init int release_early_probes(void)
 125 {
 126         struct rcu_head *tmp;
 127
 128         ok_to_free_tracepoints = true;
 129
 130         while (early_probes) {
 131                 tmp = early_probes;
 132                 early_probes = tmp->next;
 133                 call_rcu(tmp, rcu_free_old_probes);
 134         }
 135
 136         return 0;
 137 }
 138
 139 /* SRCU is initialized at core_initcall */
 140 postcore_initcall(release_early_probes);
 141
 142 static inline void release_probes(struct tracepoint_func *old)
 143 {
 144         if (old) {
 145                 struct tp_probes *tp_probes = container_of(old,
 146                         struct tp_probes, probes[0]);
 147
 148                 /*
 149                  * We can't free probes if SRCU is not initialized yet.
 150                  * Postpone the freeing till after SRCU is initialized.
 151                  */
 152                 if (unlikely(!ok_to_free_tracepoints)) {
 153                         tp_probes->rcu.next = early_probes;
 154                         early_probes = &tp_probes->rcu;
 155                         return;
 156                 }
 157
 158                 /*
 159                  * Tracepoint probes are protected by both sched RCU and SRCU,
 160                  * by calling the SRCU callback in the sched RCU callback we
 161                  * cover both cases. So let us chain the SRCU and sched RCU
 162                  * callbacks to wait for both grace periods.
 163                  */
 164                 call_rcu(&tp_probes->rcu, rcu_free_old_probes);
 165         }
 166 }
 167
 168 static void debug_print_probes(struct tracepoint_func *funcs)
 169 {
 170         int i;
 171
 172         if (!tracepoint_debug || !funcs)
 173                 return;
 174
 175         for (i = 0; funcs[i].func; i++)
 176                 printk(KERN_DEBUG "Probe %d : %p\n", i, funcs[i].func);
 177 }
 178
 179 static struct tracepoint_func *
 180 func_add(struct tracepoint_func **funcs, struct tracepoint_func *tp_func,
 181          int prio)
 182 {
 183         struct tracepoint_func *old, *new;
 184         int iter_probes;        /* Iterate over old probe array. */
 185         int nr_probes = 0;      /* Counter for probes */
 186         int pos = -1;           /* Insertion position into new array */
 187
 188         if (WARN_ON(!tp_func->func))
 189                 return ERR_PTR(-EINVAL);
 190
 191         debug_print_probes(*funcs);
 192         old = *funcs;
 193         if (old) {
 194                 /* (N -> N+1), (N != 0, 1) probes */
 195                 for (iter_probes = 0; old[iter_probes].func; iter_probes++) {
 196                         if (old[iter_probes].func == tp_stub_func)
 197                                 continue;       /* Skip stub functions. */
 198                         if (old[iter_probes].func == tp_func->func &&
 199                             old[iter_probes].data == tp_func->data)
 200                                 return ERR_PTR(-EEXIST);
 201                         nr_probes++;
 202                 }
 203         }
 204         /* + 2 : one for new probe, one for NULL func */
 205         new = allocate_probes(nr_probes + 2);
 206         if (new == NULL)
 207                 return ERR_PTR(-ENOMEM);
 208         if (old) {
 209                 nr_probes = 0;
 210                 for (iter_probes = 0; old[iter_probes].func; iter_probes++) {
 211                         if (old[iter_probes].func == tp_stub_func)
 212                                 continue;
 213                         /* Insert before probes of lower priority */
 214                         if (pos < 0 && old[iter_probes].prio < prio)
 215                                 pos = nr_probes++;
 216                         new[nr_probes++] = old[iter_probes];
 217                 }
 218                 if (pos < 0)
 219                         pos = nr_probes++;
 220                 /* nr_probes now points to the end of the new array */
 221         } else {
 222                 pos = 0;
 223                 nr_probes = 1; /* must point at end of array */
 224         }
 225         new[pos] = *tp_func;
 226         new[nr_probes].func = NULL;
 227         *funcs = new;
 228         debug_print_probes(*funcs);
 229         return old;
 230 }
 231
 232 static void *func_remove(struct tracepoint_func **funcs,
 233                 struct tracepoint_func *tp_func)
 234 {
 235         int nr_probes = 0, nr_del = 0, i;
 236         struct tracepoint_func *old, *new;
 237
 238         old = *funcs;
 239
 240         if (!old)
 241                 return ERR_PTR(-ENOENT);
 242
 243         debug_print_probes(*funcs);
 244         /* (N -> M), (N > 1, M >= 0) probes */
 245         if (tp_func->func) {
 246                 for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
 247                         if ((old[nr_probes].func == tp_func->func &&
 248                              old[nr_probes].data == tp_func->data) ||
 249                             old[nr_probes].func == tp_stub_func)
 250                                 nr_del++;
 251                 }
 252         }
 253
 254         /*
 255          * If probe is NULL, then nr_probes = nr_del = 0, and then the
 256          * entire entry will be removed.
 257          */
 258         if (nr_probes - nr_del == 0) {
 259                 /* N -> 0, (N > 1) */
 260                 *funcs = NULL;
 261                 debug_print_probes(*funcs);
 262                 return old;
 263         } else {
 264                 int j = 0;
 265                 /* N -> M, (N > 1, M > 0) */
 266                 /* + 1 for NULL */
 267                 new = allocate_probes(nr_probes - nr_del + 1);
 268                 if (new) {
 269                         for (i = 0; old[i].func; i++) {
 270                                 if ((old[i].func != tp_func->func ||
 271                                      old[i].data != tp_func->data) &&
 272                                     old[i].func != tp_stub_func)
 273                                         new[j++] = old[i];
 274                         }
 275                         new[nr_probes - nr_del].func = NULL;
 276                         *funcs = new;
 277                 } else {
 278                         /*
 279                          * Failed to allocate, replace the old function
 280                          * with calls to tp_stub_func.
 281                          */
 282                         for (i = 0; old[i].func; i++) {
 283                                 if (old[i].func == tp_func->func &&
 284                                     old[i].data == tp_func->data)
 285                                         WRITE_ONCE(old[i].func, tp_stub_func);
 286                         }
 287                         *funcs = old;
 288                 }
 289         }
 290         debug_print_probes(*funcs);
 291         return old;
 292 }
 293
 294 /*
 295  * Count the number of functions (enum tp_func_state) in a tp_funcs array.
 296  */
 297 static enum tp_func_state nr_func_state(const struct tracepoint_func *tp_funcs)
 298 {
 299         if (!tp_funcs)
 300                 return TP_FUNC_0;
 301         if (!tp_funcs[1].func)
 302                 return TP_FUNC_1;
 303         if (!tp_funcs[2].func)
 304                 return TP_FUNC_2;
 305         return TP_FUNC_N;       /* 3 or more */
 306 }
 307
 308 static void tracepoint_update_call(struct tracepoint *tp, struct tracepoint_func *tp_funcs)
 309 {
 310         void *func = tp->iterator;
 311
 312         /* Synthetic events do not have static call sites */
 313         if (!tp->static_call_key)
 314                 return;
 315         if (nr_func_state(tp_funcs) == TP_FUNC_1)
 316                 func = tp_funcs[0].func;
 317         __static_call_update(tp->static_call_key, tp->static_call_tramp, func);
 318 }
 319
 320 /*
 321  * Add the probe function to a tracepoint.
 322  */
 323 static int tracepoint_add_func(struct tracepoint *tp,
 324                                struct tracepoint_func *func, int prio,
 325                                bool warn)
 326 {
 327         struct tracepoint_func *old, *tp_funcs;
 328         int ret;
 329
 330         if (tp->regfunc && !static_key_enabled(&tp->key)) {
 331                 ret = tp->regfunc();
 332                 if (ret < 0)
 333                         return ret;
 334         }
 335
 336         tp_funcs = rcu_dereference_protected(tp->funcs,
 337                         lockdep_is_held(&tracepoints_mutex));
 338         old = func_add(&tp_funcs, func, prio);
 339         if (IS_ERR(old)) {
 340                 WARN_ON_ONCE(warn && PTR_ERR(old) != -ENOMEM);
 341                 return PTR_ERR(old);
 342         }
 343
 344         /*
 345          * rcu_assign_pointer has as smp_store_release() which makes sure
 346          * that the new probe callbacks array is consistent before setting
 347          * a pointer to it.  This array is referenced by __DO_TRACE from
 348          * include/linux/tracepoint.h using rcu_dereference_sched().
 349          */
 350         switch (nr_func_state(tp_funcs)) {
 351         case TP_FUNC_1:         /* 0->1 */
 352                 /*
 353                  * Make sure new static func never uses old data after a
 354                  * 1->0->1 transition sequence.
 355                  */
 356                 tp_rcu_cond_sync(TP_TRANSITION_SYNC_1_0_1);
 357                 /* Set static call to first function */
 358                 tracepoint_update_call(tp, tp_funcs);
 359                 /* Both iterator and static call handle NULL tp->funcs */
 360                 rcu_assign_pointer(tp->funcs, tp_funcs);
 361                 static_key_enable(&tp->key);
 362                 break;
 363         case TP_FUNC_2:         /* 1->2 */
 364                 /* Set iterator static call */
 365                 tracepoint_update_call(tp, tp_funcs);
 366                 /*
 367                  * Iterator callback installed before updating tp->funcs.
 368                  * Requires ordering between RCU assign/dereference and
 369                  * static call update/call.
 370                  */
 371                 fallthrough;
 372         case TP_FUNC_N:         /* N->N+1 (N>1) */
 373                 rcu_assign_pointer(tp->funcs, tp_funcs);
 374                 /*
 375                  * Make sure static func never uses incorrect data after a
 376                  * N->...->2->1 (N>1) transition sequence.
 377                  */
 378                 if (tp_funcs[0].data != old[0].data)
 379                         tp_rcu_get_state(TP_TRANSITION_SYNC_N_2_1);
 380                 break;
 381         default:
 382                 WARN_ON_ONCE(1);
 383                 break;
 384         }
 385
 386         release_probes(old);
 387         return 0;
 388 }
 389
 390 /*
 391  * Remove a probe function from a tracepoint.
 392  * Note: only waiting an RCU period after setting elem->call to the empty
 393  * function insures that the original callback is not used anymore. This insured
 394  * by preempt_disable around the call site.
 395  */
 396 static int tracepoint_remove_func(struct tracepoint *tp,
 397                 struct tracepoint_func *func)
 398 {
 399         struct tracepoint_func *old, *tp_funcs;
 400
 401         tp_funcs = rcu_dereference_protected(tp->funcs,
 402                         lockdep_is_held(&tracepoints_mutex));
 403         old = func_remove(&tp_funcs, func);
 404         if (WARN_ON_ONCE(IS_ERR(old)))
 405                 return PTR_ERR(old);
 406
 407         if (tp_funcs == old)
 408                 /* Failed allocating new tp_funcs, replaced func with stub */
 409                 return 0;
 410
 411         switch (nr_func_state(tp_funcs)) {
 412         case TP_FUNC_0:         /* 1->0 */
 413                 /* Removed last function */
 414                 if (tp->unregfunc && static_key_enabled(&tp->key))
 415                         tp->unregfunc();
 416
 417                 static_key_disable(&tp->key);
 418                 /* Set iterator static call */
 419                 tracepoint_update_call(tp, tp_funcs);
 420                 /* Both iterator and static call handle NULL tp->funcs */
 421                 rcu_assign_pointer(tp->funcs, NULL);
 422                 /*
 423                  * Make sure new static func never uses old data after a
 424                  * 1->0->1 transition sequence.
 425                  */
 426                 tp_rcu_get_state(TP_TRANSITION_SYNC_1_0_1);
 427                 break;
 428         case TP_FUNC_1:         /* 2->1 */
 429                 rcu_assign_pointer(tp->funcs, tp_funcs);
 430                 /*
 431                  * Make sure static func never uses incorrect data after a
 432                  * N->...->2->1 (N>2) transition sequence. If the first
 433                  * element's data has changed, then force the synchronization
 434                  * to prevent current readers that have loaded the old data
 435                  * from calling the new function.
 436                  */
 437                 if (tp_funcs[0].data != old[0].data)
 438                         tp_rcu_get_state(TP_TRANSITION_SYNC_N_2_1);
 439                 tp_rcu_cond_sync(TP_TRANSITION_SYNC_N_2_1);
 440                 /* Set static call to first function */
 441                 tracepoint_update_call(tp, tp_funcs);
 442                 break;
 443         case TP_FUNC_2:         /* N->N-1 (N>2) */
 444                 fallthrough;
 445         case TP_FUNC_N:
 446                 rcu_assign_pointer(tp->funcs, tp_funcs);
 447                 /*
 448                  * Make sure static func never uses incorrect data after a
 449                  * N->...->2->1 (N>2) transition sequence.
 450                  */
 451                 if (tp_funcs[0].data != old[0].data)
 452                         tp_rcu_get_state(TP_TRANSITION_SYNC_N_2_1);
 453                 break;
 454         default:
 455                 WARN_ON_ONCE(1);
 456                 break;
 457         }
 458         release_probes(old);
 459         return 0;
 460 }
 461
 462 /**
 463  * tracepoint_probe_register_prio_may_exist -  Connect a probe to a tracepoint with priority
 464  * @tp: tracepoint
 465  * @probe: probe handler
 466  * @data: tracepoint data
 467  * @prio: priority of this function over other registered functions
 468  *
 469  * Same as tracepoint_probe_register_prio() except that it will not warn
 470  * if the tracepoint is already registered.
 471  */
 472 int tracepoint_probe_register_prio_may_exist(struct tracepoint *tp, void *probe,
 473                                              void *data, int prio)
 474 {
 475         struct tracepoint_func tp_func;
 476         int ret;
 477
 478         mutex_lock(&tracepoints_mutex);
 479         tp_func.func = probe;
 480         tp_func.data = data;
 481         tp_func.prio = prio;
 482         ret = tracepoint_add_func(tp, &tp_func, prio, false);
 483         mutex_unlock(&tracepoints_mutex);
 484         return ret;
 485 }
 486 EXPORT_SYMBOL_GPL(tracepoint_probe_register_prio_may_exist);
 487
 488 /**
 489  * tracepoint_probe_register_prio -  Connect a probe to a tracepoint with priority
 490  * @tp: tracepoint
 491  * @probe: probe handler
 492  * @data: tracepoint data
 493  * @prio: priority of this function over other registered functions
 494  *
 495  * Returns 0 if ok, error value on error.
 496  * Note: if @tp is within a module, the caller is responsible for
 497  * unregistering the probe before the module is gone. This can be
 498  * performed either with a tracepoint module going notifier, or from
 499  * within module exit functions.
 500  */
 501 int tracepoint_probe_register_prio(struct tracepoint *tp, void *probe,
 502                                    void *data, int prio)
 503 {
 504         struct tracepoint_func tp_func;
 505         int ret;
 506
 507         mutex_lock(&tracepoints_mutex);
 508         tp_func.func = probe;
 509         tp_func.data = data;
 510         tp_func.prio = prio;
 511         ret = tracepoint_add_func(tp, &tp_func, prio, true);
 512         mutex_unlock(&tracepoints_mutex);
 513         return ret;
 514 }
 515 EXPORT_SYMBOL_GPL(tracepoint_probe_register_prio);
 516
 517 /**
 518  * tracepoint_probe_register -  Connect a probe to a tracepoint
 519  * @tp: tracepoint
 520  * @probe: probe handler
 521  * @data: tracepoint data
 522  *
 523  * Returns 0 if ok, error value on error.
 524  * Note: if @tp is within a module, the caller is responsible for
 525  * unregistering the probe before the module is gone. This can be
 526  * performed either with a tracepoint module going notifier, or from
 527  * within module exit functions.
 528  */
 529 int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data)
 530 {
 531         return tracepoint_probe_register_prio(tp, probe, data, TRACEPOINT_DEFAULT_PRIO);
 532 }
 533 EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 534
 535 /**
 536  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
 537  * @tp: tracepoint
 538  * @probe: probe function pointer
 539  * @data: tracepoint data
 540  *
 541  * Returns 0 if ok, error value on error.
 542  */
 543 int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data)
 544 {
 545         struct tracepoint_func tp_func;
 546         int ret;
 547
 548         mutex_lock(&tracepoints_mutex);
 549         tp_func.func = probe;
 550         tp_func.data = data;
 551         ret = tracepoint_remove_func(tp, &tp_func);
 552         mutex_unlock(&tracepoints_mutex);
 553         return ret;
 554 }
 555 EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 556
 557 static void for_each_tracepoint_range(
 558                 tracepoint_ptr_t *begin, tracepoint_ptr_t *end,
 559                 void (*fct)(struct tracepoint *tp, void *priv),
 560                 void *priv)
 561 {
 562         tracepoint_ptr_t *iter;
 563
 564         if (!begin)
 565                 return;
 566         for (iter = begin; iter < end; iter++)
 567                 fct(tracepoint_ptr_deref(iter), priv);
 568 }
 569
 570 #ifdef CONFIG_MODULES
 571 bool trace_module_has_bad_taint(struct module *mod)
 572 {
 573         return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP) |
 574                                (1 << TAINT_UNSIGNED_MODULE));
 575 }
 576
 577 static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list);
 578
 579 /**
 580  * register_tracepoint_module_notifier - register tracepoint coming/going notifier
 581  * @nb: notifier block
 582  *
 583  * Notifiers registered with this function are called on module
 584  * coming/going with the tracepoint_module_list_mutex held.
 585  * The notifier block callback should expect a "struct tp_module" data
 586  * pointer.
 587  */
 588 int register_tracepoint_module_notifier(struct notifier_block *nb)
 589 {
 590         struct tp_module *tp_mod;
 591         int ret;
 592
 593         mutex_lock(&tracepoint_module_list_mutex);
 594         ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb);
 595         if (ret)
 596                 goto end;
 597         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
 598                 (void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod);
 599 end:
 600         mutex_unlock(&tracepoint_module_list_mutex);
 601         return ret;
 602 }
 603 EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier);
 604
 605 /**
 606  * unregister_tracepoint_module_notifier - unregister tracepoint coming/going notifier
 607  * @nb: notifier block
 608  *
 609  * The notifier block callback should expect a "struct tp_module" data
 610  * pointer.
 611  */
 612 int unregister_tracepoint_module_notifier(struct notifier_block *nb)
 613 {
 614         struct tp_module *tp_mod;
 615         int ret;
 616
 617         mutex_lock(&tracepoint_module_list_mutex);
 618         ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb);
 619         if (ret)
 620                 goto end;
 621         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
 622                 (void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod);
 623 end:
 624         mutex_unlock(&tracepoint_module_list_mutex);
 625         return ret;
 626
 627 }
 628 EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier);
 629
 630 /*
 631  * Ensure the tracer unregistered the module's probes before the module
 632  * teardown is performed. Prevents leaks of probe and data pointers.
 633  */
 634 static void tp_module_going_check_quiescent(struct tracepoint *tp, void *priv)
 635 {
 636         WARN_ON_ONCE(tp->funcs);
 637 }
 638
 639 static int tracepoint_module_coming(struct module *mod)
 640 {
 641         struct tp_module *tp_mod;
 642         int ret = 0;
 643
 644         if (!mod->num_tracepoints)
 645                 return 0;
 646
 647         /*
 648          * We skip modules that taint the kernel, especially those with different
 649          * module headers (for forced load), to make sure we don't cause a crash.
 650          * Staging, out-of-tree, and unsigned GPL modules are fine.
 651          */
 652         if (trace_module_has_bad_taint(mod))
 653                 return 0;
 654         mutex_lock(&tracepoint_module_list_mutex);
 655         tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
 656         if (!tp_mod) {
 657                 ret = -ENOMEM;
 658                 goto end;
 659         }
 660         tp_mod->mod = mod;
 661         list_add_tail(&tp_mod->list, &tracepoint_module_list);
 662         blocking_notifier_call_chain(&tracepoint_notify_list,
 663                         MODULE_STATE_COMING, tp_mod);
 664 end:
 665         mutex_unlock(&tracepoint_module_list_mutex);
 666         return ret;
 667 }
 668
 669 static void tracepoint_module_going(struct module *mod)
 670 {
 671         struct tp_module *tp_mod;
 672
 673         if (!mod->num_tracepoints)
 674                 return;
 675
 676         mutex_lock(&tracepoint_module_list_mutex);
 677         list_for_each_entry(tp_mod, &tracepoint_module_list, list) {
 678                 if (tp_mod->mod == mod) {
 679                         blocking_notifier_call_chain(&tracepoint_notify_list,
 680                                         MODULE_STATE_GOING, tp_mod);
 681                         list_del(&tp_mod->list);
 682                         kfree(tp_mod);
 683                         /*
 684                          * Called the going notifier before checking for
 685                          * quiescence.
 686                          */
 687                         for_each_tracepoint_range(mod->tracepoints_ptrs,
 688                                 mod->tracepoints_ptrs + mod->num_tracepoints,
 689                                 tp_module_going_check_quiescent, NULL);
 690                         break;
 691                 }
 692         }
 693         /*
 694          * In the case of modules that were tainted at "coming", we'll simply
 695          * walk through the list without finding it. We cannot use the "tainted"
 696          * flag on "going", in case a module taints the kernel only after being
 697          * loaded.
 698          */
 699         mutex_unlock(&tracepoint_module_list_mutex);
 700 }
 701
 702 static int tracepoint_module_notify(struct notifier_block *self,
 703                 unsigned long val, void *data)
 704 {
 705         struct module *mod = data;
 706         int ret = 0;
 707
 708         switch (val) {
 709         case MODULE_STATE_COMING:
 710                 ret = tracepoint_module_coming(mod);
 711                 break;
 712         case MODULE_STATE_LIVE:
 713                 break;
 714         case MODULE_STATE_GOING:
 715                 tracepoint_module_going(mod);
 716                 break;
 717         case MODULE_STATE_UNFORMED:
 718                 break;
 719         }
 720         return notifier_from_errno(ret);
 721 }
 722
 723 static struct notifier_block tracepoint_module_nb = {
 724         .notifier_call = tracepoint_module_notify,
 725         .priority = 0,
 726 };
 727
 728 static __init int init_tracepoints(void)
 729 {
 730         int ret;
 731
 732         ret = register_module_notifier(&tracepoint_module_nb);
 733         if (ret)
 734                 pr_warn("Failed to register tracepoint module enter notifier\n");
 735
 736         return ret;
 737 }
 738 __initcall(init_tracepoints);
 739 #endif /* CONFIG_MODULES */
 740
 741 /**
 742  * for_each_kernel_tracepoint - iteration on all kernel tracepoints
 743  * @fct: callback
 744  * @priv: private data
 745  */
 746 void for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv),
 747                 void *priv)
 748 {
 749         for_each_tracepoint_range(__start___tracepoints_ptrs,
 750                 __stop___tracepoints_ptrs, fct, priv);
 751 }
 752 EXPORT_SYMBOL_GPL(for_each_kernel_tracepoint);
 753
 754 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 755
 756 /* NB: reg/unreg are called while guarded with the tracepoints_mutex */
 757 static int sys_tracepoint_refcount;
 758
 759 int syscall_regfunc(void)
 760 {
 761         struct task_struct *p, *t;
 762
 763         if (!sys_tracepoint_refcount) {
 764                 read_lock(&tasklist_lock);
 765                 for_each_process_thread(p, t) {
 766                         set_task_syscall_work(t, SYSCALL_TRACEPOINT);
 767                 }
 768                 read_unlock(&tasklist_lock);
 769         }
 770         sys_tracepoint_refcount++;
 771
 772         return 0;
 773 }
 774
 775 void syscall_unregfunc(void)
 776 {
 777         struct task_struct *p, *t;
 778
 779         sys_tracepoint_refcount--;
 780         if (!sys_tracepoint_refcount) {
 781                 read_lock(&tasklist_lock);
 782                 for_each_process_thread(p, t) {
 783                         clear_task_syscall_work(t, SYSCALL_TRACEPOINT);
 784                 }
 785                 read_unlock(&tasklist_lock);
 786         }
 787 }
 788 #endif