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