[linux-2.6-block.git] / kernel / gcov / base.c

/*
 *  This code maintains a list of active profiling data structures.
 *
 *    Copyright IBM Corp. 2009
 *    Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
 *
 *    Uses gcc-internal data definitions.
 *    Based on the gcov-kernel patch by:
 *		 Hubertus Franke <frankeh@us.ibm.com>
 *		 Nigel Hinds <nhinds@us.ibm.com>
 *		 Rajan Ravindran <rajancr@us.ibm.com>
 *		 Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
 *		 Paul Larson
 */

#define pr_fmt(fmt)	"gcov: " fmt

#include <linux/init.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include "gcov.h"

static int gcov_events_enabled;
static DEFINE_MUTEX(gcov_lock);

/*
 * __gcov_init is called by gcc-generated constructor code for each object
 * file compiled with -fprofile-arcs.
 */
void __gcov_init(struct gcov_info *info)
{
	static unsigned int gcov_version;

	mutex_lock(&gcov_lock);
	if (gcov_version == 0) {
		gcov_version = gcov_info_version(info);
		/*
		 * Printing gcc's version magic may prove useful for debugging
		 * incompatibility reports.
		 */
		pr_info("version magic: 0x%x\n", gcov_version);
	}
	/*
	 * Add new profiling data structure to list and inform event
	 * listener.
	 */
	gcov_info_link(info);
	if (gcov_events_enabled)
		gcov_event(GCOV_ADD, info);
	mutex_unlock(&gcov_lock);
}
EXPORT_SYMBOL(__gcov_init);

/*
 * These functions may be referenced by gcc-generated profiling code but serve
 * no function for kernel profiling.
 */
void __gcov_flush(void)
{
	/* Unused. */
}
EXPORT_SYMBOL(__gcov_flush);

void __gcov_merge_add(gcov_type *counters, unsigned int n_counters)
{
	/* Unused. */
}
EXPORT_SYMBOL(__gcov_merge_add);

void __gcov_merge_single(gcov_type *counters, unsigned int n_counters)
{
	/* Unused. */
}
EXPORT_SYMBOL(__gcov_merge_single);

void __gcov_merge_delta(gcov_type *counters, unsigned int n_counters)
{
	/* Unused. */
}
EXPORT_SYMBOL(__gcov_merge_delta);

void __gcov_merge_ior(gcov_type *counters, unsigned int n_counters)
{
	/* Unused. */
}
EXPORT_SYMBOL(__gcov_merge_ior);

/**
 * gcov_enable_events - enable event reporting through gcov_event()
 *
 * Turn on reporting of profiling data load/unload-events through the
 * gcov_event() callback. Also replay all previous events once. This function
 * is needed because some events are potentially generated too early for the
 * callback implementation to handle them initially.
 */
void gcov_enable_events(void)
{
	struct gcov_info *info = NULL;

	mutex_lock(&gcov_lock);
	gcov_events_enabled = 1;

	/* Perform event callback for previously registered entries. */
	while ((info = gcov_info_next(info)))
		gcov_event(GCOV_ADD, info);

	mutex_unlock(&gcov_lock);
}

#ifdef CONFIG_MODULES
static inline int within(void *addr, void *start, unsigned long size)
{
	return ((addr >= start) && (addr < start + size));
}

/* Update list and generate events when modules are unloaded. */
static int gcov_module_notifier(struct notifier_block *nb, unsigned long event,
				void *data)
{
	struct module *mod = data;
	struct gcov_info *info = NULL;
	struct gcov_info *prev = NULL;

	if (event != MODULE_STATE_GOING)
		return NOTIFY_OK;
	mutex_lock(&gcov_lock);

	/* Remove entries located in module from linked list. */
	while ((info = gcov_info_next(info))) {
		if (within(info, mod->module_core, mod->core_size)) {
			gcov_info_unlink(prev, info);
			if (gcov_events_enabled)
				gcov_event(GCOV_REMOVE, info);
		} else
			prev = info;
	}

	mutex_unlock(&gcov_lock);

	return NOTIFY_OK;
}

static struct notifier_block gcov_nb = {
	.notifier_call	= gcov_module_notifier,
};

static int __init gcov_init(void)
{
	return register_module_notifier(&gcov_nb);
}
device_initcall(gcov_init);
#endif /* CONFIG_MODULES */
Commit	Line	Data
2521f2c2 PO	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
2521f2c2 PO	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) {
8cbce376	36	gcov_version = gcov_info_version(info);
2521f2c2 PO	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	*/
8cbce376	47	gcov_info_link(info);
2521f2c2 PO	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
5f41ea03 FH	82	void __gcov_merge_ior(gcov_type *counters, unsigned int n_counters)
	83	{
	84	/* Unused. */
	85	}
	86	EXPORT_SYMBOL(__gcov_merge_ior);
	87
2521f2c2 PO	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	{
8cbce376	98	struct gcov_info *info = NULL;
2521f2c2 PO	99
	100	mutex_lock(&gcov_lock);
	101	gcov_events_enabled = 1;
8cbce376	102
2521f2c2	103	/* Perform event callback for previously registered entries. */
8cbce376	104	while ((info = gcov_info_next(info)))
2521f2c2	105	gcov_event(GCOV_ADD, info);
8cbce376	106
2521f2c2 PO	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;
8cbce376 FH	121	struct gcov_info *info = NULL;
8cbce376 FH	122	struct gcov_info *prev = NULL;
2521f2c2 PO	123
	124	if (event != MODULE_STATE_GOING)
	125	return NOTIFY_OK;
	126	mutex_lock(&gcov_lock);
8cbce376	127
2521f2c2	128	/* Remove entries located in module from linked list. */
8cbce376	129	while ((info = gcov_info_next(info))) {
2521f2c2	130	if (within(info, mod->module_core, mod->core_size)) {
8cbce376	131	gcov_info_unlink(prev, info);
2521f2c2 PO	132	if (gcov_events_enabled)
	133	gcov_event(GCOV_REMOVE, info);
	134	} else
	135	prev = info;
	136	}
8cbce376	137
2521f2c2 PO	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 */