[GitHub/mt8127/android_kernel_alcatel_ttab.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 <linux/slab.h>
#include <linux/time.h>

#include <linux/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->trace_buffer);
}

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->trace_buffer->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, USEC_PER_SEC);
	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 %u.%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 %u.%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 %u.%06lu %d 0x%llx %02lx,%02lx,"
			"%02lx 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, USEC_PER_SEC);
	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 %u.%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 %u.%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, USEC_PER_SEC);
	unsigned secs		= (unsigned long)t;
	int ret;

	/* The trailing newline must be in the message. */
	ret = trace_seq_printf(s, "MARK %u.%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 ftrace_event_call *call = &event_mmiotrace_rw;
	struct ring_buffer *buffer = tr->trace_buffer.buffer;
	struct ring_buffer_event *event;
	struct trace_mmiotrace_rw *entry;
	int pc = preempt_count();

	event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_RW,
					  sizeof(*entry), 0, pc);
	if (!event) {
		atomic_inc(&dropped_count);
		return;
	}
	entry	= ring_buffer_event_data(event);
	entry->rw			= *rw;

	if (!filter_check_discard(call, entry, buffer, event))
		trace_buffer_unlock_commit(buffer, event, 0, pc);
}

void mmio_trace_rw(struct mmiotrace_rw *rw)
{
	struct trace_array *tr = mmio_trace_array;
	struct trace_array_cpu *data = per_cpu_ptr(tr->trace_buffer.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 ftrace_event_call *call = &event_mmiotrace_map;
	struct ring_buffer *buffer = tr->trace_buffer.buffer;
	struct ring_buffer_event *event;
	struct trace_mmiotrace_map *entry;
	int pc = preempt_count();

	event = trace_buffer_lock_reserve(buffer, TRACE_MMIO_MAP,
					  sizeof(*entry), 0, pc);
	if (!event) {
		atomic_inc(&dropped_count);
		return;
	}
	entry	= ring_buffer_event_data(event);
	entry->map			= *map;

	if (!filter_check_discard(call, entry, buffer, event))
		trace_buffer_unlock_commit(buffer, event, 0, pc);
}

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

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