[deliverable/linux.git] / kernel / trace / trace_mmiotrace.c

/*
 * Memory mapped I/O tracing
 *
 * Copyright (C) 2008 Pekka Paalanen <pq@iki.fi>
 */

#define DEBUG 1

#include <linux/kernel.h>
#include <linux/mmiotrace.h>
#include <linux/pci.h>
#include <asm/atomic.h>

#include "trace.h"
#include "trace_output.h"

struct header_iter {
	struct pci_dev *dev;
};

static struct trace_array *mmio_trace_array;
static bool overrun_detected;
static unsigned long prev_overruns;
static atomic_t dropped_count;

static void mmio_reset_data(struct trace_array *tr)
{
	overrun_detected = false;
	prev_overruns = 0;

	tracing_reset_online_cpus(tr);
}

static int mmio_trace_init(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);
	mmio_trace_array = tr;

	mmio_reset_data(tr);
	enable_mmiotrace();
	return 0;
}

static void mmio_trace_reset(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);

	disable_mmiotrace();
	mmio_reset_data(tr);
	mmio_trace_array = NULL;
}

static void mmio_trace_start(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);
	mmio_reset_data(tr);
}

static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
{
	int ret = 0;
	int i;
	resource_size_t start, end;
	const struct pci_driver *drv = pci_dev_driver(dev);

	/* XXX: incomplete checks for trace_seq_printf() return value */
	ret += trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
				dev->bus->number, dev->devfn,
				dev->vendor, dev->device, dev->irq);
	/*
	 * XXX: is pci_resource_to_user() appropriate, since we are
	 * supposed to interpret the __ioremap() phys_addr argument based on
	 * these printed values?
	 */
	for (i = 0; i < 7; i++) {
		pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
		ret += trace_seq_printf(s, " %llx",
			(unsigned long long)(start |
			(dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
	}
	for (i = 0; i < 7; i++) {
		pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
		ret += trace_seq_printf(s, " %llx",
			dev->resource[i].start < dev->resource[i].end ?
			(unsigned long long)(end - start) + 1 : 0);
	}
	if (drv)
		ret += trace_seq_printf(s, " %s\n", drv->name);
	else
		ret += trace_seq_printf(s, " \n");
	return ret;
}

static void destroy_header_iter(struct header_iter *hiter)
{
	if (!hiter)
		return;
	pci_dev_put(hiter->dev);
	kfree(hiter);
}

static void mmio_pipe_open(struct trace_iterator *iter)
{
	struct header_iter *hiter;
	struct trace_seq *s = &iter->seq;

	trace_seq_printf(s, "VERSION 20070824\n");

	hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
	if (!hiter)
		return;

	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
	iter->private = hiter;
}

/* XXX: This is not called when the pipe is closed! */
static void mmio_close(struct trace_iterator *iter)
{
	struct header_iter *hiter = iter->private;
	destroy_header_iter(hiter);
	iter->private = NULL;
}

static unsigned long count_overruns(struct trace_iterator *iter)
{
	unsigned long cnt = atomic_xchg(&dropped_count, 0);
	unsigned long over = ring_buffer_overruns(iter->tr->buffer);

	if (over > prev_overruns)
		cnt += over - prev_overruns;
	prev_overruns = over;
	return cnt;
}

static ssize_t mmio_read(struct trace_iterator *iter, struct file *filp,
				char __user *ubuf, size_t cnt, loff_t *ppos)
{
	ssize_t ret;
	struct header_iter *hiter = iter->private;
	struct trace_seq *s = &iter->seq;
	unsigned long n;

	n = count_overruns(iter);
	if (n) {
		/* XXX: This is later than where events were lost. */
		trace_seq_printf(s, "MARK 0.000000 Lost %lu events.\n", n);
		if (!overrun_detected)
			pr_warning("mmiotrace has lost events.\n");
		overrun_detected = true;
		goto print_out;
	}

	if (!hiter)
		return 0;

	mmio_print_pcidev(s, hiter->dev);
	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, hiter->dev);

	if (!hiter->dev) {
		destroy_header_iter(hiter);
		iter->private = NULL;
	}

print_out:
	ret = trace_seq_to_user(s, ubuf, cnt);
	return (ret == -EBUSY) ? 0 : ret;
}

static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
	struct trace_mmiotrace_rw *field;
	struct mmiotrace_rw *rw;
	struct trace_seq *s	= &iter->seq;
	unsigned long long t	= ns2usecs(iter->ts);
	unsigned long usec_rem	= do_div(t, 1000000ULL);
	unsigned secs		= (unsigned long)t;
	int ret = 1;

	trace_assign_type(field, entry);
	rw = &field->rw;

	switch (rw->opcode) {
	case MMIO_READ:
		ret = trace_seq_printf(s,
			"R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
			rw->width, secs, usec_rem, rw->map_id,
			(unsigned long long)rw->phys,
			rw->value, rw->pc, 0);
		break;
	case MMIO_WRITE:
		ret = trace_seq_printf(s,
			"W %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
			rw->width, secs, usec_rem, rw->map_id,
			(unsigned long long)rw->phys,
			rw->value, rw->pc, 0);
		break;
	case MMIO_UNKNOWN_OP:
		ret = trace_seq_printf(s,
			"UNKNOWN %lu.%06lu %d 0x%llx %02x,%02x,%02x 0x%lx %d\n",
			secs, usec_rem, rw->map_id,
			(unsigned long long)rw->phys,
			(rw->value >> 16) & 0xff, (rw->value >> 8) & 0xff,
			(rw->value >> 0) & 0xff, rw->pc, 0);
		break;
	default:
		ret = trace_seq_printf(s, "rw what?\n");
		break;
	}
	if (ret)
		return TRACE_TYPE_HANDLED;
	return TRACE_TYPE_PARTIAL_LINE;
}

