[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 bool overrun_detected;

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

	overrun_detected = false;
	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 unsigned long count_overruns(struct trace_iterator *iter)
{
	int cpu;
	unsigned long cnt = 0;
	for_each_online_cpu(cpu) {
		cnt += iter->overrun[cpu];
		iter->overrun[cpu] = 0;
	}
	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 int mmio_print_rw(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
	struct mmiotrace_rw *rw	= &entry->field.mmiorw;
	struct trace_seq *s	= &iter->seq;
	unsigned long long t	= ns2usecs(entry->field.t);
	unsigned long usec_rem	= do_div(t, 1000000ULL);
	unsigned secs		= (unsigned long)t;
	int ret = 1;

	switch (entry->field.mmiorw.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 1;
	return 0;
}

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

	switch (entry->field.mmiorw.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 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);

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

	raw_local_irq_save(irq_flags);
	__raw_spin_lock(&data->lock);

	entry				= tracing_get_trace_entry(tr, data);
	tracing_generic_entry_update(entry, 0);
	entry->type			= TRACE_MMIO_RW;
	entry->field.mmiorw		= *rw;

	__raw_spin_unlock(&data->lock);
	raw_local_irq_restore(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 trace_entry *entry;
	unsigned long irq_flags;

	raw_local_irq_save(irq_flags);
	__raw_spin_lock(&data->lock);

	entry				= tracing_get_trace_entry(tr, data);
	tracing_generic_entry_update(entry, 0);
	entry->type			= TRACE_MMIO_MAP;
	entry->field.mmiomap		= *map;

	__raw_spin_unlock(&data->lock);
	raw_local_irq_restore(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();
}
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	19	static struct trace_array *mmio_trace_array;
2039238b	20	static bool overrun_detected;
f984b51e	21
bd8ac686 PP	22	static void mmio_reset_data(struct trace_array *tr)
	23	{
	24	int cpu;
	25
2039238b	26	overrun_detected = false;
bd8ac686 PP	27	tr->time_start = ftrace_now(tr->cpu);
	28
	29	for_each_online_cpu(cpu)
	30	tracing_reset(tr->data[cpu]);
	31	}
f984b51e PP	32
	33	static void mmio_trace_init(struct trace_array *tr)
	34	{
	35	pr_debug("in %s\n", __func__);
	36	mmio_trace_array = tr;
bd8ac686 PP	37	if (tr->ctrl) {
bd8ac686 PP	38	mmio_reset_data(tr);
f984b51e	39	enable_mmiotrace();
bd8ac686	40	}
f984b51e PP	41	}
	42
	43	static void mmio_trace_reset(struct trace_array *tr)
	44	{
	45	pr_debug("in %s\n", __func__);
	46	if (tr->ctrl)
	47	disable_mmiotrace();
bd8ac686 PP	48	mmio_reset_data(tr);
bd8ac686 PP	49	mmio_trace_array = NULL;
f984b51e PP	50	}
	51
	52	static void mmio_trace_ctrl_update(struct trace_array *tr)
	53	{
	54	pr_debug("in %s\n", __func__);
bd8ac686 PP	55	if (tr->ctrl) {
bd8ac686 PP	56	mmio_reset_data(tr);
f984b51e	57	enable_mmiotrace();
bd8ac686	58	} else {
f984b51e	59	disable_mmiotrace();
bd8ac686 PP	60	}
	61	}
	62
13829537 PP	63	static int mmio_print_pcidev(struct trace_seq s, const struct pci_dev dev)
	64	{
	65	int ret = 0;
	66	int i;
	67	resource_size_t start, end;
	68	const struct pci_driver *drv = pci_dev_driver(dev);
	69
	70	/* XXX: incomplete checks for trace_seq_printf() return value */
	71	ret += trace_seq_printf(s, "PCIDEV %02x%02x %04x%04x %x",
	72	dev->bus->number, dev->devfn,
	73	dev->vendor, dev->device, dev->irq);
	74	/*
	75	* XXX: is pci_resource_to_user() appropriate, since we are
	76	* supposed to interpret the __ioremap() phys_addr argument based on
	77	* these printed values?
	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	(unsigned long long)(start \|
	83	(dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
	84	}
	85	for (i = 0; i < 7; i++) {
	86	pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
	87	ret += trace_seq_printf(s, " %llx",
	88	dev->resource[i].start < dev->resource[i].end ?
	89	(unsigned long long)(end - start) + 1 : 0);
	90	}
	91	if (drv)
	92	ret += trace_seq_printf(s, " %s\n", drv->name);
	93	else
	94	ret += trace_seq_printf(s, " \n");
	95	return ret;
	96	}
	97
d0a7e8ca PP	98	static void destroy_header_iter(struct header_iter *hiter)
	99	{
	100	if (!hiter)
	101	return;
	102	pci_dev_put(hiter->dev);
	103	kfree(hiter);
	104	}
	105
	106	static void mmio_pipe_open(struct trace_iterator *iter)
bd8ac686	107	{
d0a7e8ca	108	struct header_iter *hiter;
bd8ac686	109	struct trace_seq *s = &iter->seq;
13829537 PP	110
	111	trace_seq_printf(s, "VERSION 20070824\n");
	112
d0a7e8ca PP	113	hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
	114	if (!hiter)
	115	return;
	116
	117	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
	118	iter->private = hiter;
	119	}
	120
	121	/* XXX: This is not called when the pipe is closed! */
	122	static void mmio_close(struct trace_iterator *iter)
	123	{
	124	struct header_iter *hiter = iter->private;
	125	destroy_header_iter(hiter);
	126	iter->private = NULL;
	127	}
	128
2039238b PP	129	static unsigned long count_overruns(struct trace_iterator *iter)
	130	{
	131	int cpu;
	132	unsigned long cnt = 0;
	133	for_each_online_cpu(cpu) {
	134	cnt += iter->overrun[cpu];
	135	iter->overrun[cpu] = 0;
	136	}
	137	return cnt;
	138	}
	139
d0a7e8ca PP	140	static ssize_t mmio_read(struct trace_iterator iter, struct file filp,
	141	char __user ubuf, size_t cnt, loff_t ppos)
	142	{
	143	ssize_t ret;
	144	struct header_iter *hiter = iter->private;
	145	struct trace_seq *s = &iter->seq;
2039238b PP	146	unsigned long n;
	147
	148	n = count_overruns(iter);
	149	if (n) {
	150	/* XXX: This is later than where events were lost. */
	151	trace_seq_printf(s, "MARK 0.000000 Lost %lu events.\n", n);
	152	if (!overrun_detected)
	153	pr_warning("mmiotrace has lost events.\n");
	154	overrun_detected = true;
	155	goto print_out;
	156	}
d0a7e8ca PP	157
	158	if (!hiter)
	159	return 0;
	160
	161	mmio_print_pcidev(s, hiter->dev);
	162	hiter->dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, hiter->dev);
	163
	164	if (!hiter->dev) {
	165	destroy_header_iter(hiter);
	166	iter->private = NULL;
	167	}
	168
2039238b	169	print_out:
d0a7e8ca PP	170	ret = trace_seq_to_user(s, ubuf, cnt);
d0a7e8ca PP	171	return (ret == -EBUSY) ? 0 : ret;
bd8ac686 PP	172	}
	173
	174	static int mmio_print_rw(struct trace_iterator *iter)
	175	{
	176	struct trace_entry *entry = iter->ent;
2e2ca155	177	struct mmiotrace_rw *rw = &entry->field.mmiorw;
bd8ac686	178	struct trace_seq *s = &iter->seq;
2e2ca155	179	unsigned long long t = ns2usecs(entry->field.t);
bd8ac686 PP	180	unsigned long usec_rem = do_div(t, 1000000ULL);
	181	unsigned secs = (unsigned long)t;
	182	int ret = 1;
	183
2e2ca155	184	switch (entry->field.mmiorw.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)
	212	return 1;
	213	return 0;
	214	}
	215
	216	static int mmio_print_map(struct trace_iterator *iter)
	217	{
	218	struct trace_entry *entry = iter->ent;
2e2ca155	219	struct mmiotrace_map *m = &entry->field.mmiomap;
bd8ac686	220	struct trace_seq *s = &iter->seq;
2e2ca155	221	unsigned long long t = ns2usecs(entry->field.t);
bd8ac686 PP	222	unsigned long usec_rem = do_div(t, 1000000ULL);
	223	unsigned secs = (unsigned long)t;
	224	int ret = 1;
	225
2e2ca155	226	switch (entry->field.mmiorw.opcode) {
bd8ac686 PP	227	case MMIO_PROBE:
bd8ac686 PP	228	ret = trace_seq_printf(s,
dee310d0 PP	229	"MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
	230	secs, usec_rem, m->map_id,
	231	(unsigned long long)m->phys, m->virt, m->len,
e0fd5c2f	232	0UL, 0);
bd8ac686 PP	233	break;
	234	case MMIO_UNPROBE:
	235	ret = trace_seq_printf(s,
	236	"UNMAP %lu.%06lu %d 0x%lx %d\n",
e0fd5c2f	237	secs, usec_rem, m->map_id, 0UL, 0);
bd8ac686 PP	238	break;
	239	default:
	240	ret = trace_seq_printf(s, "map what?\n");
	241	break;
	242	}
	243	if (ret)
	244	return 1;
	245	return 0;
	246	}
	247
	248	/* return 0 to abort printing without consuming current entry in pipe mode */
	249	static int mmio_print_line(struct trace_iterator *iter)
	250	{
	251	switch (iter->ent->type) {
	252	case TRACE_MMIO_RW:
	253	return mmio_print_rw(iter);
	254	case TRACE_MMIO_MAP:
	255	return mmio_print_map(iter);
	256	default:
	257	return 1; /* ignore unknown entries */
	258	}
f984b51e PP	259	}
	260
	261	static struct tracer mmio_tracer __read_mostly =
	262	{
	263	.name = "mmiotrace",
	264	.init = mmio_trace_init,
	265	.reset = mmio_trace_reset,
d0a7e8ca PP	266	.pipe_open = mmio_pipe_open,
	267	.close = mmio_close,
	268	.read = mmio_read,
f984b51e	269	.ctrl_update = mmio_trace_ctrl_update,
bd8ac686	270	.print_line = mmio_print_line,
f984b51e PP	271	};
	272
	273	__init static int init_mmio_trace(void)
	274	{
f984b51e PP	275	return register_tracer(&mmio_tracer);
	276	}
	277	device_initcall(init_mmio_trace);
	278
45dcd8b8 PP	279	static void __trace_mmiotrace_rw(struct trace_array *tr,
	280	struct trace_array_cpu *data,
	281	struct mmiotrace_rw *rw)
	282	{
	283	struct trace_entry *entry;
	284	unsigned long irq_flags;
	285
	286	raw_local_irq_save(irq_flags);
	287	__raw_spin_lock(&data->lock);
	288
	289	entry = tracing_get_trace_entry(tr, data);
	290	tracing_generic_entry_update(entry, 0);
	291	entry->type = TRACE_MMIO_RW;
	292	entry->field.mmiorw = *rw;
	293
	294	__raw_spin_unlock(&data->lock);
	295	raw_local_irq_restore(irq_flags);
	296
	297	trace_wake_up();
	298	}
	299
bd8ac686	300	void mmio_trace_rw(struct mmiotrace_rw *rw)
f984b51e PP	301	{
	302	struct trace_array *tr = mmio_trace_array;
	303	struct trace_array_cpu *data = tr->data[smp_processor_id()];
bd8ac686 PP	304	__trace_mmiotrace_rw(tr, data, rw);
bd8ac686 PP	305	}
f984b51e	306
45dcd8b8 PP	307	static void __trace_mmiotrace_map(struct trace_array *tr,
	308	struct trace_array_cpu *data,
	309	struct mmiotrace_map *map)
	310	{
	311	struct trace_entry *entry;
	312	unsigned long irq_flags;
	313
	314	raw_local_irq_save(irq_flags);
	315	__raw_spin_lock(&data->lock);
	316
	317	entry = tracing_get_trace_entry(tr, data);
	318	tracing_generic_entry_update(entry, 0);
	319	entry->type = TRACE_MMIO_MAP;
	320	entry->field.mmiomap = *map;
	321
	322	__raw_spin_unlock(&data->lock);
	323	raw_local_irq_restore(irq_flags);
	324
	325	trace_wake_up();
	326	}
	327
bd8ac686 PP	328	void mmio_trace_mapping(struct mmiotrace_map *map)
	329	{
	330	struct trace_array *tr = mmio_trace_array;
	331	struct trace_array_cpu *data;
	332
	333	preempt_disable();
	334	data = tr->data[smp_processor_id()];
	335	__trace_mmiotrace_map(tr, data, map);
	336	preempt_enable();
f984b51e	337	}