kernel/gcov/base.c

   1 /*
   2  *  This code maintains a list of active profiling data structures.
   3  *
   4  *    Copyright IBM Corp. 2009
   5  *    Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
   6  *
   7  *    Uses gcc-internal data definitions.
   8  *    Based on the gcov-kernel patch by:
   9  *               Hubertus Franke <frankeh@us.ibm.com>
  10  *               Nigel Hinds <nhinds@us.ibm.com>
  11  *               Rajan Ravindran <rajancr@us.ibm.com>
  12  *               Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
  13  *               Paul Larson
  14  */
  15
  16 #define pr_fmt(fmt)     "gcov: " fmt
  17
  18 #include <linux/init.h>
  19 #include <linux/module.h>
  20 #include <linux/mutex.h>
  21 #include "gcov.h"
  22
  23 static int gcov_events_enabled;
  24 static DEFINE_MUTEX(gcov_lock);
  25
  26 /*
  27  * __gcov_init is called by gcc-generated constructor code for each object
  28  * file compiled with -fprofile-arcs.
  29  */
  30 void __gcov_init(struct gcov_info *info)
  31 {
  32         static unsigned int gcov_version;
  33
  34         mutex_lock(&gcov_lock);
  35         if (gcov_version == 0) {
  36                 gcov_version = gcov_info_version(info);
  37                 /*
  38                  * Printing gcc's version magic may prove useful for debugging
  39                  * incompatibility reports.
  40                  */
  41                 pr_info("version magic: 0x%x\n", gcov_version);
  42         }
  43         /*
  44          * Add new profiling data structure to list and inform event
  45          * listener.
  46          */
  47         gcov_info_link(info);
  48         if (gcov_events_enabled)
  49                 gcov_event(GCOV_ADD, info);
  50         mutex_unlock(&gcov_lock);
  51 }
  52 EXPORT_SYMBOL(__gcov_init);
  53
  54 /*
  55  * These functions may be referenced by gcc-generated profiling code but serve
  56  * no function for kernel profiling.
  57  */
  58 void __gcov_flush(void)
  59 {
  60         /* Unused. */
  61 }
  62 EXPORT_SYMBOL(__gcov_flush);
  63
  64 void __gcov_merge_add(gcov_type *counters, unsigned int n_counters)
  65 {
  66         /* Unused. */
  67 }
  68 EXPORT_SYMBOL(__gcov_merge_add);
  69
  70 void __gcov_merge_single(gcov_type *counters, unsigned int n_counters)
  71 {
  72         /* Unused. */
  73 }
  74 EXPORT_SYMBOL(__gcov_merge_single);
  75
  76 void __gcov_merge_delta(gcov_type *counters, unsigned int n_counters)
  77 {
  78         /* Unused. */
  79 }
  80 EXPORT_SYMBOL(__gcov_merge_delta);
  81
  82 /**
  83  * gcov_enable_events - enable event reporting through gcov_event()
  84  *
  85  * Turn on reporting of profiling data load/unload-events through the
  86  * gcov_event() callback. Also replay all previous events once. This function
  87  * is needed because some events are potentially generated too early for the
  88  * callback implementation to handle them initially.
  89  */
  90 void gcov_enable_events(void)
  91 {
  92         struct gcov_info *info = NULL;
  93
  94         mutex_lock(&gcov_lock);
  95         gcov_events_enabled = 1;
  96
  97         /* Perform event callback for previously registered entries. */
  98         while ((info = gcov_info_next(info)))
  99                 gcov_event(GCOV_ADD, info);
 100
 101         mutex_unlock(&gcov_lock);
 102 }
 103
 104 #ifdef CONFIG_MODULES
 105 static inline int within(void *addr, void *start, unsigned long size)
 106 {
 107         return ((addr >= start) && (addr < start + size));
 108 }
 109
 110 /* Update list and generate events when modules are unloaded. */
 111 static int gcov_module_notifier(struct notifier_block *nb, unsigned long event,
 112                                 void *data)
 113 {
 114         struct module *mod = data;
 115         struct gcov_info *info = NULL;
 116         struct gcov_info *prev = NULL;
 117
 118         if (event != MODULE_STATE_GOING)
 119                 return NOTIFY_OK;
 120         mutex_lock(&gcov_lock);
 121
 122         /* Remove entries located in module from linked list. */
 123         while ((info = gcov_info_next(info))) {
 124                 if (within(info, mod->module_core, mod->core_size)) {
 125                         gcov_info_unlink(prev, info);
 126                         if (gcov_events_enabled)
 127                                 gcov_event(GCOV_REMOVE, info);
 128                 } else
 129                         prev = info;
 130         }
 131
 132         mutex_unlock(&gcov_lock);
 133
 134         return NOTIFY_OK;
 135 }
 136
 137 static struct notifier_block gcov_nb = {
 138         .notifier_call  = gcov_module_notifier,
 139 };
 140
 141 static int __init gcov_init(void)
 142 {
 143         return register_module_notifier(&gcov_nb);
 144 }
 145 device_initcall(gcov_init);
 146 #endif /* CONFIG_MODULES */