[mirror_ubuntu-bionic-kernel.git] / drivers / usb / mon / mon_main.c

// SPDX-License-Identifier: GPL-2.0
/*
 * 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/usb/hcd.h>
#include <linux/slab.h>
#include <linux/notifier.h>
#include <linux/mutex.h>

#include "usb_mon.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);
}

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

	mbus = ubus->mon_bus;
	if (mbus != 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);
}

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

	mbus = ubus->mon_bus;
	if (mbus != 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, int status)
{
	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, status);
	}
	spin_unlock_irqrestore(&mbus->lock, flags);
}

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

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

/* int (*unlink_urb) (struct urb *urb, int status); */

/*
 * Stop monitoring.
 */
static void mon_stop(struct mon_bus *mbus)
{
	struct usb_bus *ubus;
	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 const 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;

	mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL);
	if (mbus == 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, id;

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

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