[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);

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

/**
 * 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
a992bf83 YP	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
2521f2c2 PO	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	{
8cbce376	104	struct gcov_info *info = NULL;
2521f2c2 PO	105
	106	mutex_lock(&gcov_lock);
	107	gcov_events_enabled = 1;
8cbce376	108
2521f2c2	109	/* Perform event callback for previously registered entries. */
8cbce376	110	while ((info = gcov_info_next(info)))
2521f2c2	111	gcov_event(GCOV_ADD, info);
8cbce376	112
2521f2c2 PO	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;
8cbce376 FH	127	struct gcov_info *info = NULL;
8cbce376 FH	128	struct gcov_info *prev = NULL;
2521f2c2 PO	129
	130	if (event != MODULE_STATE_GOING)
	131	return NOTIFY_OK;
	132	mutex_lock(&gcov_lock);
8cbce376	133
2521f2c2	134	/* Remove entries located in module from linked list. */
8cbce376	135	while ((info = gcov_info_next(info))) {
2521f2c2	136	if (within(info, mod->module_core, mod->core_size)) {
8cbce376	137	gcov_info_unlink(prev, info);
2521f2c2 PO	138	if (gcov_events_enabled)
	139	gcov_event(GCOV_REMOVE, info);
	140	} else
	141	prev = info;
	142	}
8cbce376	143
2521f2c2 PO	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 */