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

TOMOYO Linux Cross Reference
Linux/kernel/tracepoint.c

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

~ [ 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