[linux.git] / drivers / usb / mon / mon_main.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 ([email protected])
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/notifier.h>
#include <linux/mutex.h>

#include "usb_mon.h"
#include "../core/hcd.h"

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 usb_bus *ubus);

DEFINE_MUTEX(mon_lock);

struct mon_bus mon_bus0;		/* Pseudo bus meaning "all buses" */
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 list_head *p;

	spin_lock_irqsave(&mbus->lock, flags);
	if (mbus->nreaders == 0) {
		if (mbus == &mon_bus0) {
			list_for_each (p, &mon_buses) {
				struct mon_bus *m1;
				m1 = list_entry(p, struct mon_bus, bus_link);
				m1->u_bus->monitored = 1;
			}
		} else {
			mbus->u_bus->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_bus_submit(struct mon_bus *mbus, struct urb *urb)
{
	unsigned long flags;
	struct list_head *pos;
	struct mon_reader *r;

	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_submit(r->r_data, urb);
	}
	spin_unlock_irqrestore(&mbus->lock, flags);
	return;
}

static void mon_submit(struct usb_bus *ubus, struct urb *urb)
{
	struct mon_bus *mbus;

	if ((mbus = ubus->mon_bus) != NULL)
		mon_bus_submit(mbus, urb);
	mon_bus_submit(&mon_bus0, urb);
}

/*
 */
static void mon_bus_submit_error(struct mon_bus *mbus, struct urb *urb, int error)
{
	unsigned long flags;
	struct list_head *pos;
	struct mon_reader *r;

	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_error(r->r_data, urb, error);
	}
	spin_unlock_irqrestore(&mbus->lock, flags);
	return;
}

static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
{
	struct mon_bus *mbus;

	if ((mbus = ubus->mon_bus) != NULL)
		mon_bus_submit_error(mbus, urb, error);
	mon_bus_submit_error(&mon_bus0, urb, error);
}

/*
 */
static void mon_bus_complete(struct mon_bus *mbus, struct urb *urb)
{
	unsigned long flags;
	struct list_head *pos;
	struct mon_reader *r;

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

static void mon_complete(struct usb_bus *ubus, struct urb *urb)
{
	struct mon_bus *mbus;

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

	mon_bus_complete(mbus, urb);
	mon_bus_complete(&mon_bus0, urb);
}

/* 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;
	struct list_head *p;

	if (mbus == &mon_bus0) {
		list_for_each (p, &mon_buses) {
			mbus = list_entry(p, struct mon_bus, bus_link);
			/*
			 * We do not change nreaders here, so rely on mon_lock.
			 */
			if (mbus->nreaders == 0 && (ubus = mbus->u_bus) != NULL)
				ubus->monitored = 0;
		}
	} else {
		/*
		 * A stop can be called for a dissolved mon_bus in case of
		 * a reader staying across an rmmod foo_hcd, so test ->u_bus.
		 */
		if (mon_bus0.nreaders == 0 && (ubus = mbus->u_bus) != 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(ubus);
	mutex_lock(&mon_lock);
	if (mon_bus0.nreaders != 0)
		ubus->monitored = 1;
	mutex_unlock(&mon_lock);
}

/*
 * 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);
	if (mbus->text_inited)
		mon_text_del(mbus);
	if (mbus->bin_inited)
		mon_bin_del(mbus);

	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)
{

	if (ubus->monitored) {
		ubus->monitored = 0;
		mb();
	}

	ubus->mon_bus = NULL;
	mbus->u_bus = NULL;
	mb();

	/* We want synchronize_irq() here, but that needs an argument. */
}

/*
 */
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 usb_bus *ubus)
{
	struct mon_bus *mbus;

	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->text_inited = mon_text_add(mbus, ubus);
	mbus->bin_inited = mon_bin_add(mbus, ubus);

	mutex_lock(&mon_lock);
	list_add_tail(&mbus->bus_link, &mon_buses);
	mutex_unlock(&mon_lock);
	return;

err_alloc:
	return;
}

