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