![Alan Stern](/assets/img/avatar_default.png)
This patch (as755b) fixes a bug in usbmon. Rather than assuming all USB host controllers use DMA, the code will check the usb_bus data structure. If DMA isn't used, we don't want to try peeking into a non-existent DMA buffer! Signed-off-by: Alan Stern <stern@rowland.harvard.edu> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
411 lines
8.7 KiB
C
411 lines
8.7 KiB
C
/*
|
|
* The USB Monitor, inspired by Dave Harding's USBMon.
|
|
*
|
|
* mon_main.c: Main file, module initiation and exit, registrations, etc.
|
|
*
|
|
* Copyright (C) 2005 Pete Zaitcev (zaitcev@redhat.com)
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include "usb_mon.h"
|
|
#include "../core/hcd.h"
|
|
|
|
static void mon_submit(struct usb_bus *ubus, struct urb *urb);
|
|
static void mon_complete(struct usb_bus *ubus, struct urb *urb);
|
|
static void mon_stop(struct mon_bus *mbus);
|
|
static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus);
|
|
static void mon_bus_drop(struct kref *r);
|
|
static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus);
|
|
|
|
DEFINE_MUTEX(mon_lock);
|
|
|
|
static struct dentry *mon_dir; /* /dbg/usbmon */
|
|
static LIST_HEAD(mon_buses); /* All buses we know: struct mon_bus */
|
|
|
|
/*
|
|
* Link a reader into the bus.
|
|
*
|
|
* This must be called with mon_lock taken because of mbus->ref.
|
|
*/
|
|
void mon_reader_add(struct mon_bus *mbus, struct mon_reader *r)
|
|
{
|
|
unsigned long flags;
|
|
struct usb_bus *ubus;
|
|
|
|
spin_lock_irqsave(&mbus->lock, flags);
|
|
if (mbus->nreaders == 0) {
|
|
ubus = mbus->u_bus;
|
|
if (ubus->monitored) {
|
|
/*
|
|
* Something is really broken, refuse to go on and
|
|
* possibly corrupt ops pointers or worse.
|
|
*/
|
|
printk(KERN_ERR TAG ": bus %d is already monitored\n",
|
|
ubus->busnum);
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
return;
|
|
}
|
|
ubus->monitored = 1;
|
|
}
|
|
mbus->nreaders++;
|
|
list_add_tail(&r->r_link, &mbus->r_list);
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
|
|
kref_get(&mbus->ref);
|
|
}
|
|
|
|
/*
|
|
* Unlink reader from the bus.
|
|
*
|
|
* This is called with mon_lock taken, so we can decrement mbus->ref.
|
|
*/
|
|
void mon_reader_del(struct mon_bus *mbus, struct mon_reader *r)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&mbus->lock, flags);
|
|
list_del(&r->r_link);
|
|
--mbus->nreaders;
|
|
if (mbus->nreaders == 0)
|
|
mon_stop(mbus);
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
|
|
kref_put(&mbus->ref, mon_bus_drop);
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static void mon_submit(struct usb_bus *ubus, struct urb *urb)
|
|
{
|
|
struct mon_bus *mbus;
|
|
unsigned long flags;
|
|
struct list_head *pos;
|
|
struct mon_reader *r;
|
|
|
|
mbus = ubus->mon_bus;
|
|
if (mbus == NULL)
|
|
goto out_unlocked;
|
|
|
|
spin_lock_irqsave(&mbus->lock, flags);
|
|
if (mbus->nreaders == 0)
|
|
goto out_locked;
|
|
|
|
mbus->cnt_events++;
|
|
list_for_each (pos, &mbus->r_list) {
|
|
r = list_entry(pos, struct mon_reader, r_link);
|
|
r->rnf_submit(r->r_data, urb);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
return;
|
|
|
|
out_locked:
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
out_unlocked:
|
|
return;
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
|
|
{
|
|
struct mon_bus *mbus;
|
|
unsigned long flags;
|
|
struct list_head *pos;
|
|
struct mon_reader *r;
|
|
|
|
mbus = ubus->mon_bus;
|
|
if (mbus == NULL)
|
|
goto out_unlocked;
|
|
|
|
spin_lock_irqsave(&mbus->lock, flags);
|
|
if (mbus->nreaders == 0)
|
|
goto out_locked;
|
|
|
|
mbus->cnt_events++;
|
|
list_for_each (pos, &mbus->r_list) {
|
|
r = list_entry(pos, struct mon_reader, r_link);
|
|
r->rnf_error(r->r_data, urb, error);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
return;
|
|
|
|
out_locked:
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
out_unlocked:
|
|
return;
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static void mon_complete(struct usb_bus *ubus, struct urb *urb)
|
|
{
|
|
struct mon_bus *mbus;
|
|
unsigned long flags;
|
|
struct list_head *pos;
|
|
struct mon_reader *r;
|
|
|
|
mbus = ubus->mon_bus;
|
|
if (mbus == NULL) {
|
|
/*
|
|
* This should not happen.
|
|
* At this point we do not even know the bus number...
|
|
*/
|
|
printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
|
|
urb->pipe);
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&mbus->lock, flags);
|
|
mbus->cnt_events++;
|
|
list_for_each (pos, &mbus->r_list) {
|
|
r = list_entry(pos, struct mon_reader, r_link);
|
|
r->rnf_complete(r->r_data, urb);
|
|
}
|
|
spin_unlock_irqrestore(&mbus->lock, flags);
|
|
}
|
|
|
|
/* int (*unlink_urb) (struct urb *urb, int status); */
|
|
|
|
/*
|
|
* Stop monitoring.
|
|
*/
|
|
static void mon_stop(struct mon_bus *mbus)
|
|
{
|
|
struct usb_bus *ubus = mbus->u_bus;
|
|
|
|
/*
|
|
* A stop can be called for a dissolved mon_bus in case of
|
|
* a reader staying across an rmmod foo_hcd.
|
|
*/
|
|
if (ubus != NULL) {
|
|
ubus->monitored = 0;
|
|
mb();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add a USB bus (usually by a modprobe foo-hcd)
|
|
*
|
|
* This does not return an error code because the core cannot care less
|
|
* if monitoring is not established.
|
|
*/
|
|
static void mon_bus_add(struct usb_bus *ubus)
|
|
{
|
|
mon_bus_init(mon_dir, ubus);
|
|
}
|
|
|
|
/*
|
|
* Remove a USB bus (either from rmmod foo-hcd or from a hot-remove event).
|
|
*/
|
|
static void mon_bus_remove(struct usb_bus *ubus)
|
|
{
|
|
struct mon_bus *mbus = ubus->mon_bus;
|
|
|
|
mutex_lock(&mon_lock);
|
|
list_del(&mbus->bus_link);
|
|
debugfs_remove(mbus->dent_t);
|
|
debugfs_remove(mbus->dent_s);
|
|
|
|
mon_dissolve(mbus, ubus);
|
|
kref_put(&mbus->ref, mon_bus_drop);
|
|
mutex_unlock(&mon_lock);
|
|
}
|
|
|
|
static int mon_notify(struct notifier_block *self, unsigned long action,
|
|
void *dev)
|
|
{
|
|
switch (action) {
|
|
case USB_BUS_ADD:
|
|
mon_bus_add(dev);
|
|
break;
|
|
case USB_BUS_REMOVE:
|
|
mon_bus_remove(dev);
|
|
}
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block mon_nb = {
|
|
.notifier_call = mon_notify,
|
|
};
|
|
|
|
/*
|
|
* Ops
|
|
*/
|
|
static struct usb_mon_operations mon_ops_0 = {
|
|
.urb_submit = mon_submit,
|
|
.urb_submit_error = mon_submit_error,
|
|
.urb_complete = mon_complete,
|
|
};
|
|
|
|
/*
|
|
* Tear usb_bus and mon_bus apart.
|
|
*/
|
|
static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus)
|
|
{
|
|
|
|
/*
|
|
* Never happens, but...
|
|
*/
|
|
if (ubus->monitored) {
|
|
printk(KERN_ERR TAG ": bus %d is dissolved while monitored\n",
|
|
ubus->busnum);
|
|
ubus->monitored = 0;
|
|
mb();
|
|
}
|
|
|
|
ubus->mon_bus = NULL;
|
|
mbus->u_bus = NULL;
|
|
mb();
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static void mon_bus_drop(struct kref *r)
|
|
{
|
|
struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
|
|
kfree(mbus);
|
|
}
|
|
|
|
/*
|
|
* Initialize a bus for us:
|
|
* - allocate mon_bus
|
|
* - refcount USB bus struct
|
|
* - link
|
|
*/
|
|
static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus)
|
|
{
|
|
struct dentry *d;
|
|
struct mon_bus *mbus;
|
|
enum { NAMESZ = 10 };
|
|
char name[NAMESZ];
|
|
int rc;
|
|
|
|
if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
|
|
goto err_alloc;
|
|
kref_init(&mbus->ref);
|
|
spin_lock_init(&mbus->lock);
|
|
INIT_LIST_HEAD(&mbus->r_list);
|
|
|
|
/*
|
|
* We don't need to take a reference to ubus, because we receive
|
|
* a notification if the bus is about to be removed.
|
|
*/
|
|
mbus->u_bus = ubus;
|
|
ubus->mon_bus = mbus;
|
|
mbus->uses_dma = ubus->uses_dma;
|
|
|
|
rc = snprintf(name, NAMESZ, "%dt", ubus->busnum);
|
|
if (rc <= 0 || rc >= NAMESZ)
|
|
goto err_print_t;
|
|
d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_text);
|
|
if (d == NULL)
|
|
goto err_create_t;
|
|
mbus->dent_t = d;
|
|
|
|
rc = snprintf(name, NAMESZ, "%ds", ubus->busnum);
|
|
if (rc <= 0 || rc >= NAMESZ)
|
|
goto err_print_s;
|
|
d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_stat);
|
|
if (d == NULL)
|
|
goto err_create_s;
|
|
mbus->dent_s = d;
|
|
|
|
mutex_lock(&mon_lock);
|
|
list_add_tail(&mbus->bus_link, &mon_buses);
|
|
mutex_unlock(&mon_lock);
|
|
return;
|
|
|
|
err_create_s:
|
|
err_print_s:
|
|
debugfs_remove(mbus->dent_t);
|
|
err_create_t:
|
|
err_print_t:
|
|
kfree(mbus);
|
|
err_alloc:
|
|
return;
|
|
}
|
|
|
|
static int __init mon_init(void)
|
|
{
|
|
struct usb_bus *ubus;
|
|
struct dentry *mondir;
|
|
|
|
mondir = debugfs_create_dir("usbmon", NULL);
|
|
if (IS_ERR(mondir)) {
|
|
printk(KERN_NOTICE TAG ": debugfs is not available\n");
|
|
return -ENODEV;
|
|
}
|
|
if (mondir == NULL) {
|
|
printk(KERN_NOTICE TAG ": unable to create usbmon directory\n");
|
|
return -ENODEV;
|
|
}
|
|
mon_dir = mondir;
|
|
|
|
if (usb_mon_register(&mon_ops_0) != 0) {
|
|
printk(KERN_NOTICE TAG ": unable to register with the core\n");
|
|
debugfs_remove(mondir);
|
|
return -ENODEV;
|
|
}
|
|
// MOD_INC_USE_COUNT(which_module?);
|
|
|
|
usb_register_notify(&mon_nb);
|
|
|
|
mutex_lock(&usb_bus_list_lock);
|
|
list_for_each_entry (ubus, &usb_bus_list, bus_list) {
|
|
mon_bus_init(mondir, ubus);
|
|
}
|
|
mutex_unlock(&usb_bus_list_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void __exit mon_exit(void)
|
|
{
|
|
struct mon_bus *mbus;
|
|
struct list_head *p;
|
|
|
|
usb_unregister_notify(&mon_nb);
|
|
usb_mon_deregister();
|
|
|
|
mutex_lock(&mon_lock);
|
|
while (!list_empty(&mon_buses)) {
|
|
p = mon_buses.next;
|
|
mbus = list_entry(p, struct mon_bus, bus_link);
|
|
list_del(p);
|
|
|
|
debugfs_remove(mbus->dent_t);
|
|
debugfs_remove(mbus->dent_s);
|
|
|
|
/*
|
|
* This never happens, because the open/close paths in
|
|
* file level maintain module use counters and so rmmod fails
|
|
* before reaching here. However, better be safe...
|
|
*/
|
|
if (mbus->nreaders) {
|
|
printk(KERN_ERR TAG
|
|
": Outstanding opens (%d) on usb%d, leaking...\n",
|
|
mbus->nreaders, mbus->u_bus->busnum);
|
|
atomic_set(&mbus->ref.refcount, 2); /* Force leak */
|
|
}
|
|
|
|
mon_dissolve(mbus, mbus->u_bus);
|
|
kref_put(&mbus->ref, mon_bus_drop);
|
|
}
|
|
mutex_unlock(&mon_lock);
|
|
|
|
debugfs_remove(mon_dir);
|
|
}
|
|
|
|
module_init(mon_init);
|
|
module_exit(mon_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|