static void mon_bus0_init(void)
{
	struct mon_bus *mbus = &mon_bus0;

	kref_init(&mbus->ref);
	spin_lock_init(&mbus->lock);
	INIT_LIST_HEAD(&mbus->r_list);

	mbus->text_inited = mon_text_add(mbus, NULL);
	mbus->bin_inited = mon_bin_add(mbus, NULL);
}

/*
 * Search a USB bus by number. Notice that USB bus numbers start from one,
 * which we may later use to identify "all" with zero.
 *
 * This function must be called with mon_lock held.
 *
 * This is obviously inefficient and may be revised in the future.
 */
struct mon_bus *mon_bus_lookup(unsigned int num)
{
	struct list_head *p;
	struct mon_bus *mbus;

	if (num == 0) {
		return &mon_bus0;
	}
	list_for_each (p, &mon_buses) {
		mbus = list_entry(p, struct mon_bus, bus_link);
		if (mbus->u_bus->busnum == num) {
			return mbus;
		}
	}
	return NULL;
}

static int __init mon_init(void)
{
	struct usb_bus *ubus;
	int rc;

	if ((rc = mon_text_init()) != 0)
		goto err_text;
	if ((rc = mon_bin_init()) != 0)
		goto err_bin;

	mon_bus0_init();

	if (usb_mon_register(&mon_ops_0) != 0) {
		printk(KERN_NOTICE TAG ": unable to register with the core\n");
		rc = -ENODEV;
		goto err_reg;
	}
	// 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(ubus);
	}
	mutex_unlock(&usb_bus_list_lock);
	return 0;

err_reg:
	mon_bin_exit();
err_bin:
	mon_text_exit();
err_text:
	return rc;
}

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

		if (mbus->text_inited)
			mon_text_del(mbus);
		if (mbus->bin_inited)
			mon_bin_del(mbus);

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

	mbus = &mon_bus0;
	if (mbus->text_inited)
		mon_text_del(mbus);
	if (mbus->bin_inited)
		mon_bin_del(mbus);

	mutex_unlock(&mon_lock);

	mon_text_exit();
	mon_bin_exit();
}

