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(void *ignore,
99 unsigned long call_site,
105 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
106 bytes_req, bytes_alloc, gfp_flags, -1);
109 static void kmemtrace_kmem_cache_alloc(void *ignore,
110 unsigned long call_site,
116 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
117 bytes_req, bytes_alloc, gfp_flags, -1);
120 static void kmemtrace_kmalloc_node(void *ignore,
121 unsigned long call_site,
128 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
129 bytes_req, bytes_alloc, gfp_flags, node);
132 static void kmemtrace_kmem_cache_alloc_node(void *ignore,
133 unsigned long call_site,
140 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
141 bytes_req, bytes_alloc, gfp_flags, node);
145 kmemtrace_kfree(void *ignore, unsigned long call_site, const void *ptr)
147 kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
150 static void kmemtrace_kmem_cache_free(void *ignore,
151 unsigned long call_site, const void *ptr)
153 kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
156 static int kmemtrace_start_probes(void)
160 err = register_trace_kmalloc(kmemtrace_kmalloc, NULL);
163 err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL);
166 err = register_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL);
169 err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL);
172 err = register_trace_kfree(kmemtrace_kfree, NULL);
175 err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL);
180 static void kmemtrace_stop_probes(void)
182 unregister_trace_kmalloc(kmemtrace_kmalloc, NULL);
183 unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL);
184 unregister_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL);
185 unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL);
186 unregister_trace_kfree(kmemtrace_kfree, NULL);
187 unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL);
190 static int kmem_trace_init(struct trace_array *tr)
192 kmemtrace_array = tr;
194 tracing_reset_online_cpus(tr);
196 kmemtrace_start_probes();
201 static void kmem_trace_reset(struct trace_array *tr)
203 kmemtrace_stop_probes();
206 static void kmemtrace_headers(struct seq_file *s)
208 /* Don't need headers for the original kmemtrace output */
209 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
212 seq_printf(s, "#\n");
213 seq_printf(s, "# ALLOC TYPE REQ GIVEN FLAGS "
214 " POINTER NODE CALLER\n");
215 seq_printf(s, "# FREE | | | | "
217 seq_printf(s, "# |\n\n");
221 * The following functions give the original output from kmemtrace,
222 * plus the origin CPU, since reordering occurs in-kernel now.
225 #define KMEMTRACE_USER_ALLOC 0
226 #define KMEMTRACE_USER_FREE 1
228 struct kmemtrace_user_event {
234 unsigned long call_site;
238 struct kmemtrace_user_event_alloc {
245 static enum print_line_t
246 kmemtrace_print_alloc(struct trace_iterator *iter, int flags)
248 struct trace_seq *s = &iter->seq;
249 struct kmemtrace_alloc_entry *entry;
252 trace_assign_type(entry, iter->ent);
254 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu "
255 "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
256 entry->type_id, (void *)entry->call_site, (unsigned long)entry->ptr,
257 (unsigned long)entry->bytes_req, (unsigned long)entry->bytes_alloc,
258 (unsigned long)entry->gfp_flags, entry->node);
261 return TRACE_TYPE_PARTIAL_LINE;
262 return TRACE_TYPE_HANDLED;
265 static enum print_line_t
266 kmemtrace_print_free(struct trace_iterator *iter, int flags)
268 struct trace_seq *s = &iter->seq;
269 struct kmemtrace_free_entry *entry;
272 trace_assign_type(entry, iter->ent);
274 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu\n",
275 entry->type_id, (void *)entry->call_site,
276 (unsigned long)entry->ptr);
279 return TRACE_TYPE_PARTIAL_LINE;
280 return TRACE_TYPE_HANDLED;
283 static enum print_line_t
284 kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags)
286 struct trace_seq *s = &iter->seq;
287 struct kmemtrace_alloc_entry *entry;
288 struct kmemtrace_user_event *ev;
289 struct kmemtrace_user_event_alloc *ev_alloc;
291 trace_assign_type(entry, iter->ent);
293 ev = trace_seq_reserve(s, sizeof(*ev));
295 return TRACE_TYPE_PARTIAL_LINE;
297 ev->event_id = KMEMTRACE_USER_ALLOC;
298 ev->type_id = entry->type_id;
299 ev->event_size = sizeof(*ev) + sizeof(*ev_alloc);
301 ev->timestamp = iter->ts;
302 ev->call_site = entry->call_site;
303 ev->ptr = (unsigned long)entry->ptr;
305 ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc));
307 return TRACE_TYPE_PARTIAL_LINE;
309 ev_alloc->bytes_req = entry->bytes_req;
310 ev_alloc->bytes_alloc = entry->bytes_alloc;
311 ev_alloc->gfp_flags = entry->gfp_flags;
312 ev_alloc->node = entry->node;
314 return TRACE_TYPE_HANDLED;
317 static enum print_line_t
318 kmemtrace_print_free_user(struct trace_iterator *iter, int flags)
320 struct trace_seq *s = &iter->seq;
321 struct kmemtrace_free_entry *entry;
322 struct kmemtrace_user_event *ev;
324 trace_assign_type(entry, iter->ent);
326 ev = trace_seq_reserve(s, sizeof(*ev));
328 return TRACE_TYPE_PARTIAL_LINE;
330 ev->event_id = KMEMTRACE_USER_FREE;
331 ev->type_id = entry->type_id;
332 ev->event_size = sizeof(*ev);
334 ev->timestamp = iter->ts;
335 ev->call_site = entry->call_site;
336 ev->ptr = (unsigned long)entry->ptr;
338 return TRACE_TYPE_HANDLED;
341 /* The two other following provide a more minimalistic output */
342 static enum print_line_t
343 kmemtrace_print_alloc_compress(struct trace_iterator *iter)
345 struct kmemtrace_alloc_entry *entry;
346 struct trace_seq *s = &iter->seq;
349 trace_assign_type(entry, iter->ent);
352 ret = trace_seq_printf(s, " + ");
354 return TRACE_TYPE_PARTIAL_LINE;
357 switch (entry->type_id) {
358 case KMEMTRACE_TYPE_KMALLOC:
359 ret = trace_seq_printf(s, "K ");
361 case KMEMTRACE_TYPE_CACHE:
362 ret = trace_seq_printf(s, "C ");
364 case KMEMTRACE_TYPE_PAGES:
365 ret = trace_seq_printf(s, "P ");
368 ret = trace_seq_printf(s, "? ");
372 return TRACE_TYPE_PARTIAL_LINE;
375 ret = trace_seq_printf(s, "%4zu ", entry->bytes_req);
377 return TRACE_TYPE_PARTIAL_LINE;
380 ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc);
382 return TRACE_TYPE_PARTIAL_LINE;
385 * TODO: would be better to see the name of the GFP flag names
387 ret = trace_seq_printf(s, "%08x ", entry->gfp_flags);
389 return TRACE_TYPE_PARTIAL_LINE;
391 /* Pointer to allocated */
392 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
394 return TRACE_TYPE_PARTIAL_LINE;
396 /* Node and call site*/
397 ret = trace_seq_printf(s, "%4d %pf\n", entry->node,
398 (void *)entry->call_site);
400 return TRACE_TYPE_PARTIAL_LINE;
402 return TRACE_TYPE_HANDLED;
405 static enum print_line_t
406 kmemtrace_print_free_compress(struct trace_iterator *iter)
408 struct kmemtrace_free_entry *entry;
409 struct trace_seq *s = &iter->seq;
412 trace_assign_type(entry, iter->ent);
415 ret = trace_seq_printf(s, " - ");
417 return TRACE_TYPE_PARTIAL_LINE;
420 switch (entry->type_id) {
421 case KMEMTRACE_TYPE_KMALLOC:
422 ret = trace_seq_printf(s, "K ");
424 case KMEMTRACE_TYPE_CACHE:
425 ret = trace_seq_printf(s, "C ");
427 case KMEMTRACE_TYPE_PAGES:
428 ret = trace_seq_printf(s, "P ");
431 ret = trace_seq_printf(s, "? ");
435 return TRACE_TYPE_PARTIAL_LINE;
437 /* Skip requested/allocated/flags */
438 ret = trace_seq_printf(s, " ");
440 return TRACE_TYPE_PARTIAL_LINE;
442 /* Pointer to allocated */
443 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
445 return TRACE_TYPE_PARTIAL_LINE;
447 /* Skip node and print call site*/
448 ret = trace_seq_printf(s, " %pf\n", (void *)entry->call_site);
450 return TRACE_TYPE_PARTIAL_LINE;
452 return TRACE_TYPE_HANDLED;
455 static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
457 struct trace_entry *entry = iter->ent;
459 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
460 return TRACE_TYPE_UNHANDLED;
462 switch (entry->type) {
463 case TRACE_KMEM_ALLOC:
464 return kmemtrace_print_alloc_compress(iter);
465 case TRACE_KMEM_FREE:
466 return kmemtrace_print_free_compress(iter);
468 return TRACE_TYPE_UNHANDLED;
472 static struct trace_event kmem_trace_alloc = {
473 .type = TRACE_KMEM_ALLOC,
474 .trace = kmemtrace_print_alloc,
475 .binary = kmemtrace_print_alloc_user,
478 static struct trace_event kmem_trace_free = {
479 .type = TRACE_KMEM_FREE,
480 .trace = kmemtrace_print_free,
481 .binary = kmemtrace_print_free_user,
484 static struct tracer kmem_tracer __read_mostly = {
486 .init = kmem_trace_init,
487 .reset = kmem_trace_reset,
488 .print_line = kmemtrace_print_line,
489 .print_header = kmemtrace_headers,
490 .flags = &kmem_tracer_flags
493 void kmemtrace_init(void)
495 /* earliest opportunity to start kmem tracing */
498 static int __init init_kmem_tracer(void)
500 if (!register_ftrace_event(&kmem_trace_alloc)) {
501 pr_warning("Warning: could not register kmem events\n");
505 if (!register_ftrace_event(&kmem_trace_free)) {
506 pr_warning("Warning: could not register kmem events\n");
510 if (register_tracer(&kmem_tracer) != 0) {
511 pr_warning("Warning: could not register the kmem tracer\n");
517 device_initcall(init_kmem_tracer);