static enum print_line_t mmio_print_map(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
	struct trace_mmiotrace_map *field;
	struct mmiotrace_map *m;
	struct trace_seq *s	= &iter->seq;
	unsigned long long t	= ns2usecs(iter->ts);
	unsigned long usec_rem	= do_div(t, 1000000ULL);
	unsigned secs		= (unsigned long)t;
	int ret;

	trace_assign_type(field, entry);
	m = &field->map;

	switch (m->opcode) {
	case MMIO_PROBE:
		ret = trace_seq_printf(s,
			"MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
			secs, usec_rem, m->map_id,
			(unsigned long long)m->phys, m->virt, m->len,
			0UL, 0);
		break;
	case MMIO_UNPROBE:
		ret = trace_seq_printf(s,
			"UNMAP %lu.%06lu %d 0x%lx %d\n",
			secs, usec_rem, m->map_id, 0UL, 0);
		break;
	default:
		ret = trace_seq_printf(s, "map what?\n");
		break;
	}
	if (ret)
		return TRACE_TYPE_HANDLED;
	return TRACE_TYPE_PARTIAL_LINE;
}

static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
	struct print_entry *print = (struct print_entry *)entry;
	const char *msg		= print->buf;
	struct trace_seq *s	= &iter->seq;
	unsigned long long t	= ns2usecs(iter->ts);
	unsigned long usec_rem	= do_div(t, 1000000ULL);
	unsigned secs		= (unsigned long)t;
	int ret;

	/* The trailing newline must be in the message. */
	ret = trace_seq_printf(s, "MARK %lu.%06lu %s", secs, usec_rem, msg);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t mmio_print_line(struct trace_iterator *iter)
{
	switch (iter->ent->type) {
	case TRACE_MMIO_RW:
		return mmio_print_rw(iter);
	case TRACE_MMIO_MAP:
		return mmio_print_map(iter);
	case TRACE_PRINT:
		return mmio_print_mark(iter);
	default:
		return TRACE_TYPE_HANDLED; /* ignore unknown entries */
	}
}

static struct tracer mmio_tracer __read_mostly =
{
	.name		= "mmiotrace",
	.init		= mmio_trace_init,
	.reset		= mmio_trace_reset,
	.start		= mmio_trace_start,
	.pipe_open	= mmio_pipe_open,
	.close		= mmio_close,
	.read		= mmio_read,
	.print_line	= mmio_print_line,
};

__init static int init_mmio_trace(void)
{
	return register_tracer(&mmio_tracer);
}
device_initcall(init_mmio_trace);

static void __trace_mmiotrace_rw(struct trace_array *tr,
				struct trace_array_cpu *data,
				struct mmiotrace_rw *rw)
{
	struct ring_buffer_event *event;
	struct trace_mmiotrace_rw *entry;
	unsigned long irq_flags;

	event	= ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
					   &irq_flags);
	if (!event) {
		atomic_inc(&dropped_count);
		return;
	}
	entry	= ring_buffer_event_data(event);
	tracing_generic_entry_update(&entry->ent, 0, preempt_count());
	entry->ent.type			= TRACE_MMIO_RW;
	entry->rw			= *rw;
	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);

	trace_wake_up();
}

