[deliverable/linux.git] / kernel / trace / kmemtrace.c

/*
 * Memory allocator tracing
 *
 * Copyright (C) 2008 Eduard - Gabriel Munteanu
 * Copyright (C) 2008 Pekka Enberg <penberg@cs.helsinki.fi>
 * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
 */

#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/fs.h>
#include <linux/seq_file.h>
#include <trace/kmemtrace.h>

#include "trace.h"
#include "trace_output.h"

/* Select an alternative, minimalistic output than the original one */
#define TRACE_KMEM_OPT_MINIMAL	0x1

static struct tracer_opt kmem_opts[] = {
	/* Default disable the minimalistic output */
	{ TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
	{ }
};

static struct tracer_flags kmem_tracer_flags = {
	.val = 0,
	.opts = kmem_opts
};


static bool kmem_tracing_enabled __read_mostly;
static struct trace_array *kmemtrace_array;

static int kmem_trace_init(struct trace_array *tr)
{
	int cpu;
	kmemtrace_array = tr;

	for_each_cpu_mask(cpu, cpu_possible_map)
		tracing_reset(tr, cpu);

	kmem_tracing_enabled = true;

	return 0;
}

static void kmem_trace_reset(struct trace_array *tr)
{
	kmem_tracing_enabled = false;
}

static void kmemtrace_headers(struct seq_file *s)
{
	/* Don't need headers for the original kmemtrace output */
	if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
		return;

	seq_printf(s, "#\n");
	seq_printf(s, "# ALLOC  TYPE  REQ   GIVEN  FLAGS     "
			"      POINTER         NODE    CALLER\n");
	seq_printf(s, "# FREE   |      |     |       |       "
			"       |   |            |        |\n");
	seq_printf(s, "# |\n\n");
}

/*
 * The two following functions give the original output from kmemtrace,
 * or something close to....perhaps they need some missing things
 */
static enum print_line_t
kmemtrace_print_alloc_original(struct trace_iterator *iter,
				struct kmemtrace_alloc_entry *entry)
{
	struct trace_seq *s = &iter->seq;
	int ret;

	/* Taken from the old linux/kmemtrace.h */
	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
	  "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
	   entry->type_id, entry->call_site, (unsigned long) entry->ptr,
	   (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
	   (unsigned long) entry->gfp_flags, entry->node);

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
kmemtrace_print_free_original(struct trace_iterator *iter,
				struct kmemtrace_free_entry *entry)
{
	struct trace_seq *s = &iter->seq;
	int ret;

	/* Taken from the old linux/kmemtrace.h */
	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
	   entry->type_id, entry->call_site, (unsigned long) entry->ptr);

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}


/* The two other following provide a more minimalistic output */
static enum print_line_t
kmemtrace_print_alloc_compress(struct trace_iterator *iter,
					struct kmemtrace_alloc_entry *entry)
{
	struct trace_seq *s = &iter->seq;
	int ret;

