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