Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 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 | |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 9 | #include <linux/tracepoint.h> |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 10 | #include <linux/seq_file.h> |
| 11 | #include <linux/debugfs.h> |
| 12 | #include <linux/dcache.h> |
| 13 | #include <linux/fs.h> |
| 14 | |
Zhaolei | 02af61b | 2009-04-10 14:26:18 +0800 | [diff] [blame] | 15 | #include <linux/kmemtrace.h> |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 16 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 17 | #include "trace_output.h" |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 18 | #include "trace.h" |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 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 = { |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 30 | .val = 0, |
| 31 | .opts = kmem_opts |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 32 | }; |
| 33 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 34 | static struct trace_array *kmemtrace_array; |
| 35 | |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | { |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 45 | struct ftrace_event_call *call = &event_kmem_alloc; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 46 | struct trace_array *tr = kmemtrace_array; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 47 | struct kmemtrace_alloc_entry *entry; |
| 48 | struct ring_buffer_event *event; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 49 | |
| 50 | event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry)); |
| 51 | if (!event) |
| 52 | return; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 53 | |
| 54 | entry = ring_buffer_event_data(event); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 55 | tracing_generic_entry_update(&entry->ent, 0, 0); |
| 56 | |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 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; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 65 | |
Tom Zanussi | eb02ce0 | 2009-04-08 03:15:54 -0500 | [diff] [blame] | 66 | if (!filter_check_discard(call, entry, tr->buffer, event)) |
| 67 | ring_buffer_unlock_commit(tr->buffer, event); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | { |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 76 | struct ftrace_event_call *call = &event_kmem_free; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 77 | struct trace_array *tr = kmemtrace_array; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 78 | struct kmemtrace_free_entry *entry; |
| 79 | struct ring_buffer_event *event; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 87 | entry->ent.type = TRACE_KMEM_FREE; |
| 88 | entry->type_id = type_id; |
| 89 | entry->call_site = call_site; |
| 90 | entry->ptr = ptr; |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 91 | |
Tom Zanussi | eb02ce0 | 2009-04-08 03:15:54 -0500 | [diff] [blame] | 92 | if (!filter_check_discard(call, entry, tr->buffer, event)) |
| 93 | ring_buffer_unlock_commit(tr->buffer, event); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 94 | |
| 95 | trace_wake_up(); |
| 96 | } |
| 97 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 98 | static void kmemtrace_kmalloc(void *ignore, |
| 99 | unsigned long call_site, |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 109 | static void kmemtrace_kmem_cache_alloc(void *ignore, |
| 110 | unsigned long call_site, |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 120 | static void kmemtrace_kmalloc_node(void *ignore, |
| 121 | unsigned long call_site, |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 132 | static void kmemtrace_kmem_cache_alloc_node(void *ignore, |
| 133 | unsigned long call_site, |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 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 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 144 | static void |
| 145 | kmemtrace_kfree(void *ignore, unsigned long call_site, const void *ptr) |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 146 | { |
| 147 | kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr); |
| 148 | } |
| 149 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 150 | static void kmemtrace_kmem_cache_free(void *ignore, |
| 151 | unsigned long call_site, const void *ptr) |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 152 | { |
| 153 | kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr); |
| 154 | } |
| 155 | |
| 156 | static int kmemtrace_start_probes(void) |
| 157 | { |
| 158 | int err; |
| 159 | |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 160 | err = register_trace_kmalloc(kmemtrace_kmalloc, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 161 | if (err) |
| 162 | return err; |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 163 | err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 164 | if (err) |
| 165 | return err; |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 166 | err = register_trace_kmalloc_node(kmemtrace_kmalloc_node, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 167 | if (err) |
| 168 | return err; |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 169 | err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 170 | if (err) |
| 171 | return err; |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 172 | err = register_trace_kfree(kmemtrace_kfree, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 173 | if (err) |
| 174 | return err; |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 175 | err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free, NULL); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 176 | |
| 177 | return err; |
| 178 | } |
| 179 | |
| 180 | static void kmemtrace_stop_probes(void) |
| 181 | { |
Steven Rostedt | 38516ab | 2010-04-20 17:04:50 -0400 | [diff] [blame] | 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); |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 188 | } |
| 189 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 190 | static int kmem_trace_init(struct trace_array *tr) |
| 191 | { |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 192 | kmemtrace_array = tr; |
| 193 | |
Steven Rostedt | 76f0d07 | 2009-09-04 12:12:39 -0400 | [diff] [blame] | 194 | tracing_reset_online_cpus(tr); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 195 | |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 196 | kmemtrace_start_probes(); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 197 | |
| 198 | return 0; |
| 199 | } |
| 200 | |
| 201 | static void kmem_trace_reset(struct trace_array *tr) |
| 202 | { |
Eduard - Gabriel Munteanu | ca2b84c | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 203 | kmemtrace_stop_probes(); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 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 | /* |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 221 | * The following functions give the original output from kmemtrace, |
| 222 | * plus the origin CPU, since reordering occurs in-kernel now. |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 223 | */ |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 224 | |
| 225 | #define KMEMTRACE_USER_ALLOC 0 |
| 226 | #define KMEMTRACE_USER_FREE 1 |
| 227 | |
| 228 | struct kmemtrace_user_event { |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 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; |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 236 | }; |
| 237 | |
| 238 | struct kmemtrace_user_event_alloc { |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 239 | size_t bytes_req; |
| 240 | size_t bytes_alloc; |
| 241 | unsigned gfp_flags; |
| 242 | int node; |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 243 | }; |
| 244 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 245 | static enum print_line_t |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 246 | kmemtrace_print_alloc(struct trace_iterator *iter, int flags, |
| 247 | struct trace_event *event) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 248 | { |
| 249 | struct trace_seq *s = &iter->seq; |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 250 | 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 | |
| 266 | static enum print_line_t |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 267 | kmemtrace_print_free(struct trace_iterator *iter, int flags, |
| 268 | struct trace_event *event) |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 269 | { |
| 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 | |
| 285 | static enum print_line_t |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 286 | kmemtrace_print_alloc_user(struct trace_iterator *iter, int flags, |
| 287 | struct trace_event *event) |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 288 | { |
| 289 | struct trace_seq *s = &iter->seq; |
| 290 | struct kmemtrace_alloc_entry *entry; |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 291 | struct kmemtrace_user_event *ev; |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 292 | struct kmemtrace_user_event_alloc *ev_alloc; |
| 293 | |
| 294 | trace_assign_type(entry, iter->ent); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 295 | |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 296 | ev = trace_seq_reserve(s, sizeof(*ev)); |
| 297 | if (!ev) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 298 | return TRACE_TYPE_PARTIAL_LINE; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 299 | |
| 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 Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 307 | |
| 308 | ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc)); |
| 309 | if (!ev_alloc) |
| 310 | return TRACE_TYPE_PARTIAL_LINE; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 311 | |
| 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 Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 316 | |
| 317 | return TRACE_TYPE_HANDLED; |
| 318 | } |
| 319 | |
| 320 | static enum print_line_t |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 321 | kmemtrace_print_free_user(struct trace_iterator *iter, int flags, |
| 322 | struct trace_event *event) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 323 | { |
| 324 | struct trace_seq *s = &iter->seq; |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 325 | struct kmemtrace_free_entry *entry; |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 326 | struct kmemtrace_user_event *ev; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 327 | |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 328 | trace_assign_type(entry, iter->ent); |
| 329 | |
Eduard - Gabriel Munteanu | 42af905 | 2009-03-23 15:12:26 +0200 | [diff] [blame] | 330 | ev = trace_seq_reserve(s, sizeof(*ev)); |
| 331 | if (!ev) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 332 | return TRACE_TYPE_PARTIAL_LINE; |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 333 | |
| 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 Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 341 | |
| 342 | return TRACE_TYPE_HANDLED; |
| 343 | } |
| 344 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 345 | /* The two other following provide a more minimalistic output */ |
| 346 | static enum print_line_t |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 347 | kmemtrace_print_alloc_compress(struct trace_iterator *iter) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 348 | { |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 349 | struct kmemtrace_alloc_entry *entry; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 350 | struct trace_seq *s = &iter->seq; |
| 351 | int ret; |
| 352 | |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 353 | trace_assign_type(entry, iter->ent); |
| 354 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 355 | /* 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 Dunlap | ecf441b | 2009-01-29 13:49:45 -0800 | [diff] [blame] | 379 | ret = trace_seq_printf(s, "%4zu ", entry->bytes_req); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 380 | if (!ret) |
| 381 | return TRACE_TYPE_PARTIAL_LINE; |
| 382 | |
| 383 | /* Allocated */ |
Randy Dunlap | ecf441b | 2009-01-29 13:49:45 -0800 | [diff] [blame] | 384 | ret = trace_seq_printf(s, "%4zu ", entry->bytes_alloc); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 385 | 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 Weisbecker | 6a167c6 | 2009-07-09 04:46:30 +0200 | [diff] [blame] | 400 | /* Node and call site*/ |
| 401 | ret = trace_seq_printf(s, "%4d %pf\n", entry->node, |
| 402 | (void *)entry->call_site); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 403 | if (!ret) |
| 404 | return TRACE_TYPE_PARTIAL_LINE; |
| 405 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 406 | return TRACE_TYPE_HANDLED; |
| 407 | } |
| 408 | |
| 409 | static enum print_line_t |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 410 | kmemtrace_print_free_compress(struct trace_iterator *iter) |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 411 | { |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 412 | struct kmemtrace_free_entry *entry; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 413 | struct trace_seq *s = &iter->seq; |
| 414 | int ret; |
| 415 | |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 416 | trace_assign_type(entry, iter->ent); |
| 417 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 418 | /* 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 Weisbecker | 6a167c6 | 2009-07-09 04:46:30 +0200 | [diff] [blame] | 451 | /* Skip node and print call site*/ |
| 452 | ret = trace_seq_printf(s, " %pf\n", (void *)entry->call_site); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 453 | if (!ret) |
| 454 | return TRACE_TYPE_PARTIAL_LINE; |
| 455 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 456 | return TRACE_TYPE_HANDLED; |
| 457 | } |
| 458 | |
| 459 | static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter) |
| 460 | { |
| 461 | struct trace_entry *entry = iter->ent; |
| 462 | |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 463 | if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)) |
| 464 | return TRACE_TYPE_UNHANDLED; |
| 465 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 466 | switch (entry->type) { |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 467 | case TRACE_KMEM_ALLOC: |
| 468 | return kmemtrace_print_alloc_compress(iter); |
| 469 | case TRACE_KMEM_FREE: |
| 470 | return kmemtrace_print_free_compress(iter); |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 471 | default: |
| 472 | return TRACE_TYPE_UNHANDLED; |
| 473 | } |
| 474 | } |
| 475 | |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 476 | static struct trace_event_functions kmem_trace_alloc_funcs = { |
Li Zefan | 80098c2 | 2009-07-06 16:15:04 +0800 | [diff] [blame] | 477 | .trace = kmemtrace_print_alloc, |
| 478 | .binary = kmemtrace_print_alloc_user, |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 479 | }; |
| 480 | |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 481 | static struct trace_event kmem_trace_alloc = { |
| 482 | .type = TRACE_KMEM_ALLOC, |
| 483 | .funcs = &kmem_trace_alloc_funcs, |
| 484 | }; |
| 485 | |
| 486 | static struct trace_event_functions kmem_trace_free_funcs = { |
Li Zefan | 80098c2 | 2009-07-06 16:15:04 +0800 | [diff] [blame] | 487 | .trace = kmemtrace_print_free, |
| 488 | .binary = kmemtrace_print_free_user, |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 489 | }; |
| 490 | |
Steven Rostedt | a9a5776 | 2010-04-22 18:46:14 -0400 | [diff] [blame] | 491 | static struct trace_event kmem_trace_free = { |
| 492 | .type = TRACE_KMEM_FREE, |
| 493 | .funcs = &kmem_trace_free_funcs, |
| 494 | }; |
| 495 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 496 | static struct tracer kmem_tracer __read_mostly = { |
Ingo Molnar | c826e3c | 2009-03-23 16:14:13 +0100 | [diff] [blame] | 497 | .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 Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 503 | }; |
| 504 | |
Ingo Molnar | 3e80680 | 2009-01-06 10:16:35 +0100 | [diff] [blame] | 505 | void kmemtrace_init(void) |
| 506 | { |
| 507 | /* earliest opportunity to start kmem tracing */ |
| 508 | } |
| 509 | |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 510 | static int __init init_kmem_tracer(void) |
| 511 | { |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 512 | 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 Mundt | f9ac5a6 | 2009-09-28 16:55:40 +0900 | [diff] [blame] | 522 | if (register_tracer(&kmem_tracer) != 0) { |
Li Zefan | ddc1637 | 2009-07-03 17:34:24 +0800 | [diff] [blame] | 523 | pr_warning("Warning: could not register the kmem tracer\n"); |
| 524 | return 1; |
| 525 | } |
| 526 | |
| 527 | return 0; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 528 | } |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 529 | device_initcall(init_kmem_tracer); |