	/* Alloc entry */
	ret = trace_seq_printf(s, "  +      ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Type */
	switch (entry->type_id) {
	case KMEMTRACE_TYPE_KMALLOC:
		ret = trace_seq_printf(s, "K   ");
		break;
	case KMEMTRACE_TYPE_CACHE:
		ret = trace_seq_printf(s, "C   ");
		break;
	case KMEMTRACE_TYPE_PAGES:
		ret = trace_seq_printf(s, "P   ");
		break;
	default:
		ret = trace_seq_printf(s, "?   ");
	}

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Requested */
	ret = trace_seq_printf(s, "%4zu   ", entry->bytes_req);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Allocated */
	ret = trace_seq_printf(s, "%4zu   ", entry->bytes_alloc);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Flags
	 * TODO: would be better to see the name of the GFP flag names
	 */
	ret = trace_seq_printf(s, "%08x   ", entry->gfp_flags);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Pointer to allocated */
	ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Node */
	ret = trace_seq_printf(s, "%4d   ", entry->node);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Call site */
	ret = seq_print_ip_sym(s, entry->call_site, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	if (!trace_seq_printf(s, "\n"))
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
kmemtrace_print_free_compress(struct trace_iterator *iter,
				struct kmemtrace_free_entry *entry)
{
	struct trace_seq *s = &iter->seq;
	int ret;

	/* Free entry */
	ret = trace_seq_printf(s, "  -      ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Type */
	switch (entry->type_id) {
	case KMEMTRACE_TYPE_KMALLOC:
		ret = trace_seq_printf(s, "K     ");
		break;
	case KMEMTRACE_TYPE_CACHE:
		ret = trace_seq_printf(s, "C     ");
		break;
	case KMEMTRACE_TYPE_PAGES:
		ret = trace_seq_printf(s, "P     ");
		break;
	default:
		ret = trace_seq_printf(s, "?     ");
	}

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Skip requested/allocated/flags */
	ret = trace_seq_printf(s, "                       ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Pointer to allocated */
	ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Skip node */
	ret = trace_seq_printf(s, "       ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Call site */
	ret = seq_print_ip_sym(s, entry->call_site, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	if (!trace_seq_printf(s, "\n"))
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;

	switch (entry->type) {
	case TRACE_KMEM_ALLOC: {
		struct kmemtrace_alloc_entry *field;
		trace_assign_type(field, entry);
		if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
			return kmemtrace_print_alloc_compress(iter, field);
		else
			return kmemtrace_print_alloc_original(iter, field);
	}

	case TRACE_KMEM_FREE: {
		struct kmemtrace_free_entry *field;
		trace_assign_type(field, entry);
		if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
			return kmemtrace_print_free_compress(iter, field);
		else
			return kmemtrace_print_free_original(iter, field);
	}

	default:
		return TRACE_TYPE_UNHANDLED;
	}
}

/* Trace allocations */
void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
			     unsigned long call_site,
			     const void *ptr,
			     size_t bytes_req,
			     size_t bytes_alloc,
			     gfp_t gfp_flags,
			     int node)
{
	struct ring_buffer_event *event;
	struct kmemtrace_alloc_entry *entry;
	struct trace_array *tr = kmemtrace_array;

	if (!kmem_tracing_enabled)
		return;

	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
					  sizeof(*entry), 0, 0);
	if (!event)
		return;
	entry	= ring_buffer_event_data(event);

	entry->call_site = call_site;
	entry->ptr = ptr;
	entry->bytes_req = bytes_req;
	entry->bytes_alloc = bytes_alloc;
	entry->gfp_flags = gfp_flags;
	entry->node	=	node;

	trace_buffer_unlock_commit(tr, event, 0, 0);
}
EXPORT_SYMBOL(kmemtrace_mark_alloc_node);

void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
		       unsigned long call_site,
		       const void *ptr)
{
	struct ring_buffer_event *event;
	struct kmemtrace_free_entry *entry;
	struct trace_array *tr = kmemtrace_array;

	if (!kmem_tracing_enabled)
		return;

	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
					  sizeof(*entry), 0, 0);
	if (!event)
		return;
	entry	= ring_buffer_event_data(event);
	entry->type_id	= type_id;
	entry->call_site = call_site;
	entry->ptr = ptr;

	trace_buffer_unlock_commit(tr, event, 0, 0);
}
EXPORT_SYMBOL(kmemtrace_mark_free);

static struct tracer kmem_tracer __read_mostly = {
	.name		= "kmemtrace",
	.init		= kmem_trace_init,
	.reset		= kmem_trace_reset,
	.print_line	= kmemtrace_print_line,
	.print_header = kmemtrace_headers,
	.flags		= &kmem_tracer_flags
};

void kmemtrace_init(void)
{
	/* earliest opportunity to start kmem tracing */
}

static int __init init_kmem_tracer(void)
{
	return register_tracer(&kmem_tracer);
}

device_initcall(init_kmem_tracer);
Commit	Line	Data
36994e58 FW	1	/*
	2	* Memory allocator tracing
	3	*
	4	* Copyright (C) 2008 Eduard - Gabriel Munteanu
	5	* Copyright (C) 2008 Pekka Enberg <penberg@cs.helsinki.fi>
	6	* Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
	7	*/
	8
	9	#include <linux/dcache.h>
	10	#include <linux/debugfs.h>
	11	#include <linux/fs.h>
	12	#include <linux/seq_file.h>
	13	#include <trace/kmemtrace.h>
	14
	15	#include "trace.h"
	16	#include "trace_output.h"
	17
	18	/* Select an alternative, minimalistic output than the original one */
	19	#define TRACE_KMEM_OPT_MINIMAL 0x1
	20
	21	static struct tracer_opt kmem_opts[] = {
	22	/* Default disable the minimalistic output */
	23	{ TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
	24	{ }
	25	};
	26
	27	static struct tracer_flags kmem_tracer_flags = {
	28	.val = 0,
	29	.opts = kmem_opts
	30	};
	31
	32
	33	static bool kmem_tracing_enabled __read_mostly;
	34	static struct trace_array *kmemtrace_array;
	35
	36	static int kmem_trace_init(struct trace_array *tr)
	37	{
	38	int cpu;
	39	kmemtrace_array = tr;
	40
	41	for_each_cpu_mask(cpu, cpu_possible_map)
	42	tracing_reset(tr, cpu);
	43
	44	kmem_tracing_enabled = true;
	45
	46	return 0;
	47	}
	48
	49	static void kmem_trace_reset(struct trace_array *tr)
	50	{
	51	kmem_tracing_enabled = false;
	52	}
	53
	54	static void kmemtrace_headers(struct seq_file *s)
	55	{
	56	/* Don't need headers for the original kmemtrace output */
	57	if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
	58	return;
	59
	60	seq_printf(s, "#\n");
	61	seq_printf(s, "# ALLOC TYPE REQ GIVEN FLAGS "
	62	" POINTER NODE CALLER\n");
	63	seq_printf(s, "# FREE \| \| \| \| "
	64	" \| \| \| \|\n");
65	seq_printf(s, "# \|\n\n");
66	}
67
68	/*
69	* The two following functions give the original output from kmemtrace,
70	* or something close to....perhaps they need some missing things
71	*/
72	static enum print_line_t
73	kmemtrace_print_alloc_original(struct trace_iterator *iter,
74	struct kmemtrace_alloc_entry *entry)
75	{
76	struct trace_seq *s = &iter->seq;
77	int ret;
78
79	/* Taken from the old linux/kmemtrace.h */
80	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
81	"bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
82	entry->type_id, entry->call_site, (unsigned long) entry->ptr,
83	(unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
84	(unsigned long) entry->gfp_flags, entry->node);
85
86	if (!ret)
87	return TRACE_TYPE_PARTIAL_LINE;
88
89	return TRACE_TYPE_HANDLED;
90	}
91
92	static enum print_line_t
93	kmemtrace_print_free_original(struct trace_iterator *iter,
94	struct kmemtrace_free_entry *entry)
95	{
96	struct trace_seq *s = &iter->seq;
97	int ret;
98
99	/* Taken from the old linux/kmemtrace.h */
100	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
101	entry->type_id, entry->call_site, (unsigned long) entry->ptr);
102
103	if (!ret)
104	return TRACE_TYPE_PARTIAL_LINE;
105
106	return TRACE_TYPE_HANDLED;
107	}
108
109
110	/* The two other following provide a more minimalistic output */
111	static enum print_line_t
112	kmemtrace_print_alloc_compress(struct trace_iterator *iter,
113	struct kmemtrace_alloc_entry *entry)
114	{
115	struct trace_seq *s = &iter->seq;
116	int ret;
117
118	/* Alloc entry */
119	ret = trace_seq_printf(s, " + ");
120	if (!ret)
121	return TRACE_TYPE_PARTIAL_LINE;
122
123	/* Type */
124	switch (entry->type_id) {
125	case KMEMTRACE_TYPE_KMALLOC:
126	ret = trace_seq_printf(s, "K ");
127	break;
128	case KMEMTRACE_TYPE_CACHE:
129	ret = trace_seq_printf(s, "C ");
130	break;
131	case KMEMTRACE_TYPE_PAGES:
132	ret = trace_seq_printf(s, "P ");
133	break;
134	default:
135	ret = trace_seq_printf(s, "? ");
136	}
137
138	if (!ret)
139	return TRACE_TYPE_PARTIAL_LINE;
140
141	/* Requested */
ecf441b5	142	ret = trace_seq_printf(s, "%4zu ", entry->bytes_req);
36994e58 FW	143	if (!ret)
	144	return TRACE_TYPE_PARTIAL_LINE;
	145
	146	/* Allocated */
ecf441b5	147	ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc);
36994e58 FW	148	if (!ret)
	149	return TRACE_TYPE_PARTIAL_LINE;
	150
	151	/* Flags
	152	* TODO: would be better to see the name of the GFP flag names
	153	*/
	154	ret = trace_seq_printf(s, "%08x ", entry->gfp_flags);
	155	if (!ret)
	156	return TRACE_TYPE_PARTIAL_LINE;
	157
	158	/* Pointer to allocated */
	159	ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
	160	if (!ret)
	161	return TRACE_TYPE_PARTIAL_LINE;
	162
	163	/* Node */
	164	ret = trace_seq_printf(s, "%4d ", entry->node);
	165	if (!ret)
	166	return TRACE_TYPE_PARTIAL_LINE;
	167
	168	/* Call site */
	169	ret = seq_print_ip_sym(s, entry->call_site, 0);
	170	if (!ret)
	171	return TRACE_TYPE_PARTIAL_LINE;
	172
	173	if (!trace_seq_printf(s, "\n"))
	174	return TRACE_TYPE_PARTIAL_LINE;
	175
	176	return TRACE_TYPE_HANDLED;
	177	}
	178
	179	static enum print_line_t
	180	kmemtrace_print_free_compress(struct trace_iterator *iter,
	181	struct kmemtrace_free_entry *entry)
	182	{
	183	struct trace_seq *s = &iter->seq;
	184	int ret;
	185
	186	/* Free entry */
	187	ret = trace_seq_printf(s, " - ");
	188	if (!ret)
	189	return TRACE_TYPE_PARTIAL_LINE;
	190
	191	/* Type */
	192	switch (entry->type_id) {
	193	case KMEMTRACE_TYPE_KMALLOC:
	194	ret = trace_seq_printf(s, "K ");
	195	break;
	196	case KMEMTRACE_TYPE_CACHE:
	197	ret = trace_seq_printf(s, "C ");
	198	break;
	199	case KMEMTRACE_TYPE_PAGES:
	200	ret = trace_seq_printf(s, "P ");
	201	break;
	202	default:
	203	ret = trace_seq_printf(s, "? ");
	204	}
	205
	206	if (!ret)
	207	return TRACE_TYPE_PARTIAL_LINE;
	208
	209	/* Skip requested/allocated/flags */
	210	ret = trace_seq_printf(s, " ");
	211	if (!ret)
212	return TRACE_TYPE_PARTIAL_LINE;
213
214	/* Pointer to allocated */
215	ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
216	if (!ret)
217	return TRACE_TYPE_PARTIAL_LINE;
218
219	/* Skip node */
220	ret = trace_seq_printf(s, " ");
221	if (!ret)
222	return TRACE_TYPE_PARTIAL_LINE;
223
224	/* Call site */
225	ret = seq_print_ip_sym(s, entry->call_site, 0);
226	if (!ret)
227	return TRACE_TYPE_PARTIAL_LINE;
228
229	if (!trace_seq_printf(s, "\n"))
230	return TRACE_TYPE_PARTIAL_LINE;
231
232	return TRACE_TYPE_HANDLED;
233	}
234
235	static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
236	{
237	struct trace_entry *entry = iter->ent;
238
239	switch (entry->type) {
240	case TRACE_KMEM_ALLOC: {
241	struct kmemtrace_alloc_entry *field;
242	trace_assign_type(field, entry);
243	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
244	return kmemtrace_print_alloc_compress(iter, field);
245	else
246	return kmemtrace_print_alloc_original(iter, field);
247	}
248
249	case TRACE_KMEM_FREE: {
250	struct kmemtrace_free_entry *field;
251	trace_assign_type(field, entry);
252	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
253	return kmemtrace_print_free_compress(iter, field);
254	else
255	return kmemtrace_print_free_original(iter, field);
256	}
257
258	default:
259	return TRACE_TYPE_UNHANDLED;
260	}
261	}
262
263	/* Trace allocations */
264	void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
265	unsigned long call_site,
266	const void *ptr,
267	size_t bytes_req,
268	size_t bytes_alloc,
269	gfp_t gfp_flags,
270	int node)
271	{
272	struct ring_buffer_event *event;
273	struct kmemtrace_alloc_entry *entry;
274	struct trace_array *tr = kmemtrace_array;
36994e58 FW	275
	276	if (!kmem_tracing_enabled)
	277	return;
	278
51a763dd ACM	279	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
51a763dd ACM	280	sizeof(*entry), 0, 0);
36994e58 FW	281	if (!event)
	282	return;
	283	entry = ring_buffer_event_data(event);
36994e58	284
36994e58 FW	285	entry->call_site = call_site;
	286	entry->ptr = ptr;
	287	entry->bytes_req = bytes_req;
	288	entry->bytes_alloc = bytes_alloc;
	289	entry->gfp_flags = gfp_flags;
	290	entry->node = node;
	291
51a763dd	292	trace_buffer_unlock_commit(tr, event, 0, 0);
36994e58	293	}
3fd4bc01	294	EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
36994e58 FW	295
	296	void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
	297	unsigned long call_site,
	298	const void *ptr)
	299	{
	300	struct ring_buffer_event *event;
	301	struct kmemtrace_free_entry *entry;
	302	struct trace_array *tr = kmemtrace_array;
36994e58 FW	303
	304	if (!kmem_tracing_enabled)
	305	return;
	306
51a763dd ACM	307	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
51a763dd ACM	308	sizeof(*entry), 0, 0);
36994e58 FW	309	if (!event)
	310	return;
	311	entry = ring_buffer_event_data(event);
36994e58 FW	312	entry->type_id = type_id;
	313	entry->call_site = call_site;
	314	entry->ptr = ptr;
	315
51a763dd	316	trace_buffer_unlock_commit(tr, event, 0, 0);
36994e58	317	}
3fd4bc01	318	EXPORT_SYMBOL(kmemtrace_mark_free);
36994e58 FW	319
	320	static struct tracer kmem_tracer __read_mostly = {
	321	.name = "kmemtrace",
	322	.init = kmem_trace_init,
	323	.reset = kmem_trace_reset,
	324	.print_line = kmemtrace_print_line,
	325	.print_header = kmemtrace_headers,
	326	.flags = &kmem_tracer_flags
	327	};
	328
3e806802 IM	329	void kmemtrace_init(void)
	330	{
	331	/* earliest opportunity to start kmem tracing */
	332	}
	333
36994e58 FW	334	static int __init init_kmem_tracer(void)
	335	{
	336	return register_tracer(&kmem_tracer);
	337	}
	338
	339	device_initcall(init_kmem_tracer);