module_init(mon_init);
module_exit(mon_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* The USB Monitor, inspired by Dave Harding's USBMon.
	3	*
	4	* mon_main.c: Main file, module initiation and exit, registrations, etc.
da5ca008 PZ	5	*
da5ca008 PZ	6	* Copyright (C) 2005 Pete Zaitcev ([email protected])
1da177e4 LT	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/usb.h>
72adaa96	12	#include <linux/notifier.h>
4186ecf8	13	#include <linux/mutex.h>
1da177e4 LT	14
	15	#include "usb_mon.h"
	16	#include "../core/hcd.h"
	17
1da177e4 LT	18	static void mon_stop(struct mon_bus *mbus);
	19	static void mon_dissolve(struct mon_bus mbus, struct usb_bus ubus);
	20	static void mon_bus_drop(struct kref *r);
6f23ee1f	21	static void mon_bus_init(struct usb_bus *ubus);
1da177e4	22
4186ecf8	23	DEFINE_MUTEX(mon_lock);
1da177e4	24
ecb658d3	25	struct mon_bus mon_bus0; /* Pseudo bus meaning "all buses" */
1da177e4 LT	26	static LIST_HEAD(mon_buses); /* All buses we know: struct mon_bus */
	27
	28	/*
	29	* Link a reader into the bus.
	30	*
	31	* This must be called with mon_lock taken because of mbus->ref.
	32	*/
	33	void mon_reader_add(struct mon_bus mbus, struct mon_reader r)
	34	{
	35	unsigned long flags;
ecb658d3	36	struct list_head *p;
1da177e4 LT	37
	38	spin_lock_irqsave(&mbus->lock, flags);
	39	if (mbus->nreaders == 0) {
ecb658d3 PZ	40	if (mbus == &mon_bus0) {
	41	list_for_each (p, &mon_buses) {
	42	struct mon_bus *m1;
	43	m1 = list_entry(p, struct mon_bus, bus_link);
	44	m1->u_bus->monitored = 1;
	45	}
	46	} else {
	47	mbus->u_bus->monitored = 1;
1da177e4	48	}
1da177e4 LT	49	}
	50	mbus->nreaders++;
	51	list_add_tail(&r->r_link, &mbus->r_list);
	52	spin_unlock_irqrestore(&mbus->lock, flags);
	53
	54	kref_get(&mbus->ref);
	55	}
	56
	57	/*
	58	* Unlink reader from the bus.
	59	*
	60	* This is called with mon_lock taken, so we can decrement mbus->ref.
	61	*/
	62	void mon_reader_del(struct mon_bus mbus, struct mon_reader r)
	63	{
	64	unsigned long flags;
	65
	66	spin_lock_irqsave(&mbus->lock, flags);
	67	list_del(&r->r_link);
	68	--mbus->nreaders;
	69	if (mbus->nreaders == 0)
	70	mon_stop(mbus);
	71	spin_unlock_irqrestore(&mbus->lock, flags);
	72
	73	kref_put(&mbus->ref, mon_bus_drop);
	74	}
	75
	76	/*
	77	*/
ecb658d3	78	static void mon_bus_submit(struct mon_bus mbus, struct urb urb)
1da177e4	79	{
1da177e4 LT	80	unsigned long flags;
	81	struct list_head *pos;
	82	struct mon_reader *r;
	83
1da177e4	84	spin_lock_irqsave(&mbus->lock, flags);
5b1c674d	85	mbus->cnt_events++;
1da177e4 LT	86	list_for_each (pos, &mbus->r_list) {
	87	r = list_entry(pos, struct mon_reader, r_link);
	88	r->rnf_submit(r->r_data, urb);
	89	}
1da177e4 LT	90	spin_unlock_irqrestore(&mbus->lock, flags);
1da177e4 LT	91	return;
ecb658d3	92	}
1da177e4	93
ecb658d3 PZ	94	static void mon_submit(struct usb_bus ubus, struct urb urb)
	95	{
	96	struct mon_bus *mbus;
	97
	98	if ((mbus = ubus->mon_bus) != NULL)
	99	mon_bus_submit(mbus, urb);
	100	mon_bus_submit(&mon_bus0, urb);
1da177e4 LT	101	}
	102
	103	/*
	104	*/
ecb658d3	105	static void mon_bus_submit_error(struct mon_bus mbus, struct urb urb, int error)
1da177e4	106	{
12e72fea PZ	107	unsigned long flags;
	108	struct list_head *pos;
	109	struct mon_reader *r;
1da177e4	110
12e72fea	111	spin_lock_irqsave(&mbus->lock, flags);
12e72fea PZ	112	mbus->cnt_events++;
	113	list_for_each (pos, &mbus->r_list) {
	114	r = list_entry(pos, struct mon_reader, r_link);
	115	r->rnf_error(r->r_data, urb, error);
	116	}
12e72fea	117	spin_unlock_irqrestore(&mbus->lock, flags);
1da177e4	118	return;
ecb658d3	119	}
1da177e4	120
ecb658d3 PZ	121	static void mon_submit_error(struct usb_bus ubus, struct urb urb, int error)
	122	{
	123	struct mon_bus *mbus;
	124
	125	if ((mbus = ubus->mon_bus) != NULL)
	126	mon_bus_submit_error(mbus, urb, error);
	127	mon_bus_submit_error(&mon_bus0, urb, error);
1da177e4 LT	128	}
	129
	130	/*
	131	*/
ecb658d3	132	static void mon_bus_complete(struct mon_bus mbus, struct urb urb)
1da177e4	133	{
1da177e4 LT	134	unsigned long flags;
	135	struct list_head *pos;
	136	struct mon_reader *r;
	137
ecb658d3 PZ	138	spin_lock_irqsave(&mbus->lock, flags);
	139	mbus->cnt_events++;
	140	list_for_each (pos, &mbus->r_list) {
	141	r = list_entry(pos, struct mon_reader, r_link);
	142	r->rnf_complete(r->r_data, urb);
	143	}
	144	spin_unlock_irqrestore(&mbus->lock, flags);
	145	}
	146
	147	static void mon_complete(struct usb_bus ubus, struct urb urb)
	148	{
	149	struct mon_bus *mbus;
	150
1da177e4 LT	151	mbus = ubus->mon_bus;
	152	if (mbus == NULL) {
	153	/*
	154	* This should not happen.
	155	* At this point we do not even know the bus number...
	156	*/
	157	printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
	158	urb->pipe);
	159	return;
	160	}
	161
ecb658d3 PZ	162	mon_bus_complete(mbus, urb);
ecb658d3 PZ	163	mon_bus_complete(&mon_bus0, urb);
1da177e4 LT	164	}
	165
	166	/* int (unlink_urb) (struct urb urb, int status); */
	167
	168	/*
	169	* Stop monitoring.
1da177e4 LT	170	*/
	171	static void mon_stop(struct mon_bus *mbus)
	172	{
	173	struct usb_bus *ubus = mbus->u_bus;
ecb658d3	174	struct list_head *p;
1da177e4	175
ecb658d3 PZ	176	if (mbus == &mon_bus0) {
	177	list_for_each (p, &mon_buses) {
	178	mbus = list_entry(p, struct mon_bus, bus_link);
	179	/*
	180	* We do not change nreaders here, so rely on mon_lock.
	181	*/
	182	if (mbus->nreaders == 0 && (ubus = mbus->u_bus) != NULL)
	183	ubus->monitored = 0;
	184	}
	185	} else {
	186	/*
	187	* A stop can be called for a dissolved mon_bus in case of
	188	* a reader staying across an rmmod foo_hcd, so test ->u_bus.
	189	*/
	190	if (mon_bus0.nreaders == 0 && (ubus = mbus->u_bus) != NULL) {
	191	ubus->monitored = 0;
	192	mb();
	193	}
1da177e4 LT	194	}
	195	}
	196
	197	/*
	198	* Add a USB bus (usually by a modprobe foo-hcd)
	199	*
	200	* This does not return an error code because the core cannot care less
	201	* if monitoring is not established.
	202	*/
	203	static void mon_bus_add(struct usb_bus *ubus)
	204	{
6f23ee1f	205	mon_bus_init(ubus);
ecb658d3 PZ	206	mutex_lock(&mon_lock);
	207	if (mon_bus0.nreaders != 0)
	208	ubus->monitored = 1;
	209	mutex_unlock(&mon_lock);
1da177e4 LT	210	}
	211
	212	/*
	213	* Remove a USB bus (either from rmmod foo-hcd or from a hot-remove event).
	214	*/
	215	static void mon_bus_remove(struct usb_bus *ubus)
	216	{
	217	struct mon_bus *mbus = ubus->mon_bus;
	218
4186ecf8	219	mutex_lock(&mon_lock);
1da177e4	220	list_del(&mbus->bus_link);
6f23ee1f PZ	221	if (mbus->text_inited)
6f23ee1f PZ	222	mon_text_del(mbus);
ce7cd137 PZ	223	if (mbus->bin_inited)
ce7cd137 PZ	224	mon_bin_del(mbus);
1da177e4 LT	225
	226	mon_dissolve(mbus, ubus);
	227	kref_put(&mbus->ref, mon_bus_drop);
4186ecf8	228	mutex_unlock(&mon_lock);
1da177e4 LT	229	}
1da177e4 LT	230
72adaa96 GKH	231	static int mon_notify(struct notifier_block *self, unsigned long action,
	232	void *dev)
	233	{
	234	switch (action) {
	235	case USB_BUS_ADD:
	236	mon_bus_add(dev);
	237	break;
	238	case USB_BUS_REMOVE:
	239	mon_bus_remove(dev);
	240	}
	241	return NOTIFY_OK;
	242	}
	243
	244	static struct notifier_block mon_nb = {
	245	.notifier_call = mon_notify,
	246	};
	247
