diff options
Diffstat (limited to 'kernel/trace/trace_mmiotrace.c')
-rw-r--r-- | kernel/trace/trace_mmiotrace.c | 116 |
1 files changed, 99 insertions, 17 deletions
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c index b13dc19dcbb4..f28484618ff0 100644 --- a/kernel/trace/trace_mmiotrace.c +++ b/kernel/trace/trace_mmiotrace.c | |||
@@ -27,7 +27,7 @@ static void mmio_reset_data(struct trace_array *tr) | |||
27 | tr->time_start = ftrace_now(tr->cpu); | 27 | tr->time_start = ftrace_now(tr->cpu); |
28 | 28 | ||
29 | for_each_online_cpu(cpu) | 29 | for_each_online_cpu(cpu) |
30 | tracing_reset(tr->data[cpu]); | 30 | tracing_reset(tr, cpu); |
31 | } | 31 | } |
32 | 32 | ||
33 | static void mmio_trace_init(struct trace_array *tr) | 33 | static void mmio_trace_init(struct trace_array *tr) |
@@ -130,10 +130,14 @@ static unsigned long count_overruns(struct trace_iterator *iter) | |||
130 | { | 130 | { |
131 | int cpu; | 131 | int cpu; |
132 | unsigned long cnt = 0; | 132 | unsigned long cnt = 0; |
133 | /* FIXME: */ | ||
134 | #if 0 | ||
133 | for_each_online_cpu(cpu) { | 135 | for_each_online_cpu(cpu) { |
134 | cnt += iter->overrun[cpu]; | 136 | cnt += iter->overrun[cpu]; |
135 | iter->overrun[cpu] = 0; | 137 | iter->overrun[cpu] = 0; |
136 | } | 138 | } |
139 | #endif | ||
140 | (void)cpu; | ||
137 | return cnt; | 141 | return cnt; |
138 | } | 142 | } |
139 | 143 | ||
@@ -171,17 +175,21 @@ print_out: | |||
171 | return (ret == -EBUSY) ? 0 : ret; | 175 | return (ret == -EBUSY) ? 0 : ret; |
172 | } | 176 | } |
173 | 177 | ||
174 | static int mmio_print_rw(struct trace_iterator *iter) | 178 | static enum print_line_t mmio_print_rw(struct trace_iterator *iter) |
175 | { | 179 | { |
176 | struct trace_entry *entry = iter->ent; | 180 | struct trace_entry *entry = iter->ent; |
177 | struct mmiotrace_rw *rw = &entry->mmiorw; | 181 | struct trace_mmiotrace_rw *field; |
182 | struct mmiotrace_rw *rw; | ||
178 | struct trace_seq *s = &iter->seq; | 183 | struct trace_seq *s = &iter->seq; |
179 | unsigned long long t = ns2usecs(entry->t); | 184 | unsigned long long t = ns2usecs(iter->ts); |
180 | unsigned long usec_rem = do_div(t, 1000000ULL); | 185 | unsigned long usec_rem = do_div(t, 1000000ULL); |
181 | unsigned secs = (unsigned long)t; | 186 | unsigned secs = (unsigned long)t; |
182 | int ret = 1; | 187 | int ret = 1; |
183 | 188 | ||
184 | switch (entry->mmiorw.opcode) { | 189 | trace_assign_type(field, entry); |
190 | rw = &field->rw; | ||
191 | |||
192 | switch (rw->opcode) { | ||
185 | case MMIO_READ: | 193 | case MMIO_READ: |
186 | ret = trace_seq_printf(s, | 194 | ret = trace_seq_printf(s, |
187 | "R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n", | 195 | "R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n", |
@@ -209,21 +217,25 @@ static int mmio_print_rw(struct trace_iterator *iter) | |||
209 | break; | 217 | break; |
210 | } | 218 | } |
211 | if (ret) | 219 | if (ret) |
212 | return 1; | 220 | return TRACE_TYPE_HANDLED; |
213 | return 0; | 221 | return TRACE_TYPE_PARTIAL_LINE; |
214 | } | 222 | } |
215 | 223 | ||
216 | static int mmio_print_map(struct trace_iterator *iter) | 224 | static enum print_line_t mmio_print_map(struct trace_iterator *iter) |
217 | { | 225 | { |
218 | struct trace_entry *entry = iter->ent; | 226 | struct trace_entry *entry = iter->ent; |
219 | struct mmiotrace_map *m = &entry->mmiomap; | 227 | struct trace_mmiotrace_map *field; |
228 | struct mmiotrace_map *m; | ||
220 | struct trace_seq *s = &iter->seq; | 229 | struct trace_seq *s = &iter->seq; |
221 | unsigned long long t = ns2usecs(entry->t); | 230 | unsigned long long t = ns2usecs(iter->ts); |
222 | unsigned long usec_rem = do_div(t, 1000000ULL); | 231 | unsigned long usec_rem = do_div(t, 1000000ULL); |
223 | unsigned secs = (unsigned long)t; | 232 | unsigned secs = (unsigned long)t; |
224 | int ret = 1; | 233 | int ret; |
225 | 234 | ||
226 | switch (entry->mmiorw.opcode) { | 235 | trace_assign_type(field, entry); |
236 | m = &field->map; | ||
237 | |||
238 | switch (m->opcode) { | ||
227 | case MMIO_PROBE: | 239 | case MMIO_PROBE: |
228 | ret = trace_seq_printf(s, | 240 | ret = trace_seq_printf(s, |
229 | "MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n", | 241 | "MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n", |
@@ -241,20 +253,43 @@ static int mmio_print_map(struct trace_iterator *iter) | |||
241 | break; | 253 | break; |
242 | } | 254 | } |
243 | if (ret) | 255 | if (ret) |
244 | return 1; | 256 | return TRACE_TYPE_HANDLED; |
245 | return 0; | 257 | return TRACE_TYPE_PARTIAL_LINE; |
258 | } | ||
259 | |||
260 | static enum print_line_t mmio_print_mark(struct trace_iterator *iter) | ||
261 | { | ||
262 | struct trace_entry *entry = iter->ent; | ||
263 | struct print_entry *print = (struct print_entry *)entry; | ||
264 | const char *msg = print->buf; | ||
265 | struct trace_seq *s = &iter->seq; | ||
266 | unsigned long long t = ns2usecs(iter->ts); | ||
267 | unsigned long usec_rem = do_div(t, 1000000ULL); | ||
268 | unsigned secs = (unsigned long)t; | ||
269 | int ret; | ||
270 | |||
271 | /* The trailing newline must be in the message. */ | ||
272 | ret = trace_seq_printf(s, "MARK %lu.%06lu %s", secs, usec_rem, msg); | ||
273 | if (!ret) | ||
274 | return TRACE_TYPE_PARTIAL_LINE; | ||
275 | |||
276 | if (entry->flags & TRACE_FLAG_CONT) | ||
277 | trace_seq_print_cont(s, iter); | ||
278 | |||
279 | return TRACE_TYPE_HANDLED; | ||
246 | } | 280 | } |
247 | 281 | ||
248 | /* return 0 to abort printing without consuming current entry in pipe mode */ | 282 | static enum print_line_t mmio_print_line(struct trace_iterator *iter) |
249 | static int mmio_print_line(struct trace_iterator *iter) | ||
250 | { | 283 | { |
251 | switch (iter->ent->type) { | 284 | switch (iter->ent->type) { |
252 | case TRACE_MMIO_RW: | 285 | case TRACE_MMIO_RW: |
253 | return mmio_print_rw(iter); | 286 | return mmio_print_rw(iter); |
254 | case TRACE_MMIO_MAP: | 287 | case TRACE_MMIO_MAP: |
255 | return mmio_print_map(iter); | 288 | return mmio_print_map(iter); |
289 | case TRACE_PRINT: | ||
290 | return mmio_print_mark(iter); | ||
256 | default: | 291 | default: |
257 | return 1; /* ignore unknown entries */ | 292 | return TRACE_TYPE_HANDLED; /* ignore unknown entries */ |
258 | } | 293 | } |
259 | } | 294 | } |
260 | 295 | ||
@@ -276,6 +311,27 @@ __init static int init_mmio_trace(void) | |||
276 | } | 311 | } |
277 | device_initcall(init_mmio_trace); | 312 | device_initcall(init_mmio_trace); |
278 | 313 | ||
314 | static void __trace_mmiotrace_rw(struct trace_array *tr, | ||
315 | struct trace_array_cpu *data, | ||
316 | struct mmiotrace_rw *rw) | ||
317 | { | ||
318 | struct ring_buffer_event *event; | ||
319 | struct trace_mmiotrace_rw *entry; | ||
320 | unsigned long irq_flags; | ||
321 | |||
322 | event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry), | ||
323 | &irq_flags); | ||
324 | if (!event) | ||
325 | return; | ||
326 | entry = ring_buffer_event_data(event); | ||
327 | tracing_generic_entry_update(&entry->ent, 0, preempt_count()); | ||
328 | entry->ent.type = TRACE_MMIO_RW; | ||
329 | entry->rw = *rw; | ||
330 | ring_buffer_unlock_commit(tr->buffer, event, irq_flags); | ||
331 | |||
332 | trace_wake_up(); | ||
333 | } | ||
334 | |||
279 | void mmio_trace_rw(struct mmiotrace_rw *rw) | 335 | void mmio_trace_rw(struct mmiotrace_rw *rw) |
280 | { | 336 | { |
281 | struct trace_array *tr = mmio_trace_array; | 337 | struct trace_array *tr = mmio_trace_array; |
@@ -283,6 +339,27 @@ void mmio_trace_rw(struct mmiotrace_rw *rw) | |||
283 | __trace_mmiotrace_rw(tr, data, rw); | 339 | __trace_mmiotrace_rw(tr, data, rw); |
284 | } | 340 | } |
285 | 341 | ||
342 | static void __trace_mmiotrace_map(struct trace_array *tr, | ||
343 | struct trace_array_cpu *data, | ||
344 | struct mmiotrace_map *map) | ||
345 | { | ||
346 | struct ring_buffer_event *event; | ||
347 | struct trace_mmiotrace_map *entry; | ||
348 | unsigned long irq_flags; | ||
349 | |||
350 | event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry), | ||
351 | &irq_flags); | ||
352 | if (!event) | ||
353 | return; | ||
354 | entry = ring_buffer_event_data(event); | ||
355 | tracing_generic_entry_update(&entry->ent, 0, preempt_count()); | ||
356 | entry->ent.type = TRACE_MMIO_MAP; | ||
357 | entry->map = *map; | ||
358 | ring_buffer_unlock_commit(tr->buffer, event, irq_flags); | ||
359 | |||
360 | trace_wake_up(); | ||
361 | } | ||
362 | |||
286 | void mmio_trace_mapping(struct mmiotrace_map *map) | 363 | void mmio_trace_mapping(struct mmiotrace_map *map) |
287 | { | 364 | { |
288 | struct trace_array *tr = mmio_trace_array; | 365 | struct trace_array *tr = mmio_trace_array; |
@@ -293,3 +370,8 @@ void mmio_trace_mapping(struct mmiotrace_map *map) | |||
293 | __trace_mmiotrace_map(tr, data, map); | 370 | __trace_mmiotrace_map(tr, data, map); |
294 | preempt_enable(); | 371 | preempt_enable(); |
295 | } | 372 | } |
373 | |||
374 | int mmio_trace_printk(const char *fmt, va_list args) | ||
375 | { | ||
376 | return trace_vprintk(0, fmt, args); | ||
377 | } | ||