void mmio_trace_rw(struct mmiotrace_rw *rw)
{
	struct trace_array *tr = mmio_trace_array;
	struct trace_array_cpu *data = tr->data[smp_processor_id()];
	__trace_mmiotrace_rw(tr, data, rw);
}

static void __trace_mmiotrace_map(struct trace_array *tr,
				struct trace_array_cpu *data,
				struct mmiotrace_map *map)
{
	struct ring_buffer_event *event;
	struct trace_mmiotrace_map *entry;
	unsigned long irq_flags;

	event	= ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
					   &irq_flags);
	if (!event) {
		atomic_inc(&dropped_count);
		return;
	}
	entry	= ring_buffer_event_data(event);
	tracing_generic_entry_update(&entry->ent, 0, preempt_count());
	entry->ent.type			= TRACE_MMIO_MAP;
	entry->map			= *map;
	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);

	trace_wake_up();
}

void mmio_trace_mapping(struct mmiotrace_map *map)
{
	struct trace_array *tr = mmio_trace_array;
	struct trace_array_cpu *data;

	preempt_disable();
	data = tr->data[smp_processor_id()];
	__trace_mmiotrace_map(tr, data, map);
	preempt_enable();
}

int mmio_trace_printk(const char *fmt, va_list args)
{
	return trace_vprintk(0, -1, fmt, args);
}
Commit	Line	Data
f984b51e PP	1	/*
	2	* Memory mapped I/O tracing
	3	*
	4	* Copyright (C) 2008 Pekka Paalanen <pq@iki.fi>
	5	*/
	6
	7	#define DEBUG 1
	8
	9	#include <linux/kernel.h>
	10	#include <linux/mmiotrace.h>
13829537	11	#include <linux/pci.h>
173ed24e	12	#include <asm/atomic.h>
f984b51e PP	13
f984b51e PP	14	#include "trace.h"
f0868d1e	15	#include "trace_output.h"
f984b51e	16
d0a7e8ca PP	17	struct header_iter {
	18	struct pci_dev *dev;
	19	};
	20