1da177e4 LT	248	/*
	249	* Ops
	250	*/
	251	static struct usb_mon_operations mon_ops_0 = {
	252	.urb_submit = mon_submit,
	253	.urb_submit_error = mon_submit_error,
	254	.urb_complete = mon_complete,
1da177e4 LT	255	};
	256
	257	/*
	258	* Tear usb_bus and mon_bus apart.
	259	*/
	260	static void mon_dissolve(struct mon_bus mbus, struct usb_bus ubus)
	261	{
	262
1da177e4	263	if (ubus->monitored) {
1da177e4 LT	264	ubus->monitored = 0;
	265	mb();
	266	}
	267
	268	ubus->mon_bus = NULL;
	269	mbus->u_bus = NULL;
	270	mb();
ecb658d3 PZ	271
ecb658d3 PZ	272	/* We want synchronize_irq() here, but that needs an argument. */
1da177e4 LT	273	}
	274
	275	/*
	276	*/
	277	static void mon_bus_drop(struct kref *r)
	278	{
	279	struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
	280	kfree(mbus);
	281	}
	282
	283	/*
	284	* Initialize a bus for us:
	285	* - allocate mon_bus
	286	* - refcount USB bus struct
	287	* - link
	288	*/
6f23ee1f	289	static void mon_bus_init(struct usb_bus *ubus)
1da177e4	290	{
1da177e4	291	struct mon_bus *mbus;
1da177e4	292
80b6ca48	293	if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
1da177e4	294	goto err_alloc;
1da177e4 LT	295	kref_init(&mbus->ref);
	296	spin_lock_init(&mbus->lock);
	297	INIT_LIST_HEAD(&mbus->r_list);
	298
	299	/*
17200583 AS	300	* We don't need to take a reference to ubus, because we receive
17200583 AS	301	* a notification if the bus is about to be removed.
1da177e4	302	*/
1da177e4 LT	303	mbus->u_bus = ubus;
	304	ubus->mon_bus = mbus;
	305
ce7cd137 PZ	306	mbus->text_inited = mon_text_add(mbus, ubus);
ce7cd137 PZ	307	mbus->bin_inited = mon_bin_add(mbus, ubus);
1da177e4	308
4186ecf8	309	mutex_lock(&mon_lock);
1da177e4	310	list_add_tail(&mbus->bus_link, &mon_buses);
4186ecf8	311	mutex_unlock(&mon_lock);
1da177e4 LT	312	return;
1da177e4 LT	313
1da177e4 LT	314	err_alloc:
	315	return;
	316	}
	317
