LCOV - code coverage report
Current view: top level - kernel - tracepoint.c (source / functions) Hit Total Coverage
Test: Real Lines: 25 178 14.0 %
Date: 2020-10-17 15:46:43 Functions: 1 23 4.3 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :            : extern tracepoint_ptr_t __start___tracepoints_ptrs[];
      19                 :            : extern tracepoint_ptr_t __stop___tracepoints_ptrs[];
      20                 :            : 
      21                 :            : DEFINE_SRCU(tracepoint_srcu);
      22                 :            : EXPORT_SYMBOL_GPL(tracepoint_srcu);
      23                 :            : 
      24                 :            : /* Set to 1 to enable tracepoint debug output */
      25                 :            : static const int tracepoint_debug;
      26                 :            : 
      27                 :            : #ifdef CONFIG_MODULES
      28                 :            : /*
      29                 :            :  * Tracepoint module list mutex protects the local module list.
      30                 :            :  */
      31                 :            : static DEFINE_MUTEX(tracepoint_module_list_mutex);
      32                 :            : 
      33                 :            : /* Local list of struct tp_module */
      34                 :            : static LIST_HEAD(tracepoint_module_list);
      35                 :            : #endif /* CONFIG_MODULES */
      36                 :            : 
      37                 :            : /*
      38                 :            :  * tracepoints_mutex protects the builtin and module tracepoints.
      39                 :            :  * tracepoints_mutex nests inside tracepoint_module_list_mutex.
      40                 :            :  */
      41                 :            : static DEFINE_MUTEX(tracepoints_mutex);
      42                 :            : 
      43                 :            : static struct rcu_head *early_probes;
      44                 :            : static bool ok_to_free_tracepoints;
      45                 :            : 
      46                 :            : /*
      47                 :            :  * Note about RCU :
      48                 :            :  * It is used to delay the free of multiple probes array until a quiescent
      49                 :            :  * state is reached.
      50                 :            :  */
      51                 :            : struct tp_probes {
      52                 :            :         struct rcu_head rcu;
      53                 :            :         struct tracepoint_func probes[0];
      54                 :            : };
      55                 :            : 
      56                 :          0 : static inline void *allocate_probes(int count)
      57                 :            : {
      58                 :          0 :         struct tp_probes *p  = kmalloc(struct_size(p, probes, count),
      59                 :            :                                        GFP_KERNEL);
      60                 :          0 :         return p == NULL ? NULL : p->probes;
      61                 :            : }
      62                 :            : 
      63                 :          0 : static void srcu_free_old_probes(struct rcu_head *head)
      64                 :            : {
      65                 :          0 :         kfree(container_of(head, struct tp_probes, rcu));
      66                 :          0 : }
      67                 :            : 
      68                 :          0 : static void rcu_free_old_probes(struct rcu_head *head)
      69                 :            : {
      70                 :          0 :         call_srcu(&tracepoint_srcu, head, srcu_free_old_probes);
      71                 :          0 : }
      72                 :            : 
      73                 :          3 : static __init int release_early_probes(void)
      74                 :            : {
      75                 :            :         struct rcu_head *tmp;
      76                 :            : 
      77                 :          3 :         ok_to_free_tracepoints = true;
      78                 :            : 
      79                 :          3 :         while (early_probes) {
      80                 :            :                 tmp = early_probes;
      81                 :          0 :                 early_probes = tmp->next;
      82                 :          0 :                 call_rcu(tmp, rcu_free_old_probes);
      83                 :            :         }
      84                 :            : 
      85                 :          3 :         return 0;
      86                 :            : }
      87                 :            : 
      88                 :            : /* SRCU is initialized at core_initcall */
      89                 :            : postcore_initcall(release_early_probes);
      90                 :            : 
      91                 :          0 : static inline void release_probes(struct tracepoint_func *old)
      92                 :            : {
      93                 :          0 :         if (old) {
      94                 :            :                 struct tp_probes *tp_probes = container_of(old,
      95                 :            :                         struct tp_probes, probes[0]);
      96                 :            : 
      97                 :            :                 /*
      98                 :            :                  * We can't free probes if SRCU is not initialized yet.
      99                 :            :                  * Postpone the freeing till after SRCU is initialized.
     100                 :            :                  */
     101                 :          0 :                 if (unlikely(!ok_to_free_tracepoints)) {
     102                 :          0 :                         tp_probes->rcu.next = early_probes;
     103                 :          0 :                         early_probes = &tp_probes->rcu;
     104                 :          0 :                         return;
     105                 :            :                 }
     106                 :            : 
     107                 :            :                 /*
     108                 :            :                  * Tracepoint probes are protected by both sched RCU and SRCU,
     109                 :            :                  * by calling the SRCU callback in the sched RCU callback we
     110                 :            :                  * cover both cases. So let us chain the SRCU and sched RCU
     111                 :            :                  * callbacks to wait for both grace periods.
     112                 :            :                  */
     113                 :          0 :                 call_rcu(&tp_probes->rcu, rcu_free_old_probes);
     114                 :            :         }
     115                 :            : }
     116                 :            : 
     117                 :            : static void debug_print_probes(struct tracepoint_func *funcs)
     118                 :            : {
     119                 :            :         int i;
     120                 :            : 
     121                 :            :         if (!tracepoint_debug || !funcs)
     122                 :            :                 return;
     123                 :            : 
     124                 :            :         for (i = 0; funcs[i].func; i++)
     125                 :            :                 printk(KERN_DEBUG "Probe %d : %p\n", i, funcs[i].func);
     126                 :            : }
     127                 :            : 
     128                 :            : static struct tracepoint_func *
     129                 :          0 : func_add(struct tracepoint_func **funcs, struct tracepoint_func *tp_func,
     130                 :            :          int prio)
     131                 :            : {
     132                 :            :         struct tracepoint_func *old, *new;
     133                 :            :         int nr_probes = 0;
     134                 :            :         int pos = -1;
     135                 :            : 
     136                 :          0 :         if (WARN_ON(!tp_func->func))
     137                 :            :                 return ERR_PTR(-EINVAL);
     138                 :            : 
     139                 :            :         debug_print_probes(*funcs);
     140                 :          0 :         old = *funcs;
     141                 :          0 :         if (old) {
     142                 :            :                 /* (N -> N+1), (N != 0, 1) probes */
     143                 :          0 :                 for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
     144                 :            :                         /* Insert before probes of lower priority */
     145                 :          0 :                         if (pos < 0 && old[nr_probes].prio < prio)
     146                 :            :                                 pos = nr_probes;
     147                 :          0 :                         if (old[nr_probes].func == tp_func->func &&
     148                 :          0 :                             old[nr_probes].data == tp_func->data)
     149                 :            :                                 return ERR_PTR(-EEXIST);
     150                 :            :                 }
     151                 :            :         }
     152                 :            :         /* + 2 : one for new probe, one for NULL func */
     153                 :          0 :         new = allocate_probes(nr_probes + 2);
     154                 :          0 :         if (new == NULL)
     155                 :            :                 return ERR_PTR(-ENOMEM);
     156                 :          0 :         if (old) {
     157                 :          0 :                 if (pos < 0) {
     158                 :            :                         pos = nr_probes;
     159                 :          0 :                         memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
     160                 :            :                 } else {
     161                 :            :                         /* Copy higher priority probes ahead of the new probe */
     162                 :          0 :                         memcpy(new, old, pos * sizeof(struct tracepoint_func));
     163                 :            :                         /* Copy the rest after it. */
     164                 :          0 :                         memcpy(new + pos + 1, old + pos,
     165                 :          0 :                                (nr_probes - pos) * sizeof(struct tracepoint_func));
     166                 :            :                 }
     167                 :            :         } else
     168                 :            :                 pos = 0;
     169                 :          0 :         new[pos] = *tp_func;
     170                 :          0 :         new[nr_probes + 1].func = NULL;
     171                 :          0 :         *funcs = new;
     172                 :            :         debug_print_probes(*funcs);
     173                 :          0 :         return old;
     174                 :            : }
     175                 :            : 
     176                 :          0 : static void *func_remove(struct tracepoint_func **funcs,
     177                 :            :                 struct tracepoint_func *tp_func)
     178                 :            : {
     179                 :            :         int nr_probes = 0, nr_del = 0, i;
     180                 :            :         struct tracepoint_func *old, *new;
     181                 :            : 
     182                 :          0 :         old = *funcs;
     183                 :            : 
     184                 :          0 :         if (!old)
     185                 :            :                 return ERR_PTR(-ENOENT);
     186                 :            : 
     187                 :            :         debug_print_probes(*funcs);
     188                 :            :         /* (N -> M), (N > 1, M >= 0) probes */
     189                 :          0 :         if (tp_func->func) {
     190                 :          0 :                 for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
     191                 :          0 :                         if (old[nr_probes].func == tp_func->func &&
     192                 :          0 :                              old[nr_probes].data == tp_func->data)
     193                 :          0 :                                 nr_del++;
     194                 :            :                 }
     195                 :            :         }
     196                 :            : 
     197                 :            :         /*
     198                 :            :          * If probe is NULL, then nr_probes = nr_del = 0, and then the
     199                 :            :          * entire entry will be removed.
     200                 :            :          */
     201                 :          0 :         if (nr_probes - nr_del == 0) {
     202                 :            :                 /* N -> 0, (N > 1) */
     203                 :          0 :                 *funcs = NULL;
     204                 :            :                 debug_print_probes(*funcs);
     205                 :          0 :                 return old;
     206                 :            :         } else {
     207                 :            :                 int j = 0;
     208                 :            :                 /* N -> M, (N > 1, M > 0) */
     209                 :            :                 /* + 1 for NULL */
     210                 :          0 :                 new = allocate_probes(nr_probes - nr_del + 1);
     211                 :          0 :                 if (new == NULL)
     212                 :            :                         return ERR_PTR(-ENOMEM);
     213                 :          0 :                 for (i = 0; old[i].func; i++)
     214                 :          0 :                         if (old[i].func != tp_func->func
     215                 :          0 :                                         || old[i].data != tp_func->data)
     216                 :          0 :                                 new[j++] = old[i];
     217                 :          0 :                 new[nr_probes - nr_del].func = NULL;
     218                 :          0 :                 *funcs = new;
     219                 :            :         }
     220                 :            :         debug_print_probes(*funcs);
     221                 :          0 :         return old;
     222                 :            : }
     223                 :            : 
     224                 :            : /*
     225                 :            :  * Add the probe function to a tracepoint.
     226                 :            :  */
     227                 :          0 : static int tracepoint_add_func(struct tracepoint *tp,
     228                 :            :                                struct tracepoint_func *func, int prio)
     229                 :            : {
     230                 :            :         struct tracepoint_func *old, *tp_funcs;
     231                 :            :         int ret;
     232                 :            : 
     233                 :          0 :         if (tp->regfunc && !static_key_enabled(&tp->key)) {
     234                 :          0 :                 ret = tp->regfunc();
     235                 :          0 :                 if (ret < 0)
     236                 :            :                         return ret;
     237                 :            :         }
     238                 :            : 
     239                 :          0 :         tp_funcs = rcu_dereference_protected(tp->funcs,
     240                 :            :                         lockdep_is_held(&tracepoints_mutex));
     241                 :          0 :         old = func_add(&tp_funcs, func, prio);
     242                 :          0 :         if (IS_ERR(old)) {
     243                 :          0 :                 WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
     244                 :          0 :                 return PTR_ERR(old);
     245                 :            :         }
     246                 :            : 
     247                 :            :         /*
     248                 :            :          * rcu_assign_pointer has as smp_store_release() which makes sure
     249                 :            :          * that the new probe callbacks array is consistent before setting
     250                 :            :          * a pointer to it.  This array is referenced by __DO_TRACE from
     251                 :            :          * include/linux/tracepoint.h using rcu_dereference_sched().
     252                 :            :          */
     253                 :          0 :         rcu_assign_pointer(tp->funcs, tp_funcs);
     254                 :          0 :         if (!static_key_enabled(&tp->key))
     255                 :          0 :                 static_key_slow_inc(&tp->key);
     256                 :          0 :         release_probes(old);
     257                 :          0 :         return 0;
     258                 :            : }
     259                 :            : 
     260                 :            : /*
     261                 :            :  * Remove a probe function from a tracepoint.
     262                 :            :  * Note: only waiting an RCU period after setting elem->call to the empty
     263                 :            :  * function insures that the original callback is not used anymore. This insured
     264                 :            :  * by preempt_disable around the call site.
     265                 :            :  */
     266                 :          0 : static int tracepoint_remove_func(struct tracepoint *tp,
     267                 :            :                 struct tracepoint_func *func)
     268                 :            : {
     269                 :            :         struct tracepoint_func *old, *tp_funcs;
     270                 :            : 
     271                 :          0 :         tp_funcs = rcu_dereference_protected(tp->funcs,
     272                 :            :                         lockdep_is_held(&tracepoints_mutex));
     273                 :          0 :         old = func_remove(&tp_funcs, func);
     274                 :          0 :         if (IS_ERR(old)) {
     275                 :          0 :                 WARN_ON_ONCE(PTR_ERR(old) != -ENOMEM);
     276                 :          0 :                 return PTR_ERR(old);
     277                 :            :         }
     278                 :            : 
     279                 :          0 :         if (!tp_funcs) {
     280                 :            :                 /* Removed last function */
     281                 :          0 :                 if (tp->unregfunc && static_key_enabled(&tp->key))
     282                 :          0 :                         tp->unregfunc();
     283                 :            : 
     284                 :          0 :                 if (static_key_enabled(&tp->key))
     285                 :          0 :                         static_key_slow_dec(&tp->key);
     286                 :            :         }
     287                 :          0 :         rcu_assign_pointer(tp->funcs, tp_funcs);
     288                 :          0 :         release_probes(old);
     289                 :          0 :         return 0;
     290                 :            : }
     291                 :            : 
     292                 :            : /**
     293                 :            :  * tracepoint_probe_register_prio -  Connect a probe to a tracepoint with priority
     294                 :            :  * @tp: tracepoint
     295                 :            :  * @probe: probe handler
     296                 :            :  * @data: tracepoint data
     297                 :            :  * @prio: priority of this function over other registered functions
     298                 :            :  *
     299                 :            :  * Returns 0 if ok, error value on error.
     300                 :            :  * Note: if @tp is within a module, the caller is responsible for
     301                 :            :  * unregistering the probe before the module is gone. This can be
     302                 :            :  * performed either with a tracepoint module going notifier, or from
     303                 :            :  * within module exit functions.
     304                 :            :  */
     305                 :          0 : int tracepoint_probe_register_prio(struct tracepoint *tp, void *probe,
     306                 :            :                                    void *data, int prio)
     307                 :            : {
     308                 :            :         struct tracepoint_func tp_func;
     309                 :            :         int ret;
     310                 :            : 
     311                 :          0 :         mutex_lock(&tracepoints_mutex);
     312                 :          0 :         tp_func.func = probe;
     313                 :          0 :         tp_func.data = data;
     314                 :          0 :         tp_func.prio = prio;
     315                 :          0 :         ret = tracepoint_add_func(tp, &tp_func, prio);
     316                 :          0 :         mutex_unlock(&tracepoints_mutex);
     317                 :          0 :         return ret;
     318                 :            : }
     319                 :            : EXPORT_SYMBOL_GPL(tracepoint_probe_register_prio);
     320                 :            : 
     321                 :            : /**
     322                 :            :  * tracepoint_probe_register -  Connect a probe to a tracepoint
     323                 :            :  * @tp: tracepoint
     324                 :            :  * @probe: probe handler
     325                 :            :  * @data: tracepoint data
     326                 :            :  *
     327                 :            :  * Returns 0 if ok, error value on error.
     328                 :            :  * Note: if @tp is within a module, the caller is responsible for
     329                 :            :  * unregistering the probe before the module is gone. This can be
     330                 :            :  * performed either with a tracepoint module going notifier, or from
     331                 :            :  * within module exit functions.
     332                 :            :  */
     333                 :          0 : int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data)
     334                 :            : {
     335                 :          0 :         return tracepoint_probe_register_prio(tp, probe, data, TRACEPOINT_DEFAULT_PRIO);
     336                 :            : }
     337                 :            : EXPORT_SYMBOL_GPL(tracepoint_probe_register);
     338                 :            : 
     339                 :            : /**
     340                 :            :  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
     341                 :            :  * @tp: tracepoint
     342                 :            :  * @probe: probe function pointer
     343                 :            :  * @data: tracepoint data
     344                 :            :  *
     345                 :            :  * Returns 0 if ok, error value on error.
     346                 :            :  */
     347                 :          0 : int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data)
     348                 :            : {
     349                 :            :         struct tracepoint_func tp_func;
     350                 :            :         int ret;
     351                 :            : 
     352                 :          0 :         mutex_lock(&tracepoints_mutex);
     353                 :          0 :         tp_func.func = probe;
     354                 :          0 :         tp_func.data = data;
     355                 :          0 :         ret = tracepoint_remove_func(tp, &tp_func);
     356                 :          0 :         mutex_unlock(&tracepoints_mutex);
     357                 :          0 :         return ret;
     358                 :            : }
     359                 :            : EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
     360                 :            : 
     361                 :            : static void for_each_tracepoint_range(
     362                 :            :                 tracepoint_ptr_t *begin, tracepoint_ptr_t *end,
     363                 :            :                 void (*fct)(struct tracepoint *tp, void *priv),
     364                 :            :                 void *priv)
     365                 :            : {
     366                 :            :         tracepoint_ptr_t *iter;
     367                 :            : 
     368                 :          0 :         if (!begin)
     369                 :            :                 return;
     370                 :          0 :         for (iter = begin; iter < end; iter++)
     371                 :          0 :                 fct(tracepoint_ptr_deref(iter), priv);
     372                 :            : }
     373                 :            : 
     374                 :            : #ifdef CONFIG_MODULES
     375                 :          3 : bool trace_module_has_bad_taint(struct module *mod)
     376                 :            : {
     377                 :          3 :         return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP) |
     378                 :            :                                (1 << TAINT_UNSIGNED_MODULE));
     379                 :            : }
     380                 :            : 
     381                 :            : static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list);
     382                 :            : 
     383                 :            : /**
     384                 :            :  * register_tracepoint_notifier - register tracepoint coming/going notifier
     385                 :            :  * @nb: notifier block
     386                 :            :  *
     387                 :            :  * Notifiers registered with this function are called on module
     388                 :            :  * coming/going with the tracepoint_module_list_mutex held.
     389                 :            :  * The notifier block callback should expect a "struct tp_module" data
     390                 :            :  * pointer.
     391                 :            :  */
     392                 :          0 : int register_tracepoint_module_notifier(struct notifier_block *nb)
     393                 :            : {
     394                 :            :         struct tp_module *tp_mod;
     395                 :            :         int ret;
     396                 :            : 
     397                 :          0 :         mutex_lock(&tracepoint_module_list_mutex);
     398                 :          0 :         ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb);
     399                 :          0 :         if (ret)
     400                 :            :                 goto end;
     401                 :          0 :         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
     402                 :          0 :                 (void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod);
     403                 :            : end:
     404                 :          0 :         mutex_unlock(&tracepoint_module_list_mutex);
     405                 :          0 :         return ret;
     406                 :            : }
     407                 :            : EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier);
     408                 :            : 
     409                 :            : /**
     410                 :            :  * unregister_tracepoint_notifier - unregister tracepoint coming/going notifier
     411                 :            :  * @nb: notifier block
     412                 :            :  *
     413                 :            :  * The notifier block callback should expect a "struct tp_module" data
     414                 :            :  * pointer.
     415                 :            :  */
     416                 :          0 : int unregister_tracepoint_module_notifier(struct notifier_block *nb)
     417                 :            : {
     418                 :            :         struct tp_module *tp_mod;
     419                 :            :         int ret;
     420                 :            : 
     421                 :          0 :         mutex_lock(&tracepoint_module_list_mutex);
     422                 :          0 :         ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb);
     423                 :          0 :         if (ret)
     424                 :            :                 goto end;
     425                 :          0 :         list_for_each_entry(tp_mod, &tracepoint_module_list, list)
     426                 :          0 :                 (void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod);
     427                 :            : end:
     428                 :          0 :         mutex_unlock(&tracepoint_module_list_mutex);
     429                 :          0 :         return ret;
     430                 :            : 
     431                 :            : }
     432                 :            : EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier);
     433                 :            : 
     434                 :            : /*
     435                 :            :  * Ensure the tracer unregistered the module's probes before the module
     436                 :            :  * teardown is performed. Prevents leaks of probe and data pointers.
     437                 :            :  */
     438                 :          0 : static void tp_module_going_check_quiescent(struct tracepoint *tp, void *priv)
     439                 :            : {
     440                 :          0 :         WARN_ON_ONCE(tp->funcs);
     441                 :          0 : }
     442                 :            : 
     443                 :          3 : static int tracepoint_module_coming(struct module *mod)
     444                 :            : {
     445                 :            :         struct tp_module *tp_mod;
     446                 :            :         int ret = 0;
     447                 :            : 
     448                 :          3 :         if (!mod->num_tracepoints)
     449                 :            :                 return 0;
     450                 :            : 
     451                 :            :         /*
     452                 :            :          * We skip modules that taint the kernel, especially those with different
     453                 :            :          * module headers (for forced load), to make sure we don't cause a crash.
     454                 :            :          * Staging, out-of-tree, and unsigned GPL modules are fine.
     455                 :            :          */
     456                 :          3 :         if (trace_module_has_bad_taint(mod))
     457                 :            :                 return 0;
     458                 :          3 :         mutex_lock(&tracepoint_module_list_mutex);
     459                 :            :         tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
     460                 :          3 :         if (!tp_mod) {
     461                 :            :                 ret = -ENOMEM;
     462                 :            :                 goto end;
     463                 :            :         }
     464                 :          3 :         tp_mod->mod = mod;
     465                 :          3 :         list_add_tail(&tp_mod->list, &tracepoint_module_list);
     466                 :          3 :         blocking_notifier_call_chain(&tracepoint_notify_list,
     467                 :            :                         MODULE_STATE_COMING, tp_mod);
     468                 :            : end:
     469                 :          3 :         mutex_unlock(&tracepoint_module_list_mutex);
     470                 :          3 :         return ret;
     471                 :            : }
     472                 :            : 
     473                 :          0 : static void tracepoint_module_going(struct module *mod)
     474                 :            : {
     475                 :            :         struct tp_module *tp_mod;
     476                 :            : 
     477                 :          0 :         if (!mod->num_tracepoints)
     478                 :          0 :                 return;
     479                 :            : 
     480                 :          0 :         mutex_lock(&tracepoint_module_list_mutex);
     481                 :          0 :         list_for_each_entry(tp_mod, &tracepoint_module_list, list) {
     482                 :          0 :                 if (tp_mod->mod == mod) {
     483                 :          0 :                         blocking_notifier_call_chain(&tracepoint_notify_list,
     484                 :            :                                         MODULE_STATE_GOING, tp_mod);
     485                 :            :                         list_del(&tp_mod->list);
     486                 :          0 :                         kfree(tp_mod);
     487                 :            :                         /*
     488                 :            :                          * Called the going notifier before checking for
     489                 :            :                          * quiescence.
     490                 :            :                          */
     491                 :          0 :                         for_each_tracepoint_range(mod->tracepoints_ptrs,
     492                 :          0 :                                 mod->tracepoints_ptrs + mod->num_tracepoints,
     493                 :            :                                 tp_module_going_check_quiescent, NULL);
     494                 :            :                         break;
     495                 :            :                 }
     496                 :            :         }
     497                 :            :         /*
     498                 :            :          * In the case of modules that were tainted at "coming", we'll simply
     499                 :            :          * walk through the list without finding it. We cannot use the "tainted"
     500                 :            :          * flag on "going", in case a module taints the kernel only after being
     501                 :            :          * loaded.
     502                 :            :          */
     503                 :          0 :         mutex_unlock(&tracepoint_module_list_mutex);
     504                 :            : }
     505                 :            : 
     506                 :          3 : static int tracepoint_module_notify(struct notifier_block *self,
     507                 :            :                 unsigned long val, void *data)
     508                 :            : {
     509                 :            :         struct module *mod = data;
     510                 :            :         int ret = 0;
     511                 :            : 
     512                 :          3 :         switch (val) {
     513                 :            :         case MODULE_STATE_COMING:
     514                 :          3 :                 ret = tracepoint_module_coming(mod);
     515                 :          3 :                 break;
     516                 :            :         case MODULE_STATE_LIVE:
     517                 :            :                 break;
     518                 :            :         case MODULE_STATE_GOING:
     519                 :          0 :                 tracepoint_module_going(mod);
     520                 :          0 :                 break;
     521                 :            :         case MODULE_STATE_UNFORMED:
     522                 :            :                 break;
     523                 :            :         }
     524                 :          3 :         return ret;
     525                 :            : }
     526                 :            : 
     527                 :            : static struct notifier_block tracepoint_module_nb = {
     528                 :            :         .notifier_call = tracepoint_module_notify,
     529                 :            :         .priority = 0,
     530                 :            : };
     531                 :            : 
     532                 :          3 : static __init int init_tracepoints(void)
     533                 :            : {
     534                 :            :         int ret;
     535                 :            : 
     536                 :          3 :         ret = register_module_notifier(&tracepoint_module_nb);
     537                 :          3 :         if (ret)
     538                 :          0 :                 pr_warn("Failed to register tracepoint module enter notifier\n");
     539                 :            : 
     540                 :          3 :         return ret;
     541                 :            : }
     542                 :            : __initcall(init_tracepoints);
     543                 :            : #endif /* CONFIG_MODULES */
     544                 :            : 
     545                 :            : /**
     546                 :            :  * for_each_kernel_tracepoint - iteration on all kernel tracepoints
     547                 :            :  * @fct: callback
     548                 :            :  * @priv: private data
     549                 :            :  */
     550                 :          0 : void for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv),
     551                 :            :                 void *priv)
     552                 :            : {
     553                 :            :         for_each_tracepoint_range(__start___tracepoints_ptrs,
     554                 :            :                 __stop___tracepoints_ptrs, fct, priv);
     555                 :          0 : }
     556                 :            : EXPORT_SYMBOL_GPL(for_each_kernel_tracepoint);
     557                 :            : 
     558                 :            : #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
     559                 :            : 
     560                 :            : /* NB: reg/unreg are called while guarded with the tracepoints_mutex */
     561                 :            : static int sys_tracepoint_refcount;
     562                 :            : 
     563                 :          0 : int syscall_regfunc(void)
     564                 :            : {
     565                 :            :         struct task_struct *p, *t;
     566                 :            : 
     567                 :          0 :         if (!sys_tracepoint_refcount) {
     568                 :          0 :                 read_lock(&tasklist_lock);
     569                 :          0 :                 for_each_process_thread(p, t) {
     570                 :            :                         set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
     571                 :            :                 }
     572                 :            :                 read_unlock(&tasklist_lock);
     573                 :            :         }
     574                 :          0 :         sys_tracepoint_refcount++;
     575                 :            : 
     576                 :          0 :         return 0;
     577                 :            : }
     578                 :            : 
     579                 :          0 : void syscall_unregfunc(void)
     580                 :            : {
     581                 :            :         struct task_struct *p, *t;
     582                 :            : 
     583                 :          0 :         sys_tracepoint_refcount--;
     584                 :          0 :         if (!sys_tracepoint_refcount) {
     585                 :          0 :                 read_lock(&tasklist_lock);
     586                 :          0 :                 for_each_process_thread(p, t) {
     587                 :            :                         clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
     588                 :            :                 }
     589                 :            :                 read_unlock(&tasklist_lock);
     590                 :            :         }
     591                 :          0 : }
     592                 :            : #endif
    

Generated by: LCOV version 1.14