[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, "%4d   ", entry->bytes_req);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Allocated */
	ret = trace_seq_printf(s, "%4d   ", 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;
	unsigned long irq_flags;

	if (!kmem_tracing_enabled)
		return;

	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
					 &irq_flags);
	if (!event)
		return;
	entry	= ring_buffer_event_data(event);
	tracing_generic_entry_update(&entry->ent, 0, 0);

	entry->ent.type = TRACE_KMEM_ALLOC;
	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;

	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);

	trace_wake_up();
}
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;
	unsigned long irq_flags;

	if (!kmem_tracing_enabled)
		return;

	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
					 &irq_flags);
	if (!event)
		return;
	entry	= ring_buffer_event_data(event);
	tracing_generic_entry_update(&entry->ent, 0, 0);

	entry->ent.type = TRACE_KMEM_FREE;
	entry->type_id	= type_id;
	entry->call_site = call_site;
	entry->ptr = ptr;

	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);

	trace_wake_up();
}
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 */
142	ret = trace_seq_printf(s, "%4d ", entry->bytes_req);
143	if (!ret)
144	return TRACE_TYPE_PARTIAL_LINE;
145
146	/* Allocated */
147	ret = trace_seq_printf(s, "%4d ", entry->bytes_alloc);
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;
275	unsigned long irq_flags;
276
277	if (!kmem_tracing_enabled)
278	return;
279
280	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
281	&irq_flags);
282	if (!event)
283	return;
284	entry = ring_buffer_event_data(event);
285	tracing_generic_entry_update(&entry->ent, 0, 0);
286
287	entry->ent.type = TRACE_KMEM_ALLOC;
288	entry->call_site = call_site;
289	entry->ptr = ptr;
290	entry->bytes_req = bytes_req;
291	entry->bytes_alloc = bytes_alloc;
292	entry->gfp_flags = gfp_flags;
293	entry->node = node;
294
295	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
296
297	trace_wake_up();
298	}
3fd4bc01	299	EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
36994e58 FW	300
	301	void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
	302	unsigned long call_site,
	303	const void *ptr)
	304	{
	305	struct ring_buffer_event *event;
	306	struct kmemtrace_free_entry *entry;
	307	struct trace_array *tr = kmemtrace_array;
	308	unsigned long irq_flags;
	309
	310	if (!kmem_tracing_enabled)
	311	return;
	312
	313	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
	314	&irq_flags);
	315	if (!event)
	316	return;
	317	entry = ring_buffer_event_data(event);
	318	tracing_generic_entry_update(&entry->ent, 0, 0);
	319
	320	entry->ent.type = TRACE_KMEM_FREE;
	321	entry->type_id = type_id;
	322	entry->call_site = call_site;
	323	entry->ptr = ptr;
	324
	325	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
	326
	327	trace_wake_up();
	328	}
3fd4bc01	329	EXPORT_SYMBOL(kmemtrace_mark_free);
36994e58 FW	330
	331	static struct tracer kmem_tracer __read_mostly = {
	332	.name = "kmemtrace",
	333	.init = kmem_trace_init,
	334	.reset = kmem_trace_reset,
	335	.print_line = kmemtrace_print_line,
	336	.print_header = kmemtrace_headers,
	337	.flags = &kmem_tracer_flags
	338	};
	339
3e806802 IM	340	void kmemtrace_init(void)
	341	{
	342	/* earliest opportunity to start kmem tracing */
	343	}
	344
36994e58 FW	345	static int __init init_kmem_tracer(void)
	346	{
	347	return register_tracer(&kmem_tracer);
	348	}
	349
	350	device_initcall(init_kmem_tracer);