kernel/trace/trace_mmiotrace.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Memory mapped I/O tracing
0004  *
0005  * Copyright (C) 2008 Pekka Paalanen <pq@iki.fi>
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/mmiotrace.h>
0010 #include <linux/pci.h>
0011 #include <linux/slab.h>
0012 #include <linux/time.h>
0013
0014 #include <linux/atomic.h>
0015
0016 #include "trace.h"
0017 #include "trace_output.h"
0018
0019 struct header_iter {
0020     struct pci_dev *dev;
0021 };
0022
0023 static struct trace_array *mmio_trace_array;
0024 static bool overrun_detected;
0025 static unsigned long prev_overruns;
0026 static atomic_t dropped_count;
0027
0028 static void mmio_reset_data(struct trace_array *tr)
0029 {
0030     overrun_detected = false;
0031     prev_overruns = 0;
0032
0033     tracing_reset_online_cpus(&tr->array_buffer);
0034 }
0035
0036 static int mmio_trace_init(struct trace_array *tr)
0037 {
0038     pr_debug("in %s\n", __func__);
0039     mmio_trace_array = tr;
0040
0041     mmio_reset_data(tr);
0042     enable_mmiotrace();
0043     return 0;
0044 }
0045
0046 static void mmio_trace_reset(struct trace_array *tr)
0047 {
0048     pr_debug("in %s\n", __func__);
0049
0050     disable_mmiotrace();
0051     mmio_reset_data(tr);
0052     mmio_trace_array = NULL;
0053 }
0054
0055 static void mmio_trace_start(struct trace_array *tr)
0056 {
0057     pr_debug("in %s\n", __func__);
0058     mmio_reset_data(tr);
0059 }
0060
0061 static void mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
0062 {
0063     int i;
0064     resource_size_t start, end;
0065     const struct pci_driver *drv = pci_dev_driver(dev);
0066
0067     trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
0068              dev->bus->number, dev->devfn,
0069              dev->vendor, dev->device, dev->irq);
0070     for (i = 0; i < 7; i++) {
0071         start = dev->resource[i].start;
0072         trace_seq_printf(s, " %llx",
0073             (unsigned long long)(start |
0074             (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
0075     }
0076     for (i = 0; i < 7; i++) {
0077         start = dev->resource[i].start;
0078         end = dev->resource[i].end;
0079         trace_seq_printf(s, " %llx",
0080             dev->resource[i].start < dev->resource[i].end ?
0081             (unsigned long long)(end - start) + 1 : 0);
0082     }
0083     if (drv)
0084         trace_seq_printf(s, " %s\n", drv->name);
0085     else
0086         trace_seq_puts(s, " \n");
0087 }
0088
0089 static void destroy_header_iter(struct header_iter *hiter)
0090 {
0091     if (!hiter)
0092         return;
0093     pci_dev_put(hiter->dev);
0094     kfree(hiter);
0095 }
0096
0097 static void mmio_pipe_open(struct trace_iterator *iter)
0098 {
0099     struct header_iter *hiter;
0100     struct trace_seq *s = &iter->seq;
0101
0102     trace_seq_puts(s, "VERSION 20070824\n");
0103
0104     hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
0105     if (!hiter)
0106         return;
0107
0108     hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
0109     iter->private = hiter;
0110 }
0111
0112 /* XXX: This is not called when the pipe is closed! */
0113 static void mmio_close(struct trace_iterator *iter)
0114 {
0115     struct header_iter *hiter = iter->private;
0116     destroy_header_iter(hiter);
0117     iter->private = NULL;
0118 }
0119
0120 static unsigned long count_overruns(struct trace_iterator *iter)
0121 {
0122     unsigned long cnt = atomic_xchg(&dropped_count, 0);
0123     unsigned long over = ring_buffer_overruns(iter->array_buffer->buffer);
0124
0125     if (over > prev_overruns)
0126         cnt += over - prev_overruns;
0127     prev_overruns = over;
0128     return cnt;
0129 }
0130
0131 static ssize_t mmio_read(struct trace_iterator *iter, struct file *filp,
0132                 char __user *ubuf, size_t cnt, loff_t *ppos)
0133 {
0134     ssize_t ret;
0135     struct header_iter *hiter = iter->private;
0136     struct trace_seq *s = &iter->seq;
0137     unsigned long n;
0138
0139     n = count_overruns(iter);
0140     if (n) {
0141         /* XXX: This is later than where events were lost. */
0142         trace_seq_printf(s, "MARK 0.000000 Lost %lu events.\n", n);
0143         if (!overrun_detected)
0144             pr_warn("mmiotrace has lost events\n");
0145         overrun_detected = true;
0146         goto print_out;
0147     }
0148
0149     if (!hiter)
0150         return 0;
0151
0152     mmio_print_pcidev(s, hiter->dev);
0153     hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, hiter->dev);
0154
0155     if (!hiter->dev) {
0156         destroy_header_iter(hiter);
0157         iter->private = NULL;
0158     }
0159
0160 print_out:
0161     ret = trace_seq_to_user(s, ubuf, cnt);
0162     return (ret == -EBUSY) ? 0 : ret;
0163 }
0164
0165 static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
0166 {
0167     struct trace_entry *entry = iter->ent;
0168     struct trace_mmiotrace_rw *field;
0169     struct mmiotrace_rw *rw;
0170     struct trace_seq *s = &iter->seq;
0171     unsigned long long t    = ns2usecs(iter->ts);
0172     unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
0173     unsigned secs       = (unsigned long)t;
0174
0175     trace_assign_type(field, entry);
0176     rw = &field->rw;
0177
0178     switch (rw->opcode) {
0179     case MMIO_READ:
0180         trace_seq_printf(s,
0181             "R %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
0182             rw->width, secs, usec_rem, rw->map_id,
0183             (unsigned long long)rw->phys,
0184             rw->value, rw->pc, 0);
0185         break;
0186     case MMIO_WRITE:
0187         trace_seq_printf(s,
0188             "W %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
0189             rw->width, secs, usec_rem, rw->map_id,
0190             (unsigned long long)rw->phys,
0191             rw->value, rw->pc, 0);
0192         break;
0193     case MMIO_UNKNOWN_OP:
0194         trace_seq_printf(s,
0195             "UNKNOWN %u.%06lu %d 0x%llx %02lx,%02lx,"
0196             "%02lx 0x%lx %d\n",
0197             secs, usec_rem, rw->map_id,
0198             (unsigned long long)rw->phys,
0199             (rw->value >> 16) & 0xff, (rw->value >> 8) & 0xff,
0200             (rw->value >> 0) & 0xff, rw->pc, 0);
0201         break;
0202     default:
0203         trace_seq_puts(s, "rw what?\n");
0204         break;
0205     }
0206
0207     return trace_handle_return(s);
0208 }
0209
0210 static enum print_line_t mmio_print_map(struct trace_iterator *iter)
0211 {
0212     struct trace_entry *entry = iter->ent;
0213     struct trace_mmiotrace_map *field;
0214     struct mmiotrace_map *m;
0215     struct trace_seq *s = &iter->seq;
0216     unsigned long long t    = ns2usecs(iter->ts);
0217     unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
0218     unsigned secs       = (unsigned long)t;
0219
0220     trace_assign_type(field, entry);
0221     m = &field->map;
0222
0223     switch (m->opcode) {
0224     case MMIO_PROBE:
0225         trace_seq_printf(s,
0226             "MAP %u.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
0227             secs, usec_rem, m->map_id,
0228             (unsigned long long)m->phys, m->virt, m->len,
0229             0UL, 0);
0230         break;
0231     case MMIO_UNPROBE:
0232         trace_seq_printf(s,
0233             "UNMAP %u.%06lu %d 0x%lx %d\n",
0234             secs, usec_rem, m->map_id, 0UL, 0);
0235         break;
0236     default:
0237         trace_seq_puts(s, "map what?\n");
0238         break;
0239     }
0240
0241     return trace_handle_return(s);
0242 }
0243
0244 static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
0245 {
0246     struct trace_entry *entry = iter->ent;
0247     struct print_entry *print = (struct print_entry *)entry;
0248     const char *msg     = print->buf;
0249     struct trace_seq *s = &iter->seq;
0250     unsigned long long t    = ns2usecs(iter->ts);
0251     unsigned long usec_rem  = do_div(t, USEC_PER_SEC);
0252     unsigned secs       = (unsigned long)t;
0253
0254     /* The trailing newline must be in the message. */
0255     trace_seq_printf(s, "MARK %u.%06lu %s", secs, usec_rem, msg);
0256
0257     return trace_handle_return(s);
0258 }
0259
0260 static enum print_line_t mmio_print_line(struct trace_iterator *iter)
0261 {
0262     switch (iter->ent->type) {
0263     case TRACE_MMIO_RW:
0264         return mmio_print_rw(iter);
0265     case TRACE_MMIO_MAP:
0266         return mmio_print_map(iter);
0267     case TRACE_PRINT:
0268         return mmio_print_mark(iter);
0269     default:
0270         return TRACE_TYPE_HANDLED; /* ignore unknown entries */
0271     }
0272 }
0273
0274 static struct tracer mmio_tracer __read_mostly =
0275 {
0276     .name       = "mmiotrace",
0277     .init       = mmio_trace_init,
0278     .reset      = mmio_trace_reset,
0279     .start      = mmio_trace_start,
0280     .pipe_open  = mmio_pipe_open,
0281     .close      = mmio_close,
0282     .read       = mmio_read,
0283     .print_line = mmio_print_line,
0284     .noboot     = true,
0285 };
0286
0287 __init static int init_mmio_trace(void)
0288 {
0289     return register_tracer(&mmio_tracer);
0290 }
0291 device_initcall(init_mmio_trace);
0292
0293 static void __trace_mmiotrace_rw(struct trace_array *tr,
0294                 struct trace_array_cpu *data,
0295                 struct mmiotrace_rw *rw)
0296 {
0297     struct trace_event_call *call = &event_mmiotrace_rw;
0298     struct trace_buffer *buffer = tr->array_buffer.buffer;
0299     struct ring_buffer_event *event;
0300     struct trace_mmiotrace_rw *entry;
0301     unsigned int trace_ctx;
0302
0303     trace_ctx = tracing_gen_ctx_flags(0);
0304     event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_RW,
0305                       sizeof(*entry), trace_ctx);
0306     if (!event) {
0307         atomic_inc(&dropped_count);
0308         return;
0309     }
0310     entry   = ring_buffer_event_data(event);
0311     entry->rw           = *rw;
0312
0313     if (!call_filter_check_discard(call, entry, buffer, event))
0314         trace_buffer_unlock_commit(tr, buffer, event, trace_ctx);
0315 }
0316
0317 void mmio_trace_rw(struct mmiotrace_rw *rw)
0318 {
0319     struct trace_array *tr = mmio_trace_array;
0320     struct trace_array_cpu *data = per_cpu_ptr(tr->array_buffer.data, smp_processor_id());
0321     __trace_mmiotrace_rw(tr, data, rw);
0322 }
0323
0324 static void __trace_mmiotrace_map(struct trace_array *tr,
0325                 struct trace_array_cpu *data,
0326                 struct mmiotrace_map *map)
0327 {
0328     struct trace_event_call *call = &event_mmiotrace_map;
0329     struct trace_buffer *buffer = tr->array_buffer.buffer;
0330     struct ring_buffer_event *event;
0331     struct trace_mmiotrace_map *entry;
0332     unsigned int trace_ctx;
0333
0334     trace_ctx = tracing_gen_ctx_flags(0);
0335     event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_MAP,
0336                       sizeof(*entry), trace_ctx);
0337     if (!event) {
0338         atomic_inc(&dropped_count);
0339         return;
0340     }
0341     entry   = ring_buffer_event_data(event);
0342     entry->map          = *map;
0343
0344     if (!call_filter_check_discard(call, entry, buffer, event))
0345         trace_buffer_unlock_commit(tr, buffer, event, trace_ctx);
0346 }
0347
0348 void mmio_trace_mapping(struct mmiotrace_map *map)
0349 {
0350     struct trace_array *tr = mmio_trace_array;
0351     struct trace_array_cpu *data;
0352
0353     preempt_disable();
0354     data = per_cpu_ptr(tr->array_buffer.data, smp_processor_id());
0355     __trace_mmiotrace_map(tr, data, map);
0356     preempt_enable();
0357 }
0358
0359 int mmio_trace_printk(const char *fmt, va_list args)
0360 {
0361     return trace_vprintk(0, fmt, args);
0362 }