ecb658d3 PZ	318	static void mon_bus0_init(void)
	319	{
	320	struct mon_bus *mbus = &mon_bus0;
	321
	322	kref_init(&mbus->ref);
	323	spin_lock_init(&mbus->lock);
	324	INIT_LIST_HEAD(&mbus->r_list);
	325
ce7cd137 PZ	326	mbus->text_inited = mon_text_add(mbus, NULL);
ce7cd137 PZ	327	mbus->bin_inited = mon_bin_add(mbus, NULL);
ecb658d3 PZ	328	}
ecb658d3 PZ	329
6f23ee1f PZ	330	/*
	331	* Search a USB bus by number. Notice that USB bus numbers start from one,
	332	* which we may later use to identify "all" with zero.
	333	*
	334	* This function must be called with mon_lock held.
	335	*
	336	* This is obviously inefficient and may be revised in the future.
	337	*/
	338	struct mon_bus *mon_bus_lookup(unsigned int num)
	339	{
	340	struct list_head *p;
	341	struct mon_bus *mbus;
	342
ecb658d3 PZ	343	if (num == 0) {
	344	return &mon_bus0;
	345	}
6f23ee1f PZ	346	list_for_each (p, &mon_buses) {
	347	mbus = list_entry(p, struct mon_bus, bus_link);
	348	if (mbus->u_bus->busnum == num) {
	349	return mbus;
	350	}
	351	}
	352	return NULL;
	353	}
	354
