2 * The USB Monitor, inspired by Dave Harding's USBMon.
4 * mon_main.c: Main file, module initiation and exit, registrations, etc.
6 * Copyright (C) 2005 Pete Zaitcev (zaitcev@redhat.com)
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/usb.h>
12 #include <linux/slab.h>
13 #include <linux/notifier.h>
14 #include <linux/mutex.h>
17 #include "../core/hcd.h"
19 static void mon_stop(struct mon_bus *mbus);
20 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus);
21 static void mon_bus_drop(struct kref *r);
22 static void mon_bus_init(struct usb_bus *ubus);
24 DEFINE_MUTEX(mon_lock);
26 struct mon_bus mon_bus0; /* Pseudo bus meaning "all buses" */
27 static LIST_HEAD(mon_buses); /* All buses we know: struct mon_bus */
30 * Link a reader into the bus.
32 * This must be called with mon_lock taken because of mbus->ref.
34 void mon_reader_add(struct mon_bus *mbus, struct mon_reader *r)
39 spin_lock_irqsave(&mbus->lock, flags);
40 if (mbus->nreaders == 0) {
41 if (mbus == &mon_bus0) {
42 list_for_each (p, &mon_buses) {
44 m1 = list_entry(p, struct mon_bus, bus_link);
45 m1->u_bus->monitored = 1;
48 mbus->u_bus->monitored = 1;
52 list_add_tail(&r->r_link, &mbus->r_list);
53 spin_unlock_irqrestore(&mbus->lock, flags);
59 * Unlink reader from the bus.
61 * This is called with mon_lock taken, so we can decrement mbus->ref.
63 void mon_reader_del(struct mon_bus *mbus, struct mon_reader *r)
67 spin_lock_irqsave(&mbus->lock, flags);
70 if (mbus->nreaders == 0)
72 spin_unlock_irqrestore(&mbus->lock, flags);
74 kref_put(&mbus->ref, mon_bus_drop);
79 static void mon_bus_submit(struct mon_bus *mbus, struct urb *urb)
82 struct list_head *pos;
85 spin_lock_irqsave(&mbus->lock, flags);
87 list_for_each (pos, &mbus->r_list) {
88 r = list_entry(pos, struct mon_reader, r_link);
89 r->rnf_submit(r->r_data, urb);
91 spin_unlock_irqrestore(&mbus->lock, flags);
95 static void mon_submit(struct usb_bus *ubus, struct urb *urb)
99 if ((mbus = ubus->mon_bus) != NULL)
100 mon_bus_submit(mbus, urb);
101 mon_bus_submit(&mon_bus0, urb);
106 static void mon_bus_submit_error(struct mon_bus *mbus, struct urb *urb, int error)
109 struct list_head *pos;
110 struct mon_reader *r;
112 spin_lock_irqsave(&mbus->lock, flags);
114 list_for_each (pos, &mbus->r_list) {
115 r = list_entry(pos, struct mon_reader, r_link);
116 r->rnf_error(r->r_data, urb, error);
118 spin_unlock_irqrestore(&mbus->lock, flags);
122 static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
124 struct mon_bus *mbus;
126 if ((mbus = ubus->mon_bus) != NULL)
127 mon_bus_submit_error(mbus, urb, error);
128 mon_bus_submit_error(&mon_bus0, urb, error);
133 static void mon_bus_complete(struct mon_bus *mbus, struct urb *urb, int status)
136 struct list_head *pos;
137 struct mon_reader *r;
139 spin_lock_irqsave(&mbus->lock, flags);
141 list_for_each (pos, &mbus->r_list) {
142 r = list_entry(pos, struct mon_reader, r_link);
143 r->rnf_complete(r->r_data, urb, status);
145 spin_unlock_irqrestore(&mbus->lock, flags);
148 static void mon_complete(struct usb_bus *ubus, struct urb *urb, int status)
150 struct mon_bus *mbus;
152 if ((mbus = ubus->mon_bus) != NULL)
153 mon_bus_complete(mbus, urb, status);
154 mon_bus_complete(&mon_bus0, urb, status);
157 /* int (*unlink_urb) (struct urb *urb, int status); */
162 static void mon_stop(struct mon_bus *mbus)
164 struct usb_bus *ubus;
167 if (mbus == &mon_bus0) {
168 list_for_each (p, &mon_buses) {
169 mbus = list_entry(p, struct mon_bus, bus_link);
171 * We do not change nreaders here, so rely on mon_lock.
173 if (mbus->nreaders == 0 && (ubus = mbus->u_bus) != NULL)
178 * A stop can be called for a dissolved mon_bus in case of
179 * a reader staying across an rmmod foo_hcd, so test ->u_bus.
181 if (mon_bus0.nreaders == 0 && (ubus = mbus->u_bus) != NULL) {
189 * Add a USB bus (usually by a modprobe foo-hcd)
191 * This does not return an error code because the core cannot care less
192 * if monitoring is not established.
194 static void mon_bus_add(struct usb_bus *ubus)
197 mutex_lock(&mon_lock);
198 if (mon_bus0.nreaders != 0)
200 mutex_unlock(&mon_lock);
204 * Remove a USB bus (either from rmmod foo-hcd or from a hot-remove event).
206 static void mon_bus_remove(struct usb_bus *ubus)
208 struct mon_bus *mbus = ubus->mon_bus;
210 mutex_lock(&mon_lock);
211 list_del(&mbus->bus_link);
212 if (mbus->text_inited)
214 if (mbus->bin_inited)
217 mon_dissolve(mbus, ubus);
218 kref_put(&mbus->ref, mon_bus_drop);
219 mutex_unlock(&mon_lock);
222 static int mon_notify(struct notifier_block *self, unsigned long action,
235 static struct notifier_block mon_nb = {
236 .notifier_call = mon_notify,
242 static struct usb_mon_operations mon_ops_0 = {
243 .urb_submit = mon_submit,
244 .urb_submit_error = mon_submit_error,
245 .urb_complete = mon_complete,
249 * Tear usb_bus and mon_bus apart.
251 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus)
254 if (ubus->monitored) {
259 ubus->mon_bus = NULL;
263 /* We want synchronize_irq() here, but that needs an argument. */
268 static void mon_bus_drop(struct kref *r)
270 struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
275 * Initialize a bus for us:
277 * - refcount USB bus struct
280 static void mon_bus_init(struct usb_bus *ubus)
282 struct mon_bus *mbus;
284 if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
286 kref_init(&mbus->ref);
287 spin_lock_init(&mbus->lock);
288 INIT_LIST_HEAD(&mbus->r_list);
291 * We don't need to take a reference to ubus, because we receive
292 * a notification if the bus is about to be removed.
295 ubus->mon_bus = mbus;
297 mbus->text_inited = mon_text_add(mbus, ubus);
298 mbus->bin_inited = mon_bin_add(mbus, ubus);
300 mutex_lock(&mon_lock);
301 list_add_tail(&mbus->bus_link, &mon_buses);
302 mutex_unlock(&mon_lock);
309 static void mon_bus0_init(void)
311 struct mon_bus *mbus = &mon_bus0;
313 kref_init(&mbus->ref);
314 spin_lock_init(&mbus->lock);
315 INIT_LIST_HEAD(&mbus->r_list);
317 mbus->text_inited = mon_text_add(mbus, NULL);
318 mbus->bin_inited = mon_bin_add(mbus, NULL);
322 * Search a USB bus by number. Notice that USB bus numbers start from one,
323 * which we may later use to identify "all" with zero.
325 * This function must be called with mon_lock held.
327 * This is obviously inefficient and may be revised in the future.
329 struct mon_bus *mon_bus_lookup(unsigned int num)
332 struct mon_bus *mbus;
337 list_for_each (p, &mon_buses) {
338 mbus = list_entry(p, struct mon_bus, bus_link);
339 if (mbus->u_bus->busnum == num) {
346 static int __init mon_init(void)
348 struct usb_bus *ubus;
351 if ((rc = mon_text_init()) != 0)
353 if ((rc = mon_bin_init()) != 0)
358 if (usb_mon_register(&mon_ops_0) != 0) {
359 printk(KERN_NOTICE TAG ": unable to register with the core\n");
363 // MOD_INC_USE_COUNT(which_module?);
365 mutex_lock(&usb_bus_list_lock);
366 list_for_each_entry (ubus, &usb_bus_list, bus_list) {
369 usb_register_notify(&mon_nb);
370 mutex_unlock(&usb_bus_list_lock);
381 static void __exit mon_exit(void)
383 struct mon_bus *mbus;
386 usb_unregister_notify(&mon_nb);
387 usb_mon_deregister();
389 mutex_lock(&mon_lock);
391 while (!list_empty(&mon_buses)) {
393 mbus = list_entry(p, struct mon_bus, bus_link);
396 if (mbus->text_inited)
398 if (mbus->bin_inited)
402 * This never happens, because the open/close paths in
403 * file level maintain module use counters and so rmmod fails
404 * before reaching here. However, better be safe...
406 if (mbus->nreaders) {
408 ": Outstanding opens (%d) on usb%d, leaking...\n",
409 mbus->nreaders, mbus->u_bus->busnum);
410 atomic_set(&mbus->ref.refcount, 2); /* Force leak */
413 mon_dissolve(mbus, mbus->u_bus);
414 kref_put(&mbus->ref, mon_bus_drop);
418 if (mbus->text_inited)
420 if (mbus->bin_inited)
423 mutex_unlock(&mon_lock);
429 module_init(mon_init);
430 module_exit(mon_exit);
432 MODULE_LICENSE("GPL");