kmemtrace: fix printk format warnings
[linux-2.6.git] / kernel / trace / kmemtrace.c
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
9 #include <linux/dcache.h>
10 #include <linux/debugfs.h>
11 #include <linux/fs.h>
12 #include <linux/seq_file.h>
13 #include <trace/kmemtrace.h>
14
15 #include "trace.h"
16 #include "trace_output.h"
17
18 /* Select an alternative, minimalistic output than the original one */
19 #define TRACE_KMEM_OPT_MINIMAL  0x1
20
21 static struct tracer_opt kmem_opts[] = {
22         /* Default disable the minimalistic output */
23         { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
24         { }
25 };
26
27 static struct tracer_flags kmem_tracer_flags = {
28         .val = 0,
29         .opts = kmem_opts
30 };
31
32
33 static bool kmem_tracing_enabled __read_mostly;
34 static struct trace_array *kmemtrace_array;
35
36 static int kmem_trace_init(struct trace_array *tr)
37 {
38         int cpu;
39         kmemtrace_array = tr;
40
41         for_each_cpu_mask(cpu, cpu_possible_map)
42                 tracing_reset(tr, cpu);
43
44         kmem_tracing_enabled = true;
45
46         return 0;
47 }
48
49 static void kmem_trace_reset(struct trace_array *tr)
50 {
51         kmem_tracing_enabled = false;
52 }
53
54 static void kmemtrace_headers(struct seq_file *s)
55 {
56         /* Don't need headers for the original kmemtrace output */
57         if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
58                 return;
59
60         seq_printf(s, "#\n");
61         seq_printf(s, "# ALLOC  TYPE  REQ   GIVEN  FLAGS     "
62                         "      POINTER         NODE    CALLER\n");
63         seq_printf(s, "# FREE   |      |     |       |       "
64                         "       |   |            |        |\n");
65         seq_printf(s, "# |\n\n");
66 }
67
68 /*
69  * The two following functions give the original output from kmemtrace,
70  * or something close to....perhaps they need some missing things
71  */
72 static enum print_line_t
73 kmemtrace_print_alloc_original(struct trace_iterator *iter,
74                                 struct kmemtrace_alloc_entry *entry)
75 {
76         struct trace_seq *s = &iter->seq;
77         int ret;
78
79         /* Taken from the old linux/kmemtrace.h */
80         ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
81           "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
82            entry->type_id, entry->call_site, (unsigned long) entry->ptr,
83            (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
84            (unsigned long) entry->gfp_flags, entry->node);
85
86         if (!ret)
87                 return TRACE_TYPE_PARTIAL_LINE;
88
89         return TRACE_TYPE_HANDLED;
90 }
91
92 static enum print_line_t
93 kmemtrace_print_free_original(struct trace_iterator *iter,
94                                 struct kmemtrace_free_entry *entry)
95 {
96         struct trace_seq *s = &iter->seq;
97         int ret;
98
99         /* Taken from the old linux/kmemtrace.h */
100         ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
101            entry->type_id, entry->call_site, (unsigned long) entry->ptr);
102
103         if (!ret)
104                 return TRACE_TYPE_PARTIAL_LINE;
105
106         return TRACE_TYPE_HANDLED;
107 }
108
109
110 /* The two other following provide a more minimalistic output */
111 static enum print_line_t
112 kmemtrace_print_alloc_compress(struct trace_iterator *iter,
113                                         struct kmemtrace_alloc_entry *entry)
114 {
115         struct trace_seq *s = &iter->seq;
116         int ret;
117
118         /* Alloc entry */
119         ret = trace_seq_printf(s, "  +      ");
120         if (!ret)
121                 return TRACE_TYPE_PARTIAL_LINE;
122
123         /* Type */
124         switch (entry->type_id) {
125         case KMEMTRACE_TYPE_KMALLOC:
126                 ret = trace_seq_printf(s, "K   ");
127                 break;
128         case KMEMTRACE_TYPE_CACHE:
129                 ret = trace_seq_printf(s, "C   ");
130                 break;
131         case KMEMTRACE_TYPE_PAGES:
132                 ret = trace_seq_printf(s, "P   ");
133                 break;
134         default:
135                 ret = trace_seq_printf(s, "?   ");
136         }
137
138         if (!ret)
139                 return TRACE_TYPE_PARTIAL_LINE;
140
141         /* Requested */
142         ret = trace_seq_printf(s, "%4zd   ", entry->bytes_req);
143         if (!ret)
144                 return TRACE_TYPE_PARTIAL_LINE;
145
146         /* Allocated */
147         ret = trace_seq_printf(s, "%4zd   ", entry->bytes_alloc);
148         if (!ret)
149                 return TRACE_TYPE_PARTIAL_LINE;
150
151         /* Flags
152          * TODO: would be better to see the name of the GFP flag names
153          */
154         ret = trace_seq_printf(s, "%08x   ", entry->gfp_flags);
155         if (!ret)
156                 return TRACE_TYPE_PARTIAL_LINE;
157
158         /* Pointer to allocated */
159         ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
160         if (!ret)
161                 return TRACE_TYPE_PARTIAL_LINE;
162
163         /* Node */
164         ret = trace_seq_printf(s, "%4d   ", entry->node);
165         if (!ret)
166                 return TRACE_TYPE_PARTIAL_LINE;
167
168         /* Call site */
169         ret = seq_print_ip_sym(s, entry->call_site, 0);
170         if (!ret)
171                 return TRACE_TYPE_PARTIAL_LINE;
172
173         if (!trace_seq_printf(s, "\n"))
174                 return TRACE_TYPE_PARTIAL_LINE;
175
176         return TRACE_TYPE_HANDLED;
177 }
178
179 static enum print_line_t
180 kmemtrace_print_free_compress(struct trace_iterator *iter,
181                                 struct kmemtrace_free_entry *entry)
182 {
183         struct trace_seq *s = &iter->seq;
184         int ret;
185
186         /* Free entry */
187         ret = trace_seq_printf(s, "  -      ");
188         if (!ret)
189                 return TRACE_TYPE_PARTIAL_LINE;
190
191         /* Type */
192         switch (entry->type_id) {
193         case KMEMTRACE_TYPE_KMALLOC:
194                 ret = trace_seq_printf(s, "K     ");
195                 break;
196         case KMEMTRACE_TYPE_CACHE:
197                 ret = trace_seq_printf(s, "C     ");
198                 break;
199         case KMEMTRACE_TYPE_PAGES:
200                 ret = trace_seq_printf(s, "P     ");
201                 break;
202         default:
203                 ret = trace_seq_printf(s, "?     ");
204         }
205
206         if (!ret)
207                 return TRACE_TYPE_PARTIAL_LINE;
208
209         /* Skip requested/allocated/flags */
210         ret = trace_seq_printf(s, "                       ");
211         if (!ret)
212                 return TRACE_TYPE_PARTIAL_LINE;
213
214         /* Pointer to allocated */
215         ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
216         if (!ret)
217                 return TRACE_TYPE_PARTIAL_LINE;
218
219         /* Skip node */
220         ret = trace_seq_printf(s, "       ");
221         if (!ret)
222                 return TRACE_TYPE_PARTIAL_LINE;
223
224         /* Call site */
225         ret = seq_print_ip_sym(s, entry->call_site, 0);
226         if (!ret)
227                 return TRACE_TYPE_PARTIAL_LINE;
228
229         if (!trace_seq_printf(s, "\n"))
230                 return TRACE_TYPE_PARTIAL_LINE;
231
232         return TRACE_TYPE_HANDLED;
233 }
234
235 static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
236 {
237         struct trace_entry *entry = iter->ent;
238
239         switch (entry->type) {
240         case TRACE_KMEM_ALLOC: {
241                 struct kmemtrace_alloc_entry *field;
242                 trace_assign_type(field, entry);
243                 if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
244                         return kmemtrace_print_alloc_compress(iter, field);
245                 else
246                         return kmemtrace_print_alloc_original(iter, field);
247         }
248
249         case TRACE_KMEM_FREE: {
250                 struct kmemtrace_free_entry *field;
251                 trace_assign_type(field, entry);
252                 if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
253                         return kmemtrace_print_free_compress(iter, field);
254                 else
255                         return kmemtrace_print_free_original(iter, field);
256         }
257
258         default:
259                 return TRACE_TYPE_UNHANDLED;
260         }
261 }
262
263 /* Trace allocations */
264 void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
265                              unsigned long call_site,
266                              const void *ptr,
267                              size_t bytes_req,
268                              size_t bytes_alloc,
269                              gfp_t gfp_flags,
270                              int node)
271 {
272         struct ring_buffer_event *event;
273         struct kmemtrace_alloc_entry *entry;
274         struct trace_array *tr = kmemtrace_array;
275         unsigned long irq_flags;
276
277         if (!kmem_tracing_enabled)
278                 return;
279
280         event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
281                                          &irq_flags);
282         if (!event)
283                 return;
284         entry   = ring_buffer_event_data(event);
285         tracing_generic_entry_update(&entry->ent, 0, 0);
286
287         entry->ent.type = TRACE_KMEM_ALLOC;
288         entry->call_site = call_site;
289         entry->ptr = ptr;
290         entry->bytes_req = bytes_req;
291         entry->bytes_alloc = bytes_alloc;
292         entry->gfp_flags = gfp_flags;
293         entry->node     =       node;
294
295         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
296
297         trace_wake_up();
298 }
299 EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
300
301 void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
302                        unsigned long call_site,
303                        const void *ptr)
304 {
305         struct ring_buffer_event *event;
306         struct kmemtrace_free_entry *entry;
307         struct trace_array *tr = kmemtrace_array;
308         unsigned long irq_flags;
309
310         if (!kmem_tracing_enabled)
311                 return;
312
313         event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
314                                          &irq_flags);
315         if (!event)
316                 return;
317         entry   = ring_buffer_event_data(event);
318         tracing_generic_entry_update(&entry->ent, 0, 0);
319
320         entry->ent.type = TRACE_KMEM_FREE;
321         entry->type_id  = type_id;
322         entry->call_site = call_site;
323         entry->ptr = ptr;
324
325         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
326
327         trace_wake_up();
328 }
329 EXPORT_SYMBOL(kmemtrace_mark_free);
330
331 static struct tracer kmem_tracer __read_mostly = {
332         .name           = "kmemtrace",
333         .init           = kmem_trace_init,
334         .reset          = kmem_trace_reset,
335         .print_line     = kmemtrace_print_line,
336         .print_header = kmemtrace_headers,
337         .flags          = &kmem_tracer_flags
338 };
339
340 void kmemtrace_init(void)
341 {
342         /* earliest opportunity to start kmem tracing */
343 }
344
345 static int __init init_kmem_tracer(void)
346 {
347         return register_tracer(&kmem_tracer);
348 }
349
350 device_initcall(init_kmem_tracer);