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 void __gcov_merge_ior(gcov_type *counters, unsigned int n_counters)
  83 {
  84         /* Unused. */
  85 }
  86 EXPORT_SYMBOL(__gcov_merge_ior);
  87
  88 void __gcov_merge_time_profile(gcov_type *counters, unsigned int n_counters)
  89 {
  90         /* Unused. */
  91 }
  92 EXPORT_SYMBOL(__gcov_merge_time_profile);
  93
  94 void __gcov_merge_icall_topn(gcov_type *counters, unsigned int n_counters)
  95 {
  96         /* Unused. */
  97 }
  98 EXPORT_SYMBOL(__gcov_merge_icall_topn);
  99
 100 void __gcov_exit(void)
 101 {
 102         /* Unused. */
 103 }
 104 EXPORT_SYMBOL(__gcov_exit);
 105
 106 /**
 107  * gcov_enable_events - enable event reporting through gcov_event()
 108  *
 109  * Turn on reporting of profiling data load/unload-events through the
 110  * gcov_event() callback. Also replay all previous events once. This function
 111  * is needed because some events are potentially generated too early for the
 112  * callback implementation to handle them initially.
 113  */
 114 void gcov_enable_events(void)
 115 {
 116         struct gcov_info *info = NULL;
 117
 118         mutex_lock(&gcov_lock);
 119         gcov_events_enabled = 1;
 120
 121         /* Perform event callback for previously registered entries. */
 122         while ((info = gcov_info_next(info)))
 123                 gcov_event(GCOV_ADD, info);
 124
 125         mutex_unlock(&gcov_lock);
 126 }
 127
 128 #ifdef CONFIG_MODULES
 129 static inline int within(void *addr, void *start, unsigned long size)
 130 {
 131         return ((addr >= start) && (addr < start + size));
 132 }
 133
 134 /* Update list and generate events when modules are unloaded. */
 135 static int gcov_module_notifier(struct notifier_block *nb, unsigned long event,
 136                                 void *data)
 137 {
 138         struct module *mod = data;
 139         struct gcov_info *info = NULL;
 140         struct gcov_info *prev = NULL;
 141
 142         if (event != MODULE_STATE_GOING)
 143                 return NOTIFY_OK;
 144         mutex_lock(&gcov_lock);
 145
 146         /* Remove entries located in module from linked list. */
 147         while ((info = gcov_info_next(info))) {
 148                 if (within(info, mod->module_core, mod->core_size)) {
 149                         gcov_info_unlink(prev, info);
 150                         if (gcov_events_enabled)
 151                                 gcov_event(GCOV_REMOVE, info);
 152                 } else
 153                         prev = info;
 154         }
 155
 156         mutex_unlock(&gcov_lock);
 157
 158         return NOTIFY_OK;
 159 }
 160
 161 static struct notifier_block gcov_nb = {
 162         .notifier_call  = gcov_module_notifier,
 163 };
 164
 165 static int __init gcov_init(void)
 166 {
 167         return register_module_notifier(&gcov_nb);
 168 }
 169 device_initcall(gcov_init);
 170 #endif /* CONFIG_MODULES */