2008-05-12 15:20:56 -04:00
|
|
|
/*
|
|
|
|
* Written by Pekka Paalanen, 2008 <pq@iki.fi>
|
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
2008-05-12 15:21:03 -04:00
|
|
|
#include <linux/io.h>
|
2008-09-16 15:00:34 -04:00
|
|
|
#include <linux/mmiotrace.h>
|
2008-05-12 15:20:56 -04:00
|
|
|
|
|
|
|
#define MODULE_NAME "testmmiotrace"
|
|
|
|
|
|
|
|
static unsigned long mmio_address;
|
|
|
|
module_param(mmio_address, ulong, 0);
|
|
|
|
MODULE_PARM_DESC(mmio_address, "Start address of the mapping of 16 kB.");
|
|
|
|
|
|
|
|
static void do_write_test(void __iomem *p)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2008-09-16 15:00:34 -04:00
|
|
|
mmiotrace_printk("Write test.\n");
|
2008-05-12 15:20:56 -04:00
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
iowrite8(i, p + i);
|
|
|
|
for (i = 1024; i < (5 * 1024); i += 2)
|
|
|
|
iowrite16(i * 12 + 7, p + i);
|
|
|
|
for (i = (5 * 1024); i < (16 * 1024); i += 4)
|
|
|
|
iowrite32(i * 212371 + 13, p + i);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_read_test(void __iomem *p)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2008-09-16 15:00:34 -04:00
|
|
|
mmiotrace_printk("Read test.\n");
|
2008-05-12 15:20:56 -04:00
|
|
|
for (i = 0; i < 256; i++)
|
2008-05-12 15:20:57 -04:00
|
|
|
ioread8(p + i);
|
2008-05-12 15:20:56 -04:00
|
|
|
for (i = 1024; i < (5 * 1024); i += 2)
|
2008-05-12 15:20:57 -04:00
|
|
|
ioread16(p + i);
|
2008-05-12 15:20:56 -04:00
|
|
|
for (i = (5 * 1024); i < (16 * 1024); i += 4)
|
2008-05-12 15:20:57 -04:00
|
|
|
ioread32(p + i);
|
2008-05-12 15:20:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void do_test(void)
|
|
|
|
{
|
2008-05-12 15:20:57 -04:00
|
|
|
void __iomem *p = ioremap_nocache(mmio_address, 0x4000);
|
2008-05-12 15:20:56 -04:00
|
|
|
if (!p) {
|
x86: mmiotrace full patch, preview 1
kmmio.c handles the list of mmio probes with callbacks, list of traced
pages, and attaching into the page fault handler and die notifier. It
arms, traps and disarms the given pages, this is the core of mmiotrace.
mmio-mod.c is a user interface, hooking into ioremap functions and
registering the mmio probes. It also decodes the required information
from trapped mmio accesses via the pre and post callbacks in each probe.
Currently, hooking into ioremap functions works by redefining the symbols
of the target (binary) kernel module, so that it calls the traced
versions of the functions.
The most notable changes done since the last discussion are:
- kmmio.c is a built-in, not part of the module
- direct call from fault.c to kmmio.c, removing all dynamic hooks
- prepare for unregistering probes at any time
- make kmmio re-initializable and accessible to more than one user
- rewrite kmmio locking to remove all spinlocks from page fault path
Can I abuse call_rcu() like I do in kmmio.c:unregister_kmmio_probe()
or is there a better way?
The function called via call_rcu() itself calls call_rcu() again,
will this work or break? There I need a second grace period for RCU
after the first grace period for page faults.
Mmiotrace itself (mmio-mod.c) is still a module, I am going to attack
that next. At some point I will start looking into how to make mmiotrace
a tracer component of ftrace (thanks for the hint, Ingo). Ftrace should
make the user space part of mmiotracing as simple as
'cat /debug/trace/mmio > dump.txt'.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 15:20:57 -04:00
|
|
|
pr_err(MODULE_NAME ": could not ioremap, aborting.\n");
|
2008-05-12 15:20:56 -04:00
|
|
|
return;
|
|
|
|
}
|
2008-09-16 15:00:34 -04:00
|
|
|
mmiotrace_printk("ioremap returned %p.\n", p);
|
2008-05-12 15:20:56 -04:00
|
|
|
do_write_test(p);
|
|
|
|
do_read_test(p);
|
2008-05-12 15:20:57 -04:00
|
|
|
iounmap(p);
|
2008-05-12 15:20:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init init(void)
|
|
|
|
{
|
|
|
|
if (mmio_address == 0) {
|
x86: mmiotrace full patch, preview 1
kmmio.c handles the list of mmio probes with callbacks, list of traced
pages, and attaching into the page fault handler and die notifier. It
arms, traps and disarms the given pages, this is the core of mmiotrace.
mmio-mod.c is a user interface, hooking into ioremap functions and
registering the mmio probes. It also decodes the required information
from trapped mmio accesses via the pre and post callbacks in each probe.
Currently, hooking into ioremap functions works by redefining the symbols
of the target (binary) kernel module, so that it calls the traced
versions of the functions.
The most notable changes done since the last discussion are:
- kmmio.c is a built-in, not part of the module
- direct call from fault.c to kmmio.c, removing all dynamic hooks
- prepare for unregistering probes at any time
- make kmmio re-initializable and accessible to more than one user
- rewrite kmmio locking to remove all spinlocks from page fault path
Can I abuse call_rcu() like I do in kmmio.c:unregister_kmmio_probe()
or is there a better way?
The function called via call_rcu() itself calls call_rcu() again,
will this work or break? There I need a second grace period for RCU
after the first grace period for page faults.
Mmiotrace itself (mmio-mod.c) is still a module, I am going to attack
that next. At some point I will start looking into how to make mmiotrace
a tracer component of ftrace (thanks for the hint, Ingo). Ftrace should
make the user space part of mmiotracing as simple as
'cat /debug/trace/mmio > dump.txt'.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 15:20:57 -04:00
|
|
|
pr_err(MODULE_NAME ": you have to use the module argument "
|
|
|
|
"mmio_address.\n");
|
|
|
|
pr_err(MODULE_NAME ": DO NOT LOAD THIS MODULE UNLESS"
|
2008-05-12 15:20:56 -04:00
|
|
|
" YOU REALLY KNOW WHAT YOU ARE DOING!\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
x86: mmiotrace full patch, preview 1
kmmio.c handles the list of mmio probes with callbacks, list of traced
pages, and attaching into the page fault handler and die notifier. It
arms, traps and disarms the given pages, this is the core of mmiotrace.
mmio-mod.c is a user interface, hooking into ioremap functions and
registering the mmio probes. It also decodes the required information
from trapped mmio accesses via the pre and post callbacks in each probe.
Currently, hooking into ioremap functions works by redefining the symbols
of the target (binary) kernel module, so that it calls the traced
versions of the functions.
The most notable changes done since the last discussion are:
- kmmio.c is a built-in, not part of the module
- direct call from fault.c to kmmio.c, removing all dynamic hooks
- prepare for unregistering probes at any time
- make kmmio re-initializable and accessible to more than one user
- rewrite kmmio locking to remove all spinlocks from page fault path
Can I abuse call_rcu() like I do in kmmio.c:unregister_kmmio_probe()
or is there a better way?
The function called via call_rcu() itself calls call_rcu() again,
will this work or break? There I need a second grace period for RCU
after the first grace period for page faults.
Mmiotrace itself (mmio-mod.c) is still a module, I am going to attack
that next. At some point I will start looking into how to make mmiotrace
a tracer component of ftrace (thanks for the hint, Ingo). Ftrace should
make the user space part of mmiotracing as simple as
'cat /debug/trace/mmio > dump.txt'.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 15:20:57 -04:00
|
|
|
pr_warning(MODULE_NAME ": WARNING: mapping 16 kB @ 0x%08lx "
|
2008-05-12 15:20:56 -04:00
|
|
|
"in PCI address space, and writing "
|
|
|
|
"rubbish in there.\n", mmio_address);
|
|
|
|
do_test();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit cleanup(void)
|
|
|
|
{
|
x86: mmiotrace full patch, preview 1
kmmio.c handles the list of mmio probes with callbacks, list of traced
pages, and attaching into the page fault handler and die notifier. It
arms, traps and disarms the given pages, this is the core of mmiotrace.
mmio-mod.c is a user interface, hooking into ioremap functions and
registering the mmio probes. It also decodes the required information
from trapped mmio accesses via the pre and post callbacks in each probe.
Currently, hooking into ioremap functions works by redefining the symbols
of the target (binary) kernel module, so that it calls the traced
versions of the functions.
The most notable changes done since the last discussion are:
- kmmio.c is a built-in, not part of the module
- direct call from fault.c to kmmio.c, removing all dynamic hooks
- prepare for unregistering probes at any time
- make kmmio re-initializable and accessible to more than one user
- rewrite kmmio locking to remove all spinlocks from page fault path
Can I abuse call_rcu() like I do in kmmio.c:unregister_kmmio_probe()
or is there a better way?
The function called via call_rcu() itself calls call_rcu() again,
will this work or break? There I need a second grace period for RCU
after the first grace period for page faults.
Mmiotrace itself (mmio-mod.c) is still a module, I am going to attack
that next. At some point I will start looking into how to make mmiotrace
a tracer component of ftrace (thanks for the hint, Ingo). Ftrace should
make the user space part of mmiotracing as simple as
'cat /debug/trace/mmio > dump.txt'.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 15:20:57 -04:00
|
|
|
pr_debug(MODULE_NAME ": unloaded.\n");
|
2008-05-12 15:20:56 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init);
|
|
|
|
module_exit(cleanup);
|
|
|
|
MODULE_LICENSE("GPL");
|