xref: /linux/drivers/usb/mon/mon_main.c (revision b4d8d1a93c6ea042b29bb66fbb1cf6bc556c18f7) 
1 /*
2  * The USB Monitor, inspired by Dave Harding's USBMon.
3  *
4  * mon_main.c: Main file, module initiation and exit, registrations, etc.
5  *
6  * Copyright (C) 2005 Pete Zaitcev (zaitcev@redhat.com)
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/usb.h>
12 #include <linux/debugfs.h>
13 #include <linux/smp_lock.h>
14 #include <linux/notifier.h>
15 #include <linux/mutex.h>
16 
17 #include "usb_mon.h"
18 #include "../core/hcd.h"
19 
20 static void mon_submit(struct usb_bus *ubus, struct urb *urb);
21 static void mon_complete(struct usb_bus *ubus, struct urb *urb);
22 static void mon_stop(struct mon_bus *mbus);
23 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus);
24 static void mon_bus_drop(struct kref *r);
25 static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus);
26 
27 DEFINE_MUTEX(mon_lock);
28 
29 static struct dentry *mon_dir;		/* /dbg/usbmon */
30 static LIST_HEAD(mon_buses);		/* All buses we know: struct mon_bus */
31 
32 /*
33  * Link a reader into the bus.
34  *
35  * This must be called with mon_lock taken because of mbus->ref.
36  */
37 void mon_reader_add(struct mon_bus *mbus, struct mon_reader *r)
38 {
39 	unsigned long flags;
40 	struct usb_bus *ubus;
41 
42 	spin_lock_irqsave(&mbus->lock, flags);
43 	if (mbus->nreaders == 0) {
44 		ubus = mbus->u_bus;
45 		if (ubus->monitored) {
46 			/*
47 			 * Something is really broken, refuse to go on and
48 			 * possibly corrupt ops pointers or worse.
49 			 */
50 			printk(KERN_ERR TAG ": bus %d is already monitored\n",
51 			    ubus->busnum);
52 			spin_unlock_irqrestore(&mbus->lock, flags);
53 			return;
54 		}
55 		ubus->monitored = 1;
56 	}
57 	mbus->nreaders++;
58 	list_add_tail(&r->r_link, &mbus->r_list);
59 	spin_unlock_irqrestore(&mbus->lock, flags);
60 
61 	kref_get(&mbus->ref);
62 }
63 
64 /*
65  * Unlink reader from the bus.
66  *
67  * This is called with mon_lock taken, so we can decrement mbus->ref.
68  */
69 void mon_reader_del(struct mon_bus *mbus, struct mon_reader *r)
70 {
71 	unsigned long flags;
72 
73 	spin_lock_irqsave(&mbus->lock, flags);
74 	list_del(&r->r_link);
75 	--mbus->nreaders;
76 	if (mbus->nreaders == 0)
77 		mon_stop(mbus);
78 	spin_unlock_irqrestore(&mbus->lock, flags);
79 
80 	kref_put(&mbus->ref, mon_bus_drop);
81 }
82 
83 /*
84  */
85 static void mon_submit(struct usb_bus *ubus, struct urb *urb)
86 {
87 	struct mon_bus *mbus;
88 	unsigned long flags;
89 	struct list_head *pos;
90 	struct mon_reader *r;
91 
92 	mbus = ubus->mon_bus;
93 	if (mbus == NULL)
94 		goto out_unlocked;
95 
96 	spin_lock_irqsave(&mbus->lock, flags);
97 	if (mbus->nreaders == 0)
98 		goto out_locked;
99 
100 	list_for_each (pos, &mbus->r_list) {
101 		r = list_entry(pos, struct mon_reader, r_link);
102 		r->rnf_submit(r->r_data, urb);
103 	}
104 
105 	spin_unlock_irqrestore(&mbus->lock, flags);
106 	return;
107 
108 out_locked:
109 	spin_unlock_irqrestore(&mbus->lock, flags);
110 out_unlocked:
111 	return;
112 }
113 
114 /*
115  */
116 static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int err)
117 {
118 	struct mon_bus *mbus;
119 
120 	mbus = ubus->mon_bus;
121 	if (mbus == NULL)
122 		goto out_unlocked;
123 
124 	/*
125 	 * XXX Capture the error code and the 'E' event.
126 	 */
127 
128 	return;
129 
130 out_unlocked:
131 	return;
132 }
133 
134 /*
135  */
136 static void mon_complete(struct usb_bus *ubus, struct urb *urb)
137 {
138 	struct mon_bus *mbus;
139 	unsigned long flags;
140 	struct list_head *pos;
141 	struct mon_reader *r;
142 
143 	mbus = ubus->mon_bus;
144 	if (mbus == NULL) {
145 		/*
146 		 * This should not happen.
147 		 * At this point we do not even know the bus number...
148 		 */
149 		printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
150 		    urb->pipe);
151 		return;
152 	}
153 
154 	spin_lock_irqsave(&mbus->lock, flags);
155 	list_for_each (pos, &mbus->r_list) {
156 		r = list_entry(pos, struct mon_reader, r_link);
157 		r->rnf_complete(r->r_data, urb);
158 	}
159 	spin_unlock_irqrestore(&mbus->lock, flags);
160 }
161 
162 /* int (*unlink_urb) (struct urb *urb, int status); */
163 
164 /*
165  * Stop monitoring.
166  * Obviously this must be well locked, so no need to play with mb's.
167  */
168 static void mon_stop(struct mon_bus *mbus)
169 {
170 	struct usb_bus *ubus = mbus->u_bus;
171 
172 	/*
173 	 * A stop can be called for a dissolved mon_bus in case of
174 	 * a reader staying across an rmmod foo_hcd.
175 	 */
176 	if (ubus != NULL) {
177 		ubus->monitored = 0;
178 		mb();
179 	}
180 }
181 
182 /*
183  * Add a USB bus (usually by a modprobe foo-hcd)
184  *
185  * This does not return an error code because the core cannot care less
186  * if monitoring is not established.
187  */
188 static void mon_bus_add(struct usb_bus *ubus)
189 {
190 	mon_bus_init(mon_dir, ubus);
191 }
192 
193 /*
194  * Remove a USB bus (either from rmmod foo-hcd or from a hot-remove event).
195  */
196 static void mon_bus_remove(struct usb_bus *ubus)
197 {
198 	struct mon_bus *mbus = ubus->mon_bus;
199 
200 	mutex_lock(&mon_lock);
201 	list_del(&mbus->bus_link);
202 	debugfs_remove(mbus->dent_t);
203 	debugfs_remove(mbus->dent_s);
204 
205 	mon_dissolve(mbus, ubus);
206 	kref_put(&mbus->ref, mon_bus_drop);
207 	mutex_unlock(&mon_lock);
208 }
209 
210 static int mon_notify(struct notifier_block *self, unsigned long action,
211 		      void *dev)
212 {
213 	switch (action) {
214 	case USB_BUS_ADD:
215 		mon_bus_add(dev);
216 		break;
217 	case USB_BUS_REMOVE:
218 		mon_bus_remove(dev);
219 	}
220 	return NOTIFY_OK;
221 }
222 
223 static struct notifier_block mon_nb = {
224 	.notifier_call = 	mon_notify,
225 };
226 
227 /*
228  * Ops
229  */
230 static struct usb_mon_operations mon_ops_0 = {
231 	.urb_submit =	mon_submit,
232 	.urb_submit_error = mon_submit_error,
233 	.urb_complete =	mon_complete,
234 };
235 
236 /*
237  * Tear usb_bus and mon_bus apart.
238  */
239 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus)
240 {
241 
242 	/*
243 	 * Never happens, but...
244 	 */
245 	if (ubus->monitored) {
246 		printk(KERN_ERR TAG ": bus %d is dissolved while monitored\n",
247 		    ubus->busnum);
248 		ubus->monitored = 0;
249 		mb();
250 	}
251 
252 	ubus->mon_bus = NULL;
253 	mbus->u_bus = NULL;
254 	mb();
255 	// usb_bus_put(ubus);
256 }
257 
258 /*
259  */
260 static void mon_bus_drop(struct kref *r)
261 {
262 	struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
263 	kfree(mbus);
264 }
265 
266 /*
267  * Initialize a bus for us:
268  *  - allocate mon_bus
269  *  - refcount USB bus struct
270  *  - link
271  */
272 static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus)
273 {
274 	struct dentry *d;
275 	struct mon_bus *mbus;
276 	enum { NAMESZ = 10 };
277 	char name[NAMESZ];
278 	int rc;
279 
280 	if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
281 		goto err_alloc;
282 	kref_init(&mbus->ref);
283 	spin_lock_init(&mbus->lock);
284 	INIT_LIST_HEAD(&mbus->r_list);
285 
286 	/*
287 	 * This usb_bus_get here is superfluous, because we receive
288 	 * a notification if usb_bus is about to be removed.
289 	 */
290 	// usb_bus_get(ubus);
291 	mbus->u_bus = ubus;
292 	ubus->mon_bus = mbus;
293 
294 	rc = snprintf(name, NAMESZ, "%dt", ubus->busnum);
295 	if (rc <= 0 || rc >= NAMESZ)
296 		goto err_print_t;
297 	d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_text);
298 	if (d == NULL)
299 		goto err_create_t;
300 	mbus->dent_t = d;
301 
302 	rc = snprintf(name, NAMESZ, "%ds", ubus->busnum);
303 	if (rc <= 0 || rc >= NAMESZ)
304 		goto err_print_s;
305 	d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_stat);
306 	if (d == NULL)
307 		goto err_create_s;
308 	mbus->dent_s = d;
309 
310 	mutex_lock(&mon_lock);
311 	list_add_tail(&mbus->bus_link, &mon_buses);
312 	mutex_unlock(&mon_lock);
313 	return;
314 
315 err_create_s:
316 err_print_s:
317 	debugfs_remove(mbus->dent_t);
318 err_create_t:
319 err_print_t:
320 	kfree(mbus);
321 err_alloc:
322 	return;
323 }
324 
325 static int __init mon_init(void)
326 {
327 	struct usb_bus *ubus;
328 	struct dentry *mondir;
329 
330 	mondir = debugfs_create_dir("usbmon", NULL);
331 	if (IS_ERR(mondir)) {
332 		printk(KERN_NOTICE TAG ": debugfs is not available\n");
333 		return -ENODEV;
334 	}
335 	if (mondir == NULL) {
336 		printk(KERN_NOTICE TAG ": unable to create usbmon directory\n");
337 		return -ENODEV;
338 	}
339 	mon_dir = mondir;
340 
341 	if (usb_mon_register(&mon_ops_0) != 0) {
342 		printk(KERN_NOTICE TAG ": unable to register with the core\n");
343 		debugfs_remove(mondir);
344 		return -ENODEV;
345 	}
346 	// MOD_INC_USE_COUNT(which_module?);
347 
348 	usb_register_notify(&mon_nb);
349 
350 	mutex_lock(&usb_bus_list_lock);
351 	list_for_each_entry (ubus, &usb_bus_list, bus_list) {
352 		mon_bus_init(mondir, ubus);
353 	}
354 	mutex_unlock(&usb_bus_list_lock);
355 	return 0;
356 }
357 
358 static void __exit mon_exit(void)
359 {
360 	struct mon_bus *mbus;
361 	struct list_head *p;
362 
363 	usb_unregister_notify(&mon_nb);
364 	usb_mon_deregister();
365 
366 	mutex_lock(&mon_lock);
367 	while (!list_empty(&mon_buses)) {
368 		p = mon_buses.next;
369 		mbus = list_entry(p, struct mon_bus, bus_link);
370 		list_del(p);
371 
372 		debugfs_remove(mbus->dent_t);
373 		debugfs_remove(mbus->dent_s);
374 
375 		/*
376 		 * This never happens, because the open/close paths in
377 		 * file level maintain module use counters and so rmmod fails
378 		 * before reaching here. However, better be safe...
379 		 */
380 		if (mbus->nreaders) {
381 			printk(KERN_ERR TAG
382 			    ": Outstanding opens (%d) on usb%d, leaking...\n",
383 			    mbus->nreaders, mbus->u_bus->busnum);
384 			atomic_set(&mbus->ref.refcount, 2);	/* Force leak */
385 		}
386 
387 		mon_dissolve(mbus, mbus->u_bus);
388 		kref_put(&mbus->ref, mon_bus_drop);
389 	}
390 	mutex_unlock(&mon_lock);
391 
392 	debugfs_remove(mon_dir);
393 }
394 
395 module_init(mon_init);
396 module_exit(mon_exit);
397 
398 MODULE_LICENSE("GPL");
399