1da177e4 LT	355	static int __init mon_init(void)
	356	{
	357	struct usb_bus *ubus;
6f23ee1f	358	int rc;
1da177e4	359
6f23ee1f PZ	360	if ((rc = mon_text_init()) != 0)
	361	goto err_text;
	362	if ((rc = mon_bin_init()) != 0)
	363	goto err_bin;
1da177e4	364
ecb658d3 PZ	365	mon_bus0_init();
ecb658d3 PZ	366
1da177e4 LT	367	if (usb_mon_register(&mon_ops_0) != 0) {
1da177e4 LT	368	printk(KERN_NOTICE TAG ": unable to register with the core\n");
6f23ee1f PZ	369	rc = -ENODEV;
6f23ee1f PZ	370	goto err_reg;
1da177e4 LT	371	}
	372	// MOD_INC_USE_COUNT(which_module?);
	373
72adaa96 GKH	374	usb_register_notify(&mon_nb);
72adaa96 GKH	375
4186ecf8	376	mutex_lock(&usb_bus_list_lock);
1da177e4	377	list_for_each_entry (ubus, &usb_bus_list, bus_list) {
6f23ee1f	378	mon_bus_init(ubus);
1da177e4	379	}
4186ecf8	380	mutex_unlock(&usb_bus_list_lock);
1da177e4	381	return 0;
6f23ee1f PZ	382
	383	err_reg:
	384	mon_bin_exit();
	385	err_bin:
	386	mon_text_exit();
	387	err_text:
	388	return rc;
1da177e4 LT	389	}
	390
	391	static void __exit mon_exit(void)
	392	{
	393	struct mon_bus *mbus;
	394	struct list_head *p;
	395
72adaa96	396	usb_unregister_notify(&mon_nb);
1da177e4 LT	397	usb_mon_deregister();
1da177e4 LT	398
4186ecf8	399	mutex_lock(&mon_lock);
ecb658d3	400
1da177e4 LT	401	while (!list_empty(&mon_buses)) {
	402	p = mon_buses.next;
	403	mbus = list_entry(p, struct mon_bus, bus_link);
	404	list_del(p);
	405
6f23ee1f PZ	406	if (mbus->text_inited)
6f23ee1f PZ	407	mon_text_del(mbus);
ce7cd137 PZ	408	if (mbus->bin_inited)
ce7cd137 PZ	409	mon_bin_del(mbus);
1da177e4 LT	410
	411	/*
	412	* This never happens, because the open/close paths in
	413	* file level maintain module use counters and so rmmod fails
	414	* before reaching here. However, better be safe...
	415	*/
	416	if (mbus->nreaders) {
	417	printk(KERN_ERR TAG
	418	": Outstanding opens (%d) on usb%d, leaking...\n",
	419	mbus->nreaders, mbus->u_bus->busnum);
	420	atomic_set(&mbus->ref.refcount, 2); /* Force leak */
	421	}
	422
	423	mon_dissolve(mbus, mbus->u_bus);
	424	kref_put(&mbus->ref, mon_bus_drop);
	425	}
ecb658d3 PZ	426
	427	mbus = &mon_bus0;
	428	if (mbus->text_inited)
	429	mon_text_del(mbus);
ce7cd137 PZ	430	if (mbus->bin_inited)
ce7cd137 PZ	431	mon_bin_del(mbus);
ecb658d3	432
4186ecf8	433	mutex_unlock(&mon_lock);
1da177e4	434
6f23ee1f PZ	435	mon_text_exit();
6f23ee1f PZ	436	mon_bin_exit();
1da177e4 LT	437	}
	438
	439	module_init(mon_init);
	440	module_exit(mon_exit);
	441
	442	MODULE_LICENSE("GPL");