[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 "trace.h"

struct header_iter {
	struct pci_dev *dev;
};

static struct trace_array *mmio_trace_array;

static void mmio_reset_data(struct trace_array *tr)
{
	int cpu;

	tr->time_start = ftrace_now(tr->cpu);

	for_each_online_cpu(cpu)
		tracing_reset(tr->data[cpu]);
}

static void mmio_trace_init(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);
	mmio_trace_array = tr;
	if (tr->ctrl) {
		mmio_reset_data(tr);
		enable_mmiotrace();
	}
}

static void mmio_trace_reset(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);
	if (tr->ctrl)
		disable_mmiotrace();
	mmio_reset_data(tr);
	mmio_trace_array = NULL;
}

static void mmio_trace_ctrl_update(struct trace_array *tr)
{
	pr_debug("in %s\n", __func__);
	if (tr->ctrl) {
		mmio_reset_data(tr);
		enable_mmiotrace();
	} else {
		disable_mmiotrace();
	}
}

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 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;

	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;
	}

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

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

	switch (entry->mmiorw.opcode) {
	case MMIO_READ:
		ret = trace_seq_printf(s,
			"R %d %lu.%06lu %d 0x%lx 0x%lx 0x%lx %d\n",
			rw->width, secs, usec_rem, rw->map_id, rw->phys,
			rw->value, rw->pc, 0);
		break;
	case MMIO_WRITE:
		ret = trace_seq_printf(s,
			"W %d %lu.%06lu %d 0x%lx 0x%lx 0x%lx %d\n",
			rw->width, secs, usec_rem, rw->map_id, rw->phys,
			rw->value, rw->pc, 0);
		break;
	case MMIO_UNKNOWN_OP:
		ret = trace_seq_printf(s,
			"UNKNOWN %lu.%06lu %d 0x%lx %02x,%02x,%02x 0x%lx %d\n",
			secs, usec_rem, rw->map_id, 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 1;
	return 0;
}

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

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

/* return 0 to abort printing without consuming current entry in pipe mode */
static int 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);
	default:
		return 1; /* ignore unknown entries */
	}
}

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

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

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);
}

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();
}
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>
f984b51e PP	12
	13	#include "trace.h"
	14
d0a7e8ca PP	15	struct header_iter {
	16	struct pci_dev *dev;
	17	};
	18
f984b51e PP	19	static struct trace_array *mmio_trace_array;
f984b51e PP	20
bd8ac686 PP	21	static void mmio_reset_data(struct trace_array *tr)
	22	{
	23	int cpu;
	24
	25	tr->time_start = ftrace_now(tr->cpu);
	26
	27	for_each_online_cpu(cpu)
	28	tracing_reset(tr->data[cpu]);
	29	}
f984b51e PP	30
	31	static void mmio_trace_init(struct trace_array *tr)
	32	{
	33	pr_debug("in %s\n", __func__);
	34	mmio_trace_array = tr;
bd8ac686 PP	35	if (tr->ctrl) {
bd8ac686 PP	36	mmio_reset_data(tr);
f984b51e	37	enable_mmiotrace();
bd8ac686	38	}
f984b51e PP	39	}
	40
	41	static void mmio_trace_reset(struct trace_array *tr)
	42	{
	43	pr_debug("in %s\n", __func__);
	44	if (tr->ctrl)
	45	disable_mmiotrace();
bd8ac686 PP	46	mmio_reset_data(tr);
bd8ac686 PP	47	mmio_trace_array = NULL;
f984b51e PP	48	}
	49
	50	static void mmio_trace_ctrl_update(struct trace_array *tr)
	51	{
	52	pr_debug("in %s\n", __func__);
bd8ac686 PP	53	if (tr->ctrl) {
bd8ac686 PP	54	mmio_reset_data(tr);
f984b51e	55	enable_mmiotrace();
bd8ac686	56	} else {
f984b51e	57	disable_mmiotrace();
bd8ac686 PP	58	}
	59	}
	60
