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 | ||
c826e3cd IM |
9 | #include <linux/tracepoint.h> |
10 | #include <linux/seq_file.h> | |
36994e58 | 11 | #include <linux/debugfs.h> |
c826e3cd | 12 | #include <linux/dcache.h> |
36994e58 | 13 | #include <linux/fs.h> |
c826e3cd | 14 | |
02af61bb | 15 | #include <linux/kmemtrace.h> |
36994e58 | 16 | |
36994e58 | 17 | #include "trace_output.h" |
c826e3cd | 18 | #include "trace.h" |
36994e58 FW |
19 | |
20 | /* Select an alternative, minimalistic output than the original one */ | |
21 | #define TRACE_KMEM_OPT_MINIMAL 0x1 | |
22 | ||
23 | static struct tracer_opt kmem_opts[] = { | |
24 | /* Default disable the minimalistic output */ | |
25 | { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) }, | |
26 | { } | |
27 | }; | |
28 | ||
29 | static struct tracer_flags kmem_tracer_flags = { | |
c826e3cd IM |
30 | .val = 0, |
31 | .opts = kmem_opts | |
36994e58 FW |
32 | }; |
33 | ||
36994e58 FW |
34 | static struct trace_array *kmemtrace_array; |
35 | ||
ca2b84cb EGM |
36 | /* Trace allocations */ |
37 | static 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 | { | |
e1112b4d | 45 | struct ftrace_event_call *call = &event_kmem_alloc; |
ca2b84cb | 46 | struct trace_array *tr = kmemtrace_array; |
c826e3cd IM |
47 | struct kmemtrace_alloc_entry *entry; |
48 | struct ring_buffer_event *event; | |
ca2b84cb EGM |
49 | |
50 | event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry)); | |
51 | if (!event) | |
52 | return; | |
c826e3cd IM |
53 | |
54 | entry = ring_buffer_event_data(event); | |
ca2b84cb EGM |
55 | tracing_generic_entry_update(&entry->ent, 0, 0); |
56 | ||
c826e3cd IM |
57 | 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; | |
ca2b84cb | 65 | |
eb02ce01 TZ |
66 | if (!filter_check_discard(call, entry, tr->buffer, event)) |
67 | ring_buffer_unlock_commit(tr->buffer, event); | |
ca2b84cb EGM |
68 | |
69 | trace_wake_up(); | |
70 | } | |
71 | ||
72 | static inline void kmemtrace_free(enum kmemtrace_type_id type_id, | |
73 | unsigned long call_site, | |
74 | const void *ptr) | |
75 | { | |
e1112b4d | 76 | struct ftrace_event_call *call = &event_kmem_free; |
ca2b84cb | 77 | struct trace_array *tr = kmemtrace_array; |
c826e3cd IM |
78 | struct kmemtrace_free_entry *entry; |
79 | struct ring_buffer_event *event; | |
ca2b84cb EGM |
80 | |
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 | ||
c826e3cd IM |
87 | entry->ent.type = TRACE_KMEM_FREE; |
88 | entry->type_id = type_id; | |
89 | entry->call_site = call_site; | |
90 | entry->ptr = ptr; | |
ca2b84cb | 91 | |
eb02ce01 TZ |
92 | if (!filter_check_discard(call, entry, tr->buffer, event)) |
93 | ring_buffer_unlock_commit(tr->buffer, event); | |
ca2b84cb EGM |
94 | |
95 | trace_wake_up(); | |
96 | } | |
97 | ||
38516ab5 SR |
98 | static void kmemtrace_kmalloc(void *ignore, |
99 | unsigned long call_site, | |
ca2b84cb EGM |
100 | 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 | ||
38516ab5 SR |
109 | static void kmemtrace_kmem_cache_alloc(void *ignore, |
110 | unsigned long call_site, | |
ca2b84cb EGM |
111 | 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 | ||
38516ab5 SR |
120 | static void kmemtrace_kmalloc_node(void *ignore, |
121 | unsigned long call_site, | |
ca2b84cb EGM |
122 | 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 | ||
38516ab5 SR |
132 | static void kmemtrace_kmem_cache_alloc_node(void *ignore, |
133 | unsigned long call_site, | |
ca2b84cb EGM |
134 | 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 | ||
38516ab5 SR |
144 | static void |
145 | kmemtrace_kfree(void *ignore, unsigned long call_site, const void *ptr) | |
ca2b84cb EGM |
146 | { |
147 | kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr); | |
148 | } | |
149 | ||
38516ab5 SR |
150 | static void kmemtrace_kmem_cache_free(void *ignore, |
151 | unsigned long call_site, const void *ptr) | |
ca2b84cb EGM |
152 | { |
153 | kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr); | |
154 | } | |
155 | ||
156 | static int kmemtrace_start_probes(void) | |
157 | { | |
158 | int err; | |
159 | ||
38516ab5 | 160 | err = register_trace_kmalloc(kmemtrace_kmalloc, NULL); |
ca2b84cb EGM |
161 | if (err) |
162 | return err; | |
38516ab5 | 163 | err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL); |
ca2b84cb EGM |
164 | if (err) |
165 | return err; | |
38516ab5 | 166 | err = register_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL); |
ca2b84cb EGM |
167 | if (err) |
168 | return err; | |
38516ab5 | 169 | err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL); |
ca2b84cb EGM |
170 | if (err) |
171 | return err; | |
38516ab5 | 172 | err = register_trace_kfree(kmemtrace_kfree, NULL); |
ca2b84cb EGM |
173 | if (err) |
174 | return err; | |
38516ab5 | 175 | err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL); |
ca2b84cb EGM |
176 | |
177 | return err; | |
178 | } | |
179 | ||
180 | static void kmemtrace_stop_probes(void) | |
181 | { | |
38516ab5 SR |
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); | |
ca2b84cb EGM |
188 | } |
189 | ||
36994e58 FW |
190 | static int kmem_trace_init(struct trace_array *tr) |
191 | { | |
36994e58 FW |
192 | kmemtrace_array = tr; |
193 | ||
76f0d073 | 194 | tracing_reset_online_cpus(tr); |
36994e58 | 195 | |
ca2b84cb | 196 | kmemtrace_start_probes(); |
36994e58 FW |
197 | |
198 | return 0; | |
199 | } | |
200 | ||
201 | static void kmem_trace_reset(struct trace_array *tr) | |
202 | { | |
ca2b84cb | 203 | kmemtrace_stop_probes(); |
36994e58 FW |
204 | } |
205 | ||
206 | static 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 | /* | |
42af9054 EGM |
221 | * The following functions give the original output from kmemtrace, |
222 | * plus the origin CPU, since reordering occurs in-kernel now. | |
36994e58 | 223 | */ |
42af9054 EGM |
224 | |
225 | #define KMEMTRACE_USER_ALLOC 0 | |
226 | #define KMEMTRACE_USER_FREE 1 | |
227 | ||
228 | struct kmemtrace_user_event { | |
c826e3cd IM |
229 | 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; | |
42af9054 EGM |
236 | }; |
237 | ||
238 | struct kmemtrace_user_event_alloc { | |
c826e3cd IM |
239 | size_t bytes_req; |
240 | size_t bytes_alloc; | |
241 | unsigned gfp_flags; | |
242 | int node; | |
42af9054 EGM |
243 | }; |
244 | ||
36994e58 | 245 | static enum print_line_t |
80098c20 | 246 | kmemtrace_print_alloc(struct trace_iterator *iter, int flags) |
ddc1637a LZ |
247 | { |
248 | struct trace_seq *s = &iter->seq; | |
249 | struct kmemtrace_alloc_entry *entry; | |
250 | int ret; | |
251 | ||
252 | trace_assign_type(entry, iter->ent); | |
253 | ||
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); | |
259 | ||
260 | if (!ret) | |
261 | return TRACE_TYPE_PARTIAL_LINE; | |
262 | return TRACE_TYPE_HANDLED; | |
263 | } | |
264 | ||
265 | static enum print_line_t | |
80098c20 | 266 | kmemtrace_print_free(struct trace_iterator *iter, int flags) |
36994e58 FW |
267 | { |
268 | struct trace_seq *s = &iter->seq; | |
ddc1637a LZ |
269 | struct kmemtrace_free_entry *entry; |
270 | int ret; | |
271 | ||
272 | trace_assign_type(entry, iter->ent); | |
273 | ||
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); | |
277 | ||
278 | if (!ret) | |
279 | return TRACE_TYPE_PARTIAL_LINE; | |
280 | return TRACE_TYPE_HANDLED; | |
281 | } | |
282 | ||
283 | static enum print_line_t | |
80098c20 | 284 | kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags) |
ddc1637a LZ |
285 | { |
286 | struct trace_seq *s = &iter->seq; | |
287 | struct kmemtrace_alloc_entry *entry; | |
42af9054 | 288 | struct kmemtrace_user_event *ev; |
ddc1637a LZ |
289 | struct kmemtrace_user_event_alloc *ev_alloc; |
290 | ||
291 | trace_assign_type(entry, iter->ent); | |
36994e58 | 292 | |
42af9054 EGM |
293 | ev = trace_seq_reserve(s, sizeof(*ev)); |
294 | if (!ev) | |
295 | return TRACE_TYPE_PARTIAL_LINE; | |
c826e3cd IM |
296 | |
297 | ev->event_id = KMEMTRACE_USER_ALLOC; | |
298 | ev->type_id = entry->type_id; | |
299 | ev->event_size = sizeof(*ev) + sizeof(*ev_alloc); | |
300 | ev->cpu = iter->cpu; | |
301 | ev->timestamp = iter->ts; | |
302 | ev->call_site = entry->call_site; | |
303 | ev->ptr = (unsigned long)entry->ptr; | |
42af9054 EGM |
304 | |
305 | ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc)); | |
306 | if (!ev_alloc) | |
36994e58 | 307 | return TRACE_TYPE_PARTIAL_LINE; |
c826e3cd IM |
308 | |
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; | |
36994e58 FW |
313 | |
314 | return TRACE_TYPE_HANDLED; | |
315 | } | |
316 | ||
317 | static enum print_line_t | |
80098c20 | 318 | kmemtrace_print_free_user(struct trace_iterator *iter, int flags) |
36994e58 FW |
319 | { |
320 | struct trace_seq *s = &iter->seq; | |
ddc1637a | 321 | struct kmemtrace_free_entry *entry; |
42af9054 | 322 | struct kmemtrace_user_event *ev; |
36994e58 | 323 | |
ddc1637a LZ |
324 | trace_assign_type(entry, iter->ent); |
325 | ||
42af9054 EGM |
326 | ev = trace_seq_reserve(s, sizeof(*ev)); |
327 | if (!ev) | |
36994e58 | 328 | return TRACE_TYPE_PARTIAL_LINE; |
c826e3cd IM |
329 | |
330 | ev->event_id = KMEMTRACE_USER_FREE; | |
331 | ev->type_id = entry->type_id; | |
332 | ev->event_size = sizeof(*ev); | |
333 | ev->cpu = iter->cpu; | |
334 | ev->timestamp = iter->ts; | |
335 | ev->call_site = entry->call_site; | |
336 | ev->ptr = (unsigned long)entry->ptr; | |
36994e58 FW |
337 | |
338 | return TRACE_TYPE_HANDLED; | |
339 | } | |
340 | ||
36994e58 FW |
341 | /* The two other following provide a more minimalistic output */ |
342 | static enum print_line_t | |
ddc1637a | 343 | kmemtrace_print_alloc_compress(struct trace_iterator *iter) |
36994e58 | 344 | { |
ddc1637a | 345 | struct kmemtrace_alloc_entry *entry; |
36994e58 FW |
346 | struct trace_seq *s = &iter->seq; |
347 | int ret; | |
348 | ||
ddc1637a LZ |
349 | trace_assign_type(entry, iter->ent); |
350 | ||
36994e58 FW |
351 | /* Alloc entry */ |
352 | ret = trace_seq_printf(s, " + "); | |
353 | if (!ret) | |
354 | return TRACE_TYPE_PARTIAL_LINE; | |
355 | ||
356 | /* Type */ | |
357 | switch (entry->type_id) { | |
358 | case KMEMTRACE_TYPE_KMALLOC: | |
359 | ret = trace_seq_printf(s, "K "); | |
360 | break; | |
361 | case KMEMTRACE_TYPE_CACHE: | |
362 | ret = trace_seq_printf(s, "C "); | |
363 | break; | |
364 | case KMEMTRACE_TYPE_PAGES: | |
365 | ret = trace_seq_printf(s, "P "); | |
366 | break; | |
367 | default: | |
368 | ret = trace_seq_printf(s, "? "); | |
369 | } | |
370 | ||
371 | if (!ret) | |
372 | return TRACE_TYPE_PARTIAL_LINE; | |
373 | ||
374 | /* Requested */ | |
ecf441b5 | 375 | ret = trace_seq_printf(s, "%4zu ", entry->bytes_req); |
36994e58 FW |
376 | if (!ret) |
377 | return TRACE_TYPE_PARTIAL_LINE; | |
378 | ||
379 | /* Allocated */ | |
ecf441b5 | 380 | ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc); |
36994e58 FW |
381 | if (!ret) |
382 | return TRACE_TYPE_PARTIAL_LINE; | |
383 | ||
384 | /* Flags | |
385 | * TODO: would be better to see the name of the GFP flag names | |
386 | */ | |
387 | ret = trace_seq_printf(s, "%08x ", entry->gfp_flags); | |
388 | if (!ret) | |
389 | return TRACE_TYPE_PARTIAL_LINE; | |
390 | ||
391 | /* Pointer to allocated */ | |
392 | ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr); | |
393 | if (!ret) | |
394 | return TRACE_TYPE_PARTIAL_LINE; | |
395 | ||
6a167c65 FW |
396 | /* Node and call site*/ |
397 | ret = trace_seq_printf(s, "%4d %pf\n", entry->node, | |
398 | (void *)entry->call_site); | |
36994e58 FW |
399 | if (!ret) |
400 | return TRACE_TYPE_PARTIAL_LINE; | |
401 | ||
36994e58 FW |
402 | return TRACE_TYPE_HANDLED; |
403 | } | |
404 | ||
405 | static enum print_line_t | |
ddc1637a | 406 | kmemtrace_print_free_compress(struct trace_iterator *iter) |
36994e58 | 407 | { |
ddc1637a | 408 | struct kmemtrace_free_entry *entry; |
36994e58 FW |
409 | struct trace_seq *s = &iter->seq; |
410 | int ret; | |
411 | ||
ddc1637a LZ |
412 | trace_assign_type(entry, iter->ent); |
413 | ||
36994e58 FW |
414 | /* Free entry */ |
415 | ret = trace_seq_printf(s, " - "); | |
416 | if (!ret) | |
417 | return TRACE_TYPE_PARTIAL_LINE; | |
418 | ||
419 | /* Type */ | |
420 | switch (entry->type_id) { | |
421 | case KMEMTRACE_TYPE_KMALLOC: | |
422 | ret = trace_seq_printf(s, "K "); | |
423 | break; | |
424 | case KMEMTRACE_TYPE_CACHE: | |
425 | ret = trace_seq_printf(s, "C "); | |
426 | break; | |
427 | case KMEMTRACE_TYPE_PAGES: | |
428 | ret = trace_seq_printf(s, "P "); | |
429 | break; | |
430 | default: | |
431 | ret = trace_seq_printf(s, "? "); | |
432 | } | |
433 | ||
434 | if (!ret) | |
435 | return TRACE_TYPE_PARTIAL_LINE; | |
436 | ||
437 | /* Skip requested/allocated/flags */ | |
438 | ret = trace_seq_printf(s, " "); | |
439 | if (!ret) | |
440 | return TRACE_TYPE_PARTIAL_LINE; | |
441 | ||
442 | /* Pointer to allocated */ | |
443 | ret = trace_seq_printf(s, "0x%tx ", (ptrdiff_t)entry->ptr); | |
444 | if (!ret) | |
445 | return TRACE_TYPE_PARTIAL_LINE; | |
446 | ||
6a167c65 FW |
447 | /* Skip node and print call site*/ |
448 | ret = trace_seq_printf(s, " %pf\n", (void *)entry->call_site); | |
36994e58 FW |
449 | if (!ret) |
450 | return TRACE_TYPE_PARTIAL_LINE; | |
451 | ||
36994e58 FW |
452 | return TRACE_TYPE_HANDLED; |
453 | } | |
454 | ||
455 | static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter) | |
456 | { | |
457 | struct trace_entry *entry = iter->ent; | |
458 | ||
ddc1637a LZ |
459 | if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)) |
460 | return TRACE_TYPE_UNHANDLED; | |
36994e58 | 461 | |
ddc1637a LZ |
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); | |
36994e58 FW |
467 | default: |
468 | return TRACE_TYPE_UNHANDLED; | |
469 | } | |
470 | } | |
471 | ||
ddc1637a LZ |
472 | static struct trace_event kmem_trace_alloc = { |
473 | .type = TRACE_KMEM_ALLOC, | |
80098c20 LZ |
474 | .trace = kmemtrace_print_alloc, |
475 | .binary = kmemtrace_print_alloc_user, | |
ddc1637a LZ |
476 | }; |
477 | ||
478 | static struct trace_event kmem_trace_free = { | |
479 | .type = TRACE_KMEM_FREE, | |
80098c20 LZ |
480 | .trace = kmemtrace_print_free, |
481 | .binary = kmemtrace_print_free_user, | |
ddc1637a LZ |
482 | }; |
483 | ||
36994e58 | 484 | static struct tracer kmem_tracer __read_mostly = { |
c826e3cd IM |
485 | .name = "kmemtrace", |
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 | |
36994e58 FW |
491 | }; |
492 | ||
3e806802 IM |
493 | void kmemtrace_init(void) |
494 | { | |
495 | /* earliest opportunity to start kmem tracing */ | |
496 | } | |
497 | ||
36994e58 FW |
498 | static int __init init_kmem_tracer(void) |
499 | { | |
ddc1637a LZ |
500 | if (!register_ftrace_event(&kmem_trace_alloc)) { |
501 | pr_warning("Warning: could not register kmem events\n"); | |
502 | return 1; | |
503 | } | |
504 | ||
505 | if (!register_ftrace_event(&kmem_trace_free)) { | |
506 | pr_warning("Warning: could not register kmem events\n"); | |
507 | return 1; | |
508 | } | |
509 | ||
f9ac5a69 | 510 | if (register_tracer(&kmem_tracer) != 0) { |
ddc1637a LZ |
511 | pr_warning("Warning: could not register the kmem tracer\n"); |
512 | return 1; | |
513 | } | |
514 | ||
515 | return 0; | |
36994e58 | 516 | } |
36994e58 | 517 | device_initcall(init_kmem_tracer); |