2 * Memory allocator tracing
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>
9 #include <linux/tracepoint.h>
10 #include <linux/seq_file.h>
11 #include <linux/debugfs.h>
12 #include <linux/dcache.h>
15 #include <linux/kmemtrace.h>
17 #include "trace_output.h"
20 /* Select an alternative, minimalistic output than the original one */
21 #define TRACE_KMEM_OPT_MINIMAL 0x1
23 static struct tracer_opt kmem_opts[] = {
24 /* Default disable the minimalistic output */
25 { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
29 static struct tracer_flags kmem_tracer_flags = {
34 static struct trace_array *kmemtrace_array;
36 /* Trace allocations */
37 static inline void kmemtrace_alloc(enum kmemtrace_type_id type_id,
38 unsigned long call_site,
45 struct ftrace_event_call *call = &event_kmem_alloc;
46 struct trace_array *tr = kmemtrace_array;
47 struct kmemtrace_alloc_entry *entry;
48 struct ring_buffer_event *event;
50 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
54 entry = ring_buffer_event_data(event);
55 tracing_generic_entry_update(&entry->ent, 0, 0);
57 entry->ent.type = TRACE_KMEM_ALLOC;
58 entry->type_id = type_id;
59 entry->call_site = call_site;
61 entry->bytes_req = bytes_req;
62 entry->bytes_alloc = bytes_alloc;
63 entry->gfp_flags = gfp_flags;
66 if (!filter_check_discard(call, entry, tr->buffer, event))
67 ring_buffer_unlock_commit(tr->buffer, event);
72 static inline void kmemtrace_free(enum kmemtrace_type_id type_id,
73 unsigned long call_site,
76 struct ftrace_event_call *call = &event_kmem_free;
77 struct trace_array *tr = kmemtrace_array;
78 struct kmemtrace_free_entry *entry;
79 struct ring_buffer_event *event;
81 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
84 entry = ring_buffer_event_data(event);
85 tracing_generic_entry_update(&entry->ent, 0, 0);
87 entry->ent.type = TRACE_KMEM_FREE;
88 entry->type_id = type_id;
89 entry->call_site = call_site;
92 if (!filter_check_discard(call, entry, tr->buffer, event))
93 ring_buffer_unlock_commit(tr->buffer, event);
98 static void kmemtrace_kmalloc(unsigned long call_site,
104 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
105 bytes_req, bytes_alloc, gfp_flags, -1);
108 static void kmemtrace_kmem_cache_alloc(unsigned long call_site,
114 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
115 bytes_req, bytes_alloc, gfp_flags, -1);
118 static void kmemtrace_kmalloc_node(unsigned long call_site,
125 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
126 bytes_req, bytes_alloc, gfp_flags, node);
129 static void kmemtrace_kmem_cache_alloc_node(unsigned long call_site,
136 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
137 bytes_req, bytes_alloc, gfp_flags, node);
140 static void kmemtrace_kfree(unsigned long call_site, const void *ptr)
142 kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
145 static void kmemtrace_kmem_cache_free(unsigned long call_site, const void *ptr)
147 kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
150 static int kmemtrace_start_probes(void)
154 err = register_trace_kmalloc(kmemtrace_kmalloc);
157 err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
160 err = register_trace_kmalloc_node(kmemtrace_kmalloc_node);
163 err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
166 err = register_trace_kfree(kmemtrace_kfree);
169 err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
174 static void kmemtrace_stop_probes(void)
176 unregister_trace_kmalloc(kmemtrace_kmalloc);
177 unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
178 unregister_trace_kmalloc_node(kmemtrace_kmalloc_node);
179 unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
180 unregister_trace_kfree(kmemtrace_kfree);
181 unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
184 static int kmem_trace_init(struct trace_array *tr)
187 kmemtrace_array = tr;
189 for_each_cpu(cpu, cpu_possible_mask)
190 tracing_reset(tr, cpu);
192 kmemtrace_start_probes();
197 static void kmem_trace_reset(struct trace_array *tr)
199 kmemtrace_stop_probes();
202 static void kmemtrace_headers(struct seq_file *s)
204 /* Don't need headers for the original kmemtrace output */
205 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
208 seq_printf(s, "#\n");
209 seq_printf(s, "# ALLOC TYPE REQ GIVEN FLAGS "
210 " POINTER NODE CALLER\n");
211 seq_printf(s, "# FREE | | | | "
213 seq_printf(s, "# |\n\n");
217 * The following functions give the original output from kmemtrace,
218 * plus the origin CPU, since reordering occurs in-kernel now.
221 #define KMEMTRACE_USER_ALLOC 0
222 #define KMEMTRACE_USER_FREE 1
224 struct kmemtrace_user_event {
230 unsigned long call_site;
234 struct kmemtrace_user_event_alloc {
241 static enum print_line_t
242 kmemtrace_print_alloc(struct trace_iterator *iter, int flags)
244 struct trace_seq *s = &iter->seq;
245 struct kmemtrace_alloc_entry *entry;
248 trace_assign_type(entry, iter->ent);
250 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu "
251 "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
252 entry->type_id, (void *)entry->call_site, (unsigned long)entry->ptr,
253 (unsigned long)entry->bytes_req, (unsigned long)entry->bytes_alloc,
254 (unsigned long)entry->gfp_flags, entry->node);
257 return TRACE_TYPE_PARTIAL_LINE;
258 return TRACE_TYPE_HANDLED;
261 static enum print_line_t
262 kmemtrace_print_free(struct trace_iterator *iter, int flags)
264 struct trace_seq *s = &iter->seq;
265 struct kmemtrace_free_entry *entry;
268 trace_assign_type(entry, iter->ent);
270 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu\n",
271 entry->type_id, (void *)entry->call_site,
272 (unsigned long)entry->ptr);
275 return TRACE_TYPE_PARTIAL_LINE;
276 return TRACE_TYPE_HANDLED;
279 static enum print_line_t
280 kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags)
282 struct trace_seq *s = &iter->seq;
283 struct kmemtrace_alloc_entry *entry;
284 struct kmemtrace_user_event *ev;
285 struct kmemtrace_user_event_alloc *ev_alloc;
287 trace_assign_type(entry, iter->ent);
289 ev = trace_seq_reserve(s, sizeof(*ev));
291 return TRACE_TYPE_PARTIAL_LINE;
293 ev->event_id = KMEMTRACE_USER_ALLOC;
294 ev->type_id = entry->type_id;
295 ev->event_size = sizeof(*ev) + sizeof(*ev_alloc);
297 ev->timestamp = iter->ts;
298 ev->call_site = entry->call_site;
299 ev->ptr = (unsigned long)entry->ptr;
301 ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc));
303 return TRACE_TYPE_PARTIAL_LINE;
305 ev_alloc->bytes_req = entry->bytes_req;
306 ev_alloc->bytes_alloc = entry->bytes_alloc;
307 ev_alloc->gfp_flags = entry->gfp_flags;
308 ev_alloc->node = entry->node;
310 return TRACE_TYPE_HANDLED;
313 static enum print_line_t
314 kmemtrace_print_free_user(struct trace_iterator *iter, int flags)
316 struct trace_seq *s = &iter->seq;
317 struct kmemtrace_free_entry *entry;
318 struct kmemtrace_user_event *ev;
320 trace_assign_type(entry, iter->ent);
322 ev = trace_seq_reserve(s, sizeof(*ev));
324 return TRACE_TYPE_PARTIAL_LINE;
326 ev->event_id = KMEMTRACE_USER_FREE;
327 ev->type_id = entry->type_id;
328 ev->event_size = sizeof(*ev);
330 ev->timestamp = iter->ts;
331 ev->call_site = entry->call_site;
332 ev->ptr = (unsigned long)entry->ptr;
334 return TRACE_TYPE_HANDLED;
337 /* The two other following provide a more minimalistic output */
338 static enum print_line_t
339 kmemtrace_print_alloc_compress(struct trace_iterator *iter)
341 struct kmemtrace_alloc_entry *entry;
342 struct trace_seq *s = &iter->seq;
345 trace_assign_type(entry, iter->ent);
348 ret = trace_seq_printf(s, " + ");
350 return TRACE_TYPE_PARTIAL_LINE;
353 switch (entry->type_id) {
354 case KMEMTRACE_TYPE_KMALLOC:
355 ret = trace_seq_printf(s, "K ");
357 case KMEMTRACE_TYPE_CACHE:
358 ret = trace_seq_printf(s, "C ");
360 case KMEMTRACE_TYPE_PAGES:
361 ret = trace_seq_printf(s, "P ");
364 ret = trace_seq_printf(s, "? ");
368 return TRACE_TYPE_PARTIAL_LINE;
371 ret = trace_seq_printf(s, "%4zu ", entry->bytes_req);
373 return TRACE_TYPE_PARTIAL_LINE;
376 ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc);
378 return TRACE_TYPE_PARTIAL_LINE;
381 * TODO: would be better to see the name of the GFP flag names
383 ret = trace_seq_printf(s, "%08x ", entry->gfp_flags);
385 return TRACE_TYPE_PARTIAL_LINE;
387 /* Pointer to allocated */
388 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
390 return TRACE_TYPE_PARTIAL_LINE;
392 /* Node and call site*/
393 ret = trace_seq_printf(s, "%4d %pf\n", entry->node,
394 (void *)entry->call_site);
396 return TRACE_TYPE_PARTIAL_LINE;
398 return TRACE_TYPE_HANDLED;
401 static enum print_line_t
402 kmemtrace_print_free_compress(struct trace_iterator *iter)
404 struct kmemtrace_free_entry *entry;
405 struct trace_seq *s = &iter->seq;
408 trace_assign_type(entry, iter->ent);
411 ret = trace_seq_printf(s, " - ");
413 return TRACE_TYPE_PARTIAL_LINE;
416 switch (entry->type_id) {
417 case KMEMTRACE_TYPE_KMALLOC:
418 ret = trace_seq_printf(s, "K ");
420 case KMEMTRACE_TYPE_CACHE:
421 ret = trace_seq_printf(s, "C ");
423 case KMEMTRACE_TYPE_PAGES:
424 ret = trace_seq_printf(s, "P ");
427 ret = trace_seq_printf(s, "? ");
431 return TRACE_TYPE_PARTIAL_LINE;
433 /* Skip requested/allocated/flags */
434 ret = trace_seq_printf(s, " ");
436 return TRACE_TYPE_PARTIAL_LINE;
438 /* Pointer to allocated */
439 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
441 return TRACE_TYPE_PARTIAL_LINE;
443 /* Skip node and print call site*/
444 ret = trace_seq_printf(s, " %pf\n", (void *)entry->call_site);
446 return TRACE_TYPE_PARTIAL_LINE;
448 return TRACE_TYPE_HANDLED;
451 static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
453 struct trace_entry *entry = iter->ent;
455 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
456 return TRACE_TYPE_UNHANDLED;
458 switch (entry->type) {
459 case TRACE_KMEM_ALLOC:
460 return kmemtrace_print_alloc_compress(iter);
461 case TRACE_KMEM_FREE:
462 return kmemtrace_print_free_compress(iter);
464 return TRACE_TYPE_UNHANDLED;
468 static struct trace_event kmem_trace_alloc = {
469 .type = TRACE_KMEM_ALLOC,
470 .trace = kmemtrace_print_alloc,
471 .binary = kmemtrace_print_alloc_user,
474 static struct trace_event kmem_trace_free = {
475 .type = TRACE_KMEM_FREE,
476 .trace = kmemtrace_print_free,
477 .binary = kmemtrace_print_free_user,
480 static struct tracer kmem_tracer __read_mostly = {
482 .init = kmem_trace_init,
483 .reset = kmem_trace_reset,
484 .print_line = kmemtrace_print_line,
485 .print_header = kmemtrace_headers,
486 .flags = &kmem_tracer_flags
489 void kmemtrace_init(void)
491 /* earliest opportunity to start kmem tracing */
494 static int __init init_kmem_tracer(void)
496 if (!register_ftrace_event(&kmem_trace_alloc)) {
497 pr_warning("Warning: could not register kmem events\n");
501 if (!register_ftrace_event(&kmem_trace_free)) {
502 pr_warning("Warning: could not register kmem events\n");
506 if (!register_tracer(&kmem_tracer)) {
507 pr_warning("Warning: could not register the kmem tracer\n");
513 device_initcall(init_kmem_tracer);