13829537 PP	61	static int mmio_print_pcidev(struct trace_seq s, const struct pci_dev dev)
	62	{
	63	int ret = 0;
	64	int i;
	65	resource_size_t start, end;
	66	const struct pci_driver *drv = pci_dev_driver(dev);
	67
	68	/* XXX: incomplete checks for trace_seq_printf() return value */
	69	ret += trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
	70	dev->bus->number, dev->devfn,
	71	dev->vendor, dev->device, dev->irq);
	72	/*
	73	* XXX: is pci_resource_to_user() appropriate, since we are
	74	* supposed to interpret the __ioremap() phys_addr argument based on
	75	* these printed values?
	76	*/
	77	for (i = 0; i < 7; i++) {
	78	pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
	79	ret += trace_seq_printf(s, " %llx",
	80	(unsigned long long)(start \|
	81	(dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
	82	}
	83	for (i = 0; i < 7; i++) {
	84	pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
	85	ret += trace_seq_printf(s, " %llx",
	86	dev->resource[i].start < dev->resource[i].end ?
	87	(unsigned long long)(end - start) + 1 : 0);
	88	}
	89	if (drv)
	90	ret += trace_seq_printf(s, " %s\n", drv->name);
	91	else
	92	ret += trace_seq_printf(s, " \n");
	93	return ret;
	94	}
	95
d0a7e8ca PP	96	static void destroy_header_iter(struct header_iter *hiter)
	97	{
	98	if (!hiter)
	99	return;
	100	pci_dev_put(hiter->dev);
	101	kfree(hiter);
	102	}
	103
	104	static void mmio_pipe_open(struct trace_iterator *iter)
bd8ac686	105	{
d0a7e8ca	106	struct header_iter *hiter;
bd8ac686	107	struct trace_seq *s = &iter->seq;
13829537 PP	108
	109	trace_seq_printf(s, "VERSION 20070824\n");
	110
d0a7e8ca PP	111	hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
	112	if (!hiter)
	113	return;
	114
	115	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
	116	iter->private = hiter;
	117	}
	118
	119	/* XXX: This is not called when the pipe is closed! */
	120	static void mmio_close(struct trace_iterator *iter)
	121	{
	122	struct header_iter *hiter = iter->private;
	123	destroy_header_iter(hiter);
	124	iter->private = NULL;
	125	}
	126
	127	static ssize_t mmio_read(struct trace_iterator iter, struct file filp,
	128	char __user ubuf, size_t cnt, loff_t ppos)
	129	{
	130	ssize_t ret;
	131	struct header_iter *hiter = iter->private;
	132	struct trace_seq *s = &iter->seq;
	133
	134	if (!hiter)
	135	return 0;
	136
	137	mmio_print_pcidev(s, hiter->dev);
	138	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, hiter->dev);
	139
	140	if (!hiter->dev) {
	141	destroy_header_iter(hiter);
	142	iter->private = NULL;
	143	}
	144
	145	ret = trace_seq_to_user(s, ubuf, cnt);
	146	return (ret == -EBUSY) ? 0 : ret;
bd8ac686 PP	147	}
	148
	149	static int mmio_print_rw(struct trace_iterator *iter)
	150	{
	151	struct trace_entry *entry = iter->ent;
	152	struct mmiotrace_rw *rw = &entry->mmiorw;
	153	struct trace_seq *s = &iter->seq;
	154	unsigned long long t = ns2usecs(entry->t);
	155	unsigned long usec_rem = do_div(t, 1000000ULL);
	156	unsigned secs = (unsigned long)t;
	157	int ret = 1;
	158
	159	switch (entry->mmiorw.opcode) {
	160	case MMIO_READ:
	161	ret = trace_seq_printf(s,
	162	"R %d %lu.%06lu %d 0x%lx 0x%lx 0x%lx %d\n",
	163	rw->width, secs, usec_rem, rw->map_id, rw->phys,
736ca61f	164	rw->value, rw->pc, 0);
bd8ac686 PP	165	break;
	166	case MMIO_WRITE:
	167	ret = trace_seq_printf(s,
	168	"W %d %lu.%06lu %d 0x%lx 0x%lx 0x%lx %d\n",
	169	rw->width, secs, usec_rem, rw->map_id, rw->phys,
736ca61f	170	rw->value, rw->pc, 0);
bd8ac686 PP	171	break;
	172	case MMIO_UNKNOWN_OP:
	173	ret = trace_seq_printf(s,
	174	"UNKNOWN %lu.%06lu %d 0x%lx %02x,%02x,%02x 0x%lx %d\n",
	175	secs, usec_rem, rw->map_id, rw->phys,
	176	(rw->value >> 16) & 0xff, (rw->value >> 8) & 0xff,
736ca61f	177	(rw->value >> 0) & 0xff, rw->pc, 0);
bd8ac686 PP	178	break;
	179	default:
	180	ret = trace_seq_printf(s, "rw what?\n");
	181	break;
	182	}
	183	if (ret)
	184	return 1;
	185	return 0;
	186	}
	187
	188	static int mmio_print_map(struct trace_iterator *iter)
	189	{
	190	struct trace_entry *entry = iter->ent;
	191	struct mmiotrace_map *m = &entry->mmiomap;
	192	struct trace_seq *s = &iter->seq;
	193	unsigned long long t = ns2usecs(entry->t);
	194	unsigned long usec_rem = do_div(t, 1000000ULL);
	195	unsigned secs = (unsigned long)t;
	196	int ret = 1;
	197
	198	switch (entry->mmiorw.opcode) {
	199	case MMIO_PROBE:
	200	ret = trace_seq_printf(s,
	201	"MAP %lu.%06lu %d 0x%lx 0x%lx 0x%lx 0x%lx %d\n",
	202	secs, usec_rem, m->map_id, m->phys, m->virt, m->len,
	203	0UL, entry->pid);
	204	break;
	205	case MMIO_UNPROBE:
	206	ret = trace_seq_printf(s,
	207	"UNMAP %lu.%06lu %d 0x%lx %d\n",
	208	secs, usec_rem, m->map_id, 0UL, entry->pid);
	209	break;
	210	default:
	211	ret = trace_seq_printf(s, "map what?\n");
	212	break;
	213	}
	214	if (ret)
	215	return 1;
	216	return 0;
	217	}
	218
	219	/* return 0 to abort printing without consuming current entry in pipe mode */
	220	static int mmio_print_line(struct trace_iterator *iter)
	221	{
	222	switch (iter->ent->type) {
	223	case TRACE_MMIO_RW:
	224	return mmio_print_rw(iter);
	225	case TRACE_MMIO_MAP:
	226	return mmio_print_map(iter);
	227	default:
	228	return 1; /* ignore unknown entries */
	229	}
f984b51e PP	230	}
	231
	232	static struct tracer mmio_tracer __read_mostly =
	233	{
	234	.name = "mmiotrace",
	235	.init = mmio_trace_init,
	236	.reset = mmio_trace_reset,
d0a7e8ca PP	237	.pipe_open = mmio_pipe_open,
	238	.close = mmio_close,
	239	.read = mmio_read,
f984b51e	240	.ctrl_update = mmio_trace_ctrl_update,
bd8ac686	241	.print_line = mmio_print_line,
f984b51e PP	242	};
	243
	244	__init static int init_mmio_trace(void)
	245	{
f984b51e PP	246	return register_tracer(&mmio_tracer);
	247	}
	248	device_initcall(init_mmio_trace);
	249
bd8ac686	250	void mmio_trace_rw(struct mmiotrace_rw *rw)
f984b51e PP	251	{
	252	struct trace_array *tr = mmio_trace_array;
	253	struct trace_array_cpu *data = tr->data[smp_processor_id()];
bd8ac686 PP	254	__trace_mmiotrace_rw(tr, data, rw);
bd8ac686 PP	255	}
f984b51e	256
bd8ac686 PP	257	void mmio_trace_mapping(struct mmiotrace_map *map)
	258	{
	259	struct trace_array *tr = mmio_trace_array;
	260	struct trace_array_cpu *data;
	261
	262	preempt_disable();
	263	data = tr->data[smp_processor_id()];
	264	__trace_mmiotrace_map(tr, data, map);
	265	preempt_enable();
f984b51e	266	}