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