f984b51e	21	static struct trace_array *mmio_trace_array;
2039238b	22	static bool overrun_detected;
7ee1768d	23	static unsigned long prev_overruns;
173ed24e	24	static atomic_t dropped_count;
f984b51e	25
bd8ac686 PP	26	static void mmio_reset_data(struct trace_array *tr)
bd8ac686 PP	27	{
2039238b	28	overrun_detected = false;
7ee1768d	29	prev_overruns = 0;
bd8ac686	30
213cc060	31	tracing_reset_online_cpus(tr);
bd8ac686	32	}
f984b51e	33
1c80025a	34	static int mmio_trace_init(struct trace_array *tr)
f984b51e PP	35	{
	36	pr_debug("in %s\n", __func__);
	37	mmio_trace_array = tr;
c76f0694 SR	38
	39	mmio_reset_data(tr);
	40	enable_mmiotrace();
1c80025a	41	return 0;
f984b51e PP	42	}
	43
	44	static void mmio_trace_reset(struct trace_array *tr)
	45	{
	46	pr_debug("in %s\n", __func__);
c76f0694 SR	47
c76f0694 SR	48	disable_mmiotrace();
bd8ac686 PP	49	mmio_reset_data(tr);
bd8ac686 PP	50	mmio_trace_array = NULL;
f984b51e PP	51	}
f984b51e PP	52
bbf5b1a0	53	static void mmio_trace_start(struct trace_array *tr)
f984b51e PP	54	{
f984b51e PP	55	pr_debug("in %s\n", __func__);
bbf5b1a0	56	mmio_reset_data(tr);
bd8ac686 PP	57	}
bd8ac686 PP	58
13829537 PP	59	static int mmio_print_pcidev(struct trace_seq s, const struct pci_dev dev)
	60	{
	61	int ret = 0;
	62	int i;
	63	resource_size_t start, end;
	64	const struct pci_driver *drv = pci_dev_driver(dev);
	65
	66	/* XXX: incomplete checks for trace_seq_printf() return value */
	67	ret += trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
	68	dev->bus->number, dev->devfn,
	69	dev->vendor, dev->device, dev->irq);
	70	/*
	71	* XXX: is pci_resource_to_user() appropriate, since we are
	72	* supposed to interpret the __ioremap() phys_addr argument based on
	73	* these printed values?
	74	*/
	75	for (i = 0; i < 7; i++) {
	76	pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
	77	ret += trace_seq_printf(s, " %llx",
	78	(unsigned long long)(start \|
	79	(dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
	80	}
	81	for (i = 0; i < 7; i++) {
	82	pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
	83	ret += trace_seq_printf(s, " %llx",
	84	dev->resource[i].start < dev->resource[i].end ?
	85	(unsigned long long)(end - start) + 1 : 0);
	86	}
	87	if (drv)
	88	ret += trace_seq_printf(s, " %s\n", drv->name);
	89	else
	90	ret += trace_seq_printf(s, " \n");
	91	return ret;
	92	}
	93
d0a7e8ca PP	94	static void destroy_header_iter(struct header_iter *hiter)
	95	{
	96	if (!hiter)
	97	return;
	98	pci_dev_put(hiter->dev);
	99	kfree(hiter);
	100	}
	101
	102	static void mmio_pipe_open(struct trace_iterator *iter)
bd8ac686	103	{
d0a7e8ca	104	struct header_iter *hiter;
bd8ac686	105	struct trace_seq *s = &iter->seq;
13829537 PP	106
	107	trace_seq_printf(s, "VERSION 20070824\n");
	108
d0a7e8ca PP	109	hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
	110	if (!hiter)
	111	return;
	112
	113	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
	114	iter->private = hiter;
	115	}
	116
	117	/* XXX: This is not called when the pipe is closed! */
	118	static void mmio_close(struct trace_iterator *iter)
	119	{
	120	struct header_iter *hiter = iter->private;
	121	destroy_header_iter(hiter);
	122	iter->private = NULL;
	123	}
	124
2039238b PP	125	static unsigned long count_overruns(struct trace_iterator *iter)
2039238b PP	126	{
173ed24e	127	unsigned long cnt = atomic_xchg(&dropped_count, 0);
7ee1768d PP	128	unsigned long over = ring_buffer_overruns(iter->tr->buffer);
	129
	130	if (over > prev_overruns)
173ed24e	131	cnt += over - prev_overruns;
7ee1768d	132	prev_overruns = over;
2039238b PP	133	return cnt;
	134	}
	135
d0a7e8ca PP	136	static ssize_t mmio_read(struct trace_iterator iter, struct file filp,
	137	char __user ubuf, size_t cnt, loff_t ppos)
	138	{
	139	ssize_t ret;
	140	struct header_iter *hiter = iter->private;
	141	struct trace_seq *s = &iter->seq;
2039238b PP	142	unsigned long n;
	143
	144	n = count_overruns(iter);
	145	if (n) {
	146	/* XXX: This is later than where events were lost. */
	147	trace_seq_printf(s, "MARK 0.000000 Lost %lu events.\n", n);
	148	if (!overrun_detected)
	149	pr_warning("mmiotrace has lost events.\n");
	150	overrun_detected = true;
	151	goto print_out;
	152	}
d0a7e8ca PP	153
	154	if (!hiter)
	155	return 0;
	156
	157	mmio_print_pcidev(s, hiter->dev);
	158	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, hiter->dev);
	159
	160	if (!hiter->dev) {
	161	destroy_header_iter(hiter);
	162	iter->private = NULL;
	163	}
	164
2039238b	165	print_out:
d0a7e8ca PP	166	ret = trace_seq_to_user(s, ubuf, cnt);
d0a7e8ca PP	167	return (ret == -EBUSY) ? 0 : ret;
bd8ac686 PP	168	}
bd8ac686 PP	169
07f4e4f7	170	static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
bd8ac686 PP	171	{
bd8ac686 PP	172	struct trace_entry *entry = iter->ent;
7104f300 SR	173	struct trace_mmiotrace_rw *field;
7104f300 SR	174	struct mmiotrace_rw *rw;
bd8ac686	175	struct trace_seq *s = &iter->seq;
3928a8a2	176	unsigned long long t = ns2usecs(iter->ts);
bd8ac686 PP	177	unsigned long usec_rem = do_div(t, 1000000ULL);
	178	unsigned secs = (unsigned long)t;
	179	int ret = 1;
	180
7104f300 SR	181	trace_assign_type(field, entry);
	182	rw = &field->rw;
	183
777e208d	184	switch (rw->opcode) {
bd8ac686 PP	185	case MMIO_READ:
bd8ac686 PP	186	ret = trace_seq_printf(s,
dee310d0 PP	187	"R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
	188	rw->width, secs, usec_rem, rw->map_id,
	189	(unsigned long long)rw->phys,
736ca61f	190	rw->value, rw->pc, 0);
bd8ac686 PP	191	break;
	192	case MMIO_WRITE:
	193	ret = trace_seq_printf(s,
dee310d0 PP	194	"W %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
	195	rw->width, secs, usec_rem, rw->map_id,
	196	(unsigned long long)rw->phys,
736ca61f	197	rw->value, rw->pc, 0);
bd8ac686 PP	198	break;
	199	case MMIO_UNKNOWN_OP:
	200	ret = trace_seq_printf(s,
dee310d0 PP	201	"UNKNOWN %lu.%06lu %d 0x%llx %02x,%02x,%02x 0x%lx %d\n",
	202	secs, usec_rem, rw->map_id,
	203	(unsigned long long)rw->phys,
bd8ac686	204	(rw->value >> 16) & 0xff, (rw->value >> 8) & 0xff,
736ca61f	205	(rw->value >> 0) & 0xff, rw->pc, 0);
bd8ac686 PP	206	break;
	207	default:
	208	ret = trace_seq_printf(s, "rw what?\n");
	209	break;
	210	}
	211	if (ret)
07f4e4f7 FW	212	return TRACE_TYPE_HANDLED;
07f4e4f7 FW	213	return TRACE_TYPE_PARTIAL_LINE;
bd8ac686 PP	214	}
bd8ac686 PP	215
07f4e4f7	216	static enum print_line_t mmio_print_map(struct trace_iterator *iter)
bd8ac686 PP	217	{
bd8ac686 PP	218	struct trace_entry *entry = iter->ent;
7104f300 SR	219	struct trace_mmiotrace_map *field;
7104f300 SR	220	struct mmiotrace_map *m;
bd8ac686	221	struct trace_seq *s = &iter->seq;
3928a8a2	222	unsigned long long t = ns2usecs(iter->ts);
bd8ac686 PP	223	unsigned long usec_rem = do_div(t, 1000000ULL);
bd8ac686 PP	224	unsigned secs = (unsigned long)t;
07f4e4f7	225	int ret;
bd8ac686	226
7104f300 SR	227	trace_assign_type(field, entry);
	228	m = &field->map;
	229
777e208d	230	switch (m->opcode) {
bd8ac686 PP	231	case MMIO_PROBE:
bd8ac686 PP	232	ret = trace_seq_printf(s,
dee310d0 PP	233	"MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
	234	secs, usec_rem, m->map_id,
	235	(unsigned long long)m->phys, m->virt, m->len,
e0fd5c2f	236	0UL, 0);
bd8ac686 PP	237	break;
	238	case MMIO_UNPROBE:
	239	ret = trace_seq_printf(s,
	240	"UNMAP %lu.%06lu %d 0x%lx %d\n",
e0fd5c2f	241	secs, usec_rem, m->map_id, 0UL, 0);
bd8ac686 PP	242	break;
	243	default:
	244	ret = trace_seq_printf(s, "map what?\n");
	245	break;
	246	}
	247	if (ret)
07f4e4f7 FW	248	return TRACE_TYPE_HANDLED;
07f4e4f7 FW	249	return TRACE_TYPE_PARTIAL_LINE;
bd8ac686 PP	250	}
bd8ac686 PP	251
07f4e4f7	252	static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
fc5e27ae PP	253	{
fc5e27ae PP	254	struct trace_entry *entry = iter->ent;
777e208d SR	255	struct print_entry print = (struct print_entry )entry;
777e208d SR	256	const char *msg = print->buf;
fc5e27ae	257	struct trace_seq *s = &iter->seq;
3928a8a2	258	unsigned long long t = ns2usecs(iter->ts);
fc5e27ae PP	259	unsigned long usec_rem = do_div(t, 1000000ULL);
	260	unsigned secs = (unsigned long)t;
	261	int ret;
	262
	263	/* The trailing newline must be in the message. */
	264	ret = trace_seq_printf(s, "MARK %lu.%06lu %s", secs, usec_rem, msg);
	265	if (!ret)
07f4e4f7	266	return TRACE_TYPE_PARTIAL_LINE;
fc5e27ae	267
07f4e4f7	268	return TRACE_TYPE_HANDLED;
fc5e27ae PP	269	}
fc5e27ae PP	270
07f4e4f7	271	static enum print_line_t mmio_print_line(struct trace_iterator *iter)
bd8ac686 PP	272	{
	273	switch (iter->ent->type) {
	274	case TRACE_MMIO_RW:
	275	return mmio_print_rw(iter);
	276	case TRACE_MMIO_MAP:
	277	return mmio_print_map(iter);
fc5e27ae PP	278	case TRACE_PRINT:
fc5e27ae PP	279	return mmio_print_mark(iter);
bd8ac686	280	default:
07f4e4f7	281	return TRACE_TYPE_HANDLED; /* ignore unknown entries */
bd8ac686	282	}
f984b51e PP	283	}
	284
	285	static struct tracer mmio_tracer __read_mostly =
	286	{
	287	.name = "mmiotrace",
	288	.init = mmio_trace_init,
	289	.reset = mmio_trace_reset,
bbf5b1a0	290	.start = mmio_trace_start,
d0a7e8ca PP	291	.pipe_open = mmio_pipe_open,
	292	.close = mmio_close,
	293	.read = mmio_read,
bd8ac686	294	.print_line = mmio_print_line,
f984b51e PP	295	};
	296
	297	__init static int init_mmio_trace(void)
	298	{
f984b51e PP	299	return register_tracer(&mmio_tracer);
	300	}
	301	device_initcall(init_mmio_trace);
	302
45dcd8b8 PP	303	static void __trace_mmiotrace_rw(struct trace_array *tr,
	304	struct trace_array_cpu *data,
	305	struct mmiotrace_rw *rw)
	306	{
3928a8a2	307	struct ring_buffer_event *event;
777e208d	308	struct trace_mmiotrace_rw *entry;
45dcd8b8 PP	309	unsigned long irq_flags;
45dcd8b8 PP	310
3928a8a2 SR	311	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
3928a8a2 SR	312	&irq_flags);
173ed24e PP	313	if (!event) {
173ed24e PP	314	atomic_inc(&dropped_count);
3928a8a2	315	return;
173ed24e	316	}
3928a8a2	317	entry = ring_buffer_event_data(event);
38697053	318	tracing_generic_entry_update(&entry->ent, 0, preempt_count());
777e208d SR	319	entry->ent.type = TRACE_MMIO_RW;
777e208d SR	320	entry->rw = *rw;
3928a8a2	321	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
45dcd8b8 PP	322
	323	trace_wake_up();
	324	}
	325
