blob: bbfc1bb1660b248758c85e2073999d1b5cce258f [file] [log] [blame]
Frederic Weisbecker36994e52008-12-29 13:42:23 -08001/*
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
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +02009#include <linux/tracepoint.h>
Ingo Molnarc826e3c2009-03-23 16:14:13 +010010#include <linux/seq_file.h>
11#include <linux/debugfs.h>
12#include <linux/dcache.h>
13#include <linux/fs.h>
14
Zhaolei02af61b2009-04-10 14:26:18 +080015#include <linux/kmemtrace.h>
Frederic Weisbecker36994e52008-12-29 13:42:23 -080016
Frederic Weisbecker36994e52008-12-29 13:42:23 -080017#include "trace_output.h"
Ingo Molnarc826e3c2009-03-23 16:14:13 +010018#include "trace.h"
Frederic Weisbecker36994e52008-12-29 13:42:23 -080019
20/* Select an alternative, minimalistic output than the original one */
21#define TRACE_KMEM_OPT_MINIMAL 0x1
22
23static struct tracer_opt kmem_opts[] = {
24 /* Default disable the minimalistic output */
25 { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
26 { }
27};
28
29static struct tracer_flags kmem_tracer_flags = {
Ingo Molnarc826e3c2009-03-23 16:14:13 +010030 .val = 0,
31 .opts = kmem_opts
Frederic Weisbecker36994e52008-12-29 13:42:23 -080032};
33
Frederic Weisbecker36994e52008-12-29 13:42:23 -080034static struct trace_array *kmemtrace_array;
35
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020036/* Trace allocations */
37static inline void kmemtrace_alloc(enum kmemtrace_type_id type_id,
38 unsigned long call_site,
39 const void *ptr,
40 size_t bytes_req,
41 size_t bytes_alloc,
42 gfp_t gfp_flags,
43 int node)
44{
Tom Zanussie1112b42009-03-31 00:48:49 -050045 struct ftrace_event_call *call = &event_kmem_alloc;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020046 struct trace_array *tr = kmemtrace_array;
Ingo Molnarc826e3c2009-03-23 16:14:13 +010047 struct kmemtrace_alloc_entry *entry;
48 struct ring_buffer_event *event;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020049
50 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
51 if (!event)
52 return;
Ingo Molnarc826e3c2009-03-23 16:14:13 +010053
54 entry = ring_buffer_event_data(event);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020055 tracing_generic_entry_update(&entry->ent, 0, 0);
56
Ingo Molnarc826e3c2009-03-23 16:14:13 +010057 entry->ent.type = TRACE_KMEM_ALLOC;
58 entry->type_id = type_id;
59 entry->call_site = call_site;
60 entry->ptr = ptr;
61 entry->bytes_req = bytes_req;
62 entry->bytes_alloc = bytes_alloc;
63 entry->gfp_flags = gfp_flags;
64 entry->node = node;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020065
Tom Zanussieb02ce02009-04-08 03:15:54 -050066 if (!filter_check_discard(call, entry, tr->buffer, event))
67 ring_buffer_unlock_commit(tr->buffer, event);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020068
69 trace_wake_up();
70}
71
72static inline void kmemtrace_free(enum kmemtrace_type_id type_id,
73 unsigned long call_site,
74 const void *ptr)
75{
Tom Zanussie1112b42009-03-31 00:48:49 -050076 struct ftrace_event_call *call = &event_kmem_free;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020077 struct trace_array *tr = kmemtrace_array;
Ingo Molnarc826e3c2009-03-23 16:14:13 +010078 struct kmemtrace_free_entry *entry;
79 struct ring_buffer_event *event;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020080
81 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
82 if (!event)
83 return;
84 entry = ring_buffer_event_data(event);
85 tracing_generic_entry_update(&entry->ent, 0, 0);
86
Ingo Molnarc826e3c2009-03-23 16:14:13 +010087 entry->ent.type = TRACE_KMEM_FREE;
88 entry->type_id = type_id;
89 entry->call_site = call_site;
90 entry->ptr = ptr;
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020091
Tom Zanussieb02ce02009-04-08 03:15:54 -050092 if (!filter_check_discard(call, entry, tr->buffer, event))
93 ring_buffer_unlock_commit(tr->buffer, event);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +020094
95 trace_wake_up();
96}
97
Steven Rostedt38516ab2010-04-20 17:04:50 -040098static void kmemtrace_kmalloc(void *ignore,
99 unsigned long call_site,
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200100 const void *ptr,
101 size_t bytes_req,
102 size_t bytes_alloc,
103 gfp_t gfp_flags)
104{
105 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
106 bytes_req, bytes_alloc, gfp_flags, -1);
107}
108
Steven Rostedt38516ab2010-04-20 17:04:50 -0400109static void kmemtrace_kmem_cache_alloc(void *ignore,
110 unsigned long call_site,
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200111 const void *ptr,
112 size_t bytes_req,
113 size_t bytes_alloc,
114 gfp_t gfp_flags)
115{
116 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
117 bytes_req, bytes_alloc, gfp_flags, -1);
118}
119
Steven Rostedt38516ab2010-04-20 17:04:50 -0400120static void kmemtrace_kmalloc_node(void *ignore,
121 unsigned long call_site,
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200122 const void *ptr,
123 size_t bytes_req,
124 size_t bytes_alloc,
125 gfp_t gfp_flags,
126 int node)
127{
128 kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
129 bytes_req, bytes_alloc, gfp_flags, node);
130}
131
Steven Rostedt38516ab2010-04-20 17:04:50 -0400132static void kmemtrace_kmem_cache_alloc_node(void *ignore,
133 unsigned long call_site,
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200134 const void *ptr,
135 size_t bytes_req,
136 size_t bytes_alloc,
137 gfp_t gfp_flags,
138 int node)
139{
140 kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
141 bytes_req, bytes_alloc, gfp_flags, node);
142}
143
Steven Rostedt38516ab2010-04-20 17:04:50 -0400144static void
145kmemtrace_kfree(void *ignore, unsigned long call_site, const void *ptr)
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200146{
147 kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
148}
149
Steven Rostedt38516ab2010-04-20 17:04:50 -0400150static void kmemtrace_kmem_cache_free(void *ignore,
151 unsigned long call_site, const void *ptr)
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200152{
153 kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
154}
155
156static int kmemtrace_start_probes(void)
157{
158 int err;
159
Steven Rostedt38516ab2010-04-20 17:04:50 -0400160 err = register_trace_kmalloc(kmemtrace_kmalloc, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200161 if (err)
162 return err;
Steven Rostedt38516ab2010-04-20 17:04:50 -0400163 err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200164 if (err)
165 return err;
Steven Rostedt38516ab2010-04-20 17:04:50 -0400166 err = register_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200167 if (err)
168 return err;
Steven Rostedt38516ab2010-04-20 17:04:50 -0400169 err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200170 if (err)
171 return err;
Steven Rostedt38516ab2010-04-20 17:04:50 -0400172 err = register_trace_kfree(kmemtrace_kfree, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200173 if (err)
174 return err;
Steven Rostedt38516ab2010-04-20 17:04:50 -0400175 err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200176
177 return err;
178}
179
180static void kmemtrace_stop_probes(void)
181{
Steven Rostedt38516ab2010-04-20 17:04:50 -0400182 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);
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200188}
189
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800190static int kmem_trace_init(struct trace_array *tr)
191{
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800192 kmemtrace_array = tr;
193
Steven Rostedt76f0d072009-09-04 12:12:39 -0400194 tracing_reset_online_cpus(tr);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800195
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200196 kmemtrace_start_probes();
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800197
198 return 0;
199}
200
201static void kmem_trace_reset(struct trace_array *tr)
202{
Eduard - Gabriel Munteanuca2b84c2009-03-23 15:12:24 +0200203 kmemtrace_stop_probes();
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800204}
205
206static void kmemtrace_headers(struct seq_file *s)
207{
208 /* Don't need headers for the original kmemtrace output */
209 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
210 return;
211
212 seq_printf(s, "#\n");
213 seq_printf(s, "# ALLOC TYPE REQ GIVEN FLAGS "
214 " POINTER NODE CALLER\n");
215 seq_printf(s, "# FREE | | | | "
216 " | | | |\n");
217 seq_printf(s, "# |\n\n");
218}
219
220/*
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200221 * The following functions give the original output from kmemtrace,
222 * plus the origin CPU, since reordering occurs in-kernel now.
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800223 */
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200224
225#define KMEMTRACE_USER_ALLOC 0
226#define KMEMTRACE_USER_FREE 1
227
228struct kmemtrace_user_event {
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100229 u8 event_id;
230 u8 type_id;
231 u16 event_size;
232 u32 cpu;
233 u64 timestamp;
234 unsigned long call_site;
235 unsigned long ptr;
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200236};
237
238struct kmemtrace_user_event_alloc {
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100239 size_t bytes_req;
240 size_t bytes_alloc;
241 unsigned gfp_flags;
242 int node;
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200243};
244
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800245static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400246kmemtrace_print_alloc(struct trace_iterator *iter, int flags,
247 struct trace_event *event)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800248{
249 struct trace_seq *s = &iter->seq;
Li Zefanddc16372009-07-03 17:34:24 +0800250 struct kmemtrace_alloc_entry *entry;
251 int ret;
252
253 trace_assign_type(entry, iter->ent);
254
255 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu "
256 "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
257 entry->type_id, (void *)entry->call_site, (unsigned long)entry->ptr,
258 (unsigned long)entry->bytes_req, (unsigned long)entry->bytes_alloc,
259 (unsigned long)entry->gfp_flags, entry->node);
260
261 if (!ret)
262 return TRACE_TYPE_PARTIAL_LINE;
263 return TRACE_TYPE_HANDLED;
264}
265
266static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400267kmemtrace_print_free(struct trace_iterator *iter, int flags,
268 struct trace_event *event)
Li Zefanddc16372009-07-03 17:34:24 +0800269{
270 struct trace_seq *s = &iter->seq;
271 struct kmemtrace_free_entry *entry;
272 int ret;
273
274 trace_assign_type(entry, iter->ent);
275
276 ret = trace_seq_printf(s, "type_id %d call_site %pF ptr %lu\n",
277 entry->type_id, (void *)entry->call_site,
278 (unsigned long)entry->ptr);
279
280 if (!ret)
281 return TRACE_TYPE_PARTIAL_LINE;
282 return TRACE_TYPE_HANDLED;
283}
284
285static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400286kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags,
287 struct trace_event *event)
Li Zefanddc16372009-07-03 17:34:24 +0800288{
289 struct trace_seq *s = &iter->seq;
290 struct kmemtrace_alloc_entry *entry;
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200291 struct kmemtrace_user_event *ev;
Li Zefanddc16372009-07-03 17:34:24 +0800292 struct kmemtrace_user_event_alloc *ev_alloc;
293
294 trace_assign_type(entry, iter->ent);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800295
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200296 ev = trace_seq_reserve(s, sizeof(*ev));
297 if (!ev)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800298 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100299
300 ev->event_id = KMEMTRACE_USER_ALLOC;
301 ev->type_id = entry->type_id;
302 ev->event_size = sizeof(*ev) + sizeof(*ev_alloc);
303 ev->cpu = iter->cpu;
304 ev->timestamp = iter->ts;
305 ev->call_site = entry->call_site;
306 ev->ptr = (unsigned long)entry->ptr;
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200307
308 ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc));
309 if (!ev_alloc)
310 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100311
312 ev_alloc->bytes_req = entry->bytes_req;
313 ev_alloc->bytes_alloc = entry->bytes_alloc;
314 ev_alloc->gfp_flags = entry->gfp_flags;
315 ev_alloc->node = entry->node;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800316
317 return TRACE_TYPE_HANDLED;
318}
319
320static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400321kmemtrace_print_free_user(struct trace_iterator *iter, int flags,
322 struct trace_event *event)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800323{
324 struct trace_seq *s = &iter->seq;
Li Zefanddc16372009-07-03 17:34:24 +0800325 struct kmemtrace_free_entry *entry;
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200326 struct kmemtrace_user_event *ev;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800327
Li Zefanddc16372009-07-03 17:34:24 +0800328 trace_assign_type(entry, iter->ent);
329
Eduard - Gabriel Munteanu42af9052009-03-23 15:12:26 +0200330 ev = trace_seq_reserve(s, sizeof(*ev));
331 if (!ev)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800332 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100333
334 ev->event_id = KMEMTRACE_USER_FREE;
335 ev->type_id = entry->type_id;
336 ev->event_size = sizeof(*ev);
337 ev->cpu = iter->cpu;
338 ev->timestamp = iter->ts;
339 ev->call_site = entry->call_site;
340 ev->ptr = (unsigned long)entry->ptr;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800341
342 return TRACE_TYPE_HANDLED;
343}
344
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800345/* The two other following provide a more minimalistic output */
346static enum print_line_t
Li Zefanddc16372009-07-03 17:34:24 +0800347kmemtrace_print_alloc_compress(struct trace_iterator *iter)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800348{
Li Zefanddc16372009-07-03 17:34:24 +0800349 struct kmemtrace_alloc_entry *entry;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800350 struct trace_seq *s = &iter->seq;
351 int ret;
352
Li Zefanddc16372009-07-03 17:34:24 +0800353 trace_assign_type(entry, iter->ent);
354
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800355 /* Alloc entry */
356 ret = trace_seq_printf(s, " + ");
357 if (!ret)
358 return TRACE_TYPE_PARTIAL_LINE;
359
360 /* Type */
361 switch (entry->type_id) {
362 case KMEMTRACE_TYPE_KMALLOC:
363 ret = trace_seq_printf(s, "K ");
364 break;
365 case KMEMTRACE_TYPE_CACHE:
366 ret = trace_seq_printf(s, "C ");
367 break;
368 case KMEMTRACE_TYPE_PAGES:
369 ret = trace_seq_printf(s, "P ");
370 break;
371 default:
372 ret = trace_seq_printf(s, "? ");
373 }
374
375 if (!ret)
376 return TRACE_TYPE_PARTIAL_LINE;
377
378 /* Requested */
Randy Dunlapecf441b2009-01-29 13:49:45 -0800379 ret = trace_seq_printf(s, "%4zu ", entry->bytes_req);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800380 if (!ret)
381 return TRACE_TYPE_PARTIAL_LINE;
382
383 /* Allocated */
Randy Dunlapecf441b2009-01-29 13:49:45 -0800384 ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800385 if (!ret)
386 return TRACE_TYPE_PARTIAL_LINE;
387
388 /* Flags
389 * TODO: would be better to see the name of the GFP flag names
390 */
391 ret = trace_seq_printf(s, "%08x ", entry->gfp_flags);
392 if (!ret)
393 return TRACE_TYPE_PARTIAL_LINE;
394
395 /* Pointer to allocated */
396 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
397 if (!ret)
398 return TRACE_TYPE_PARTIAL_LINE;
399
Frederic Weisbecker6a167c62009-07-09 04:46:30 +0200400 /* Node and call site*/
401 ret = trace_seq_printf(s, "%4d %pf\n", entry->node,
402 (void *)entry->call_site);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800403 if (!ret)
404 return TRACE_TYPE_PARTIAL_LINE;
405
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800406 return TRACE_TYPE_HANDLED;
407}
408
409static enum print_line_t
Li Zefanddc16372009-07-03 17:34:24 +0800410kmemtrace_print_free_compress(struct trace_iterator *iter)
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800411{
Li Zefanddc16372009-07-03 17:34:24 +0800412 struct kmemtrace_free_entry *entry;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800413 struct trace_seq *s = &iter->seq;
414 int ret;
415
Li Zefanddc16372009-07-03 17:34:24 +0800416 trace_assign_type(entry, iter->ent);
417
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800418 /* Free entry */
419 ret = trace_seq_printf(s, " - ");
420 if (!ret)
421 return TRACE_TYPE_PARTIAL_LINE;
422
423 /* Type */
424 switch (entry->type_id) {
425 case KMEMTRACE_TYPE_KMALLOC:
426 ret = trace_seq_printf(s, "K ");
427 break;
428 case KMEMTRACE_TYPE_CACHE:
429 ret = trace_seq_printf(s, "C ");
430 break;
431 case KMEMTRACE_TYPE_PAGES:
432 ret = trace_seq_printf(s, "P ");
433 break;
434 default:
435 ret = trace_seq_printf(s, "? ");
436 }
437
438 if (!ret)
439 return TRACE_TYPE_PARTIAL_LINE;
440
441 /* Skip requested/allocated/flags */
442 ret = trace_seq_printf(s, " ");
443 if (!ret)
444 return TRACE_TYPE_PARTIAL_LINE;
445
446 /* Pointer to allocated */
447 ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr);
448 if (!ret)
449 return TRACE_TYPE_PARTIAL_LINE;
450
Frederic Weisbecker6a167c62009-07-09 04:46:30 +0200451 /* Skip node and print call site*/
452 ret = trace_seq_printf(s, " %pf\n", (void *)entry->call_site);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800453 if (!ret)
454 return TRACE_TYPE_PARTIAL_LINE;
455
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800456 return TRACE_TYPE_HANDLED;
457}
458
459static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
460{
461 struct trace_entry *entry = iter->ent;
462
Li Zefanddc16372009-07-03 17:34:24 +0800463 if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
464 return TRACE_TYPE_UNHANDLED;
465
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800466 switch (entry->type) {
Li Zefanddc16372009-07-03 17:34:24 +0800467 case TRACE_KMEM_ALLOC:
468 return kmemtrace_print_alloc_compress(iter);
469 case TRACE_KMEM_FREE:
470 return kmemtrace_print_free_compress(iter);
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800471 default:
472 return TRACE_TYPE_UNHANDLED;
473 }
474}
475
Steven Rostedta9a57762010-04-22 18:46:14 -0400476static struct trace_event_functions kmem_trace_alloc_funcs = {
Li Zefan80098c22009-07-06 16:15:04 +0800477 .trace = kmemtrace_print_alloc,
478 .binary = kmemtrace_print_alloc_user,
Li Zefanddc16372009-07-03 17:34:24 +0800479};
480
Steven Rostedta9a57762010-04-22 18:46:14 -0400481static struct trace_event kmem_trace_alloc = {
482 .type = TRACE_KMEM_ALLOC,
483 .funcs = &kmem_trace_alloc_funcs,
484};
485
486static struct trace_event_functions kmem_trace_free_funcs = {
Li Zefan80098c22009-07-06 16:15:04 +0800487 .trace = kmemtrace_print_free,
488 .binary = kmemtrace_print_free_user,
Li Zefanddc16372009-07-03 17:34:24 +0800489};
490
Steven Rostedta9a57762010-04-22 18:46:14 -0400491static struct trace_event kmem_trace_free = {
492 .type = TRACE_KMEM_FREE,
493 .funcs = &kmem_trace_free_funcs,
494};
495
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800496static struct tracer kmem_tracer __read_mostly = {
Ingo Molnarc826e3c2009-03-23 16:14:13 +0100497 .name = "kmemtrace",
498 .init = kmem_trace_init,
499 .reset = kmem_trace_reset,
500 .print_line = kmemtrace_print_line,
501 .print_header = kmemtrace_headers,
502 .flags = &kmem_tracer_flags
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800503};
504
Ingo Molnar3e806802009-01-06 10:16:35 +0100505void kmemtrace_init(void)
506{
507 /* earliest opportunity to start kmem tracing */
508}
509
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800510static int __init init_kmem_tracer(void)
511{
Li Zefanddc16372009-07-03 17:34:24 +0800512 if (!register_ftrace_event(&kmem_trace_alloc)) {
513 pr_warning("Warning: could not register kmem events\n");
514 return 1;
515 }
516
517 if (!register_ftrace_event(&kmem_trace_free)) {
518 pr_warning("Warning: could not register kmem events\n");
519 return 1;
520 }
521
Paul Mundtf9ac5a62009-09-28 16:55:40 +0900522 if (register_tracer(&kmem_tracer) != 0) {
Li Zefanddc16372009-07-03 17:34:24 +0800523 pr_warning("Warning: could not register the kmem tracer\n");
524 return 1;
525 }
526
527 return 0;
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800528}
Frederic Weisbecker36994e52008-12-29 13:42:23 -0800529device_initcall(init_kmem_tracer);