[linux-2.6-block.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"

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

/* XXX: This is not called for trace_pipe file! */
static void mmio_print_header(struct trace_iterator *iter)
{
	struct trace_seq *s = &iter->seq;
	struct pci_dev *dev = NULL;

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

	for_each_pci_dev(dev)
		mmio_print_pcidev(s, dev);
	/* XXX: return value? What if header is very long? */
}

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