bd8ac686	326	void mmio_trace_rw(struct mmiotrace_rw *rw)
f984b51e PP	327	{
	328	struct trace_array *tr = mmio_trace_array;
	329	struct trace_array_cpu *data = tr->data[smp_processor_id()];
bd8ac686 PP	330	__trace_mmiotrace_rw(tr, data, rw);
bd8ac686 PP	331	}
f984b51e	332
45dcd8b8 PP	333	static void __trace_mmiotrace_map(struct trace_array *tr,
	334	struct trace_array_cpu *data,
	335	struct mmiotrace_map *map)
	336	{
3928a8a2	337	struct ring_buffer_event *event;
777e208d	338	struct trace_mmiotrace_map *entry;
45dcd8b8 PP	339	unsigned long irq_flags;
45dcd8b8 PP	340
3928a8a2 SR	341	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
3928a8a2 SR	342	&irq_flags);
173ed24e PP	343	if (!event) {
173ed24e PP	344	atomic_inc(&dropped_count);
3928a8a2	345	return;
173ed24e	346	}
3928a8a2	347	entry = ring_buffer_event_data(event);
38697053	348	tracing_generic_entry_update(&entry->ent, 0, preempt_count());
777e208d SR	349	entry->ent.type = TRACE_MMIO_MAP;
777e208d SR	350	entry->map = *map;
3928a8a2	351	ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
45dcd8b8 PP	352
	353	trace_wake_up();
	354	}
	355
bd8ac686 PP	356	void mmio_trace_mapping(struct mmiotrace_map *map)
	357	{
	358	struct trace_array *tr = mmio_trace_array;
	359	struct trace_array_cpu *data;
	360
	361	preempt_disable();
	362	data = tr->data[smp_processor_id()];
	363	__trace_mmiotrace_map(tr, data, map);
	364	preempt_enable();
f984b51e	365	}
9e57fb35 PP	366
	367	int mmio_trace_printk(const char *fmt, va_list args)
	368	{
1fd8f2a3	369	return trace_vprintk(0, -1, fmt, args);
9e57fb35	370	}