~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/tracepoint.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp