xref: /linux/drivers/usb/mon/mon_main.c (revision 185a257f2f73bcd89050ad02da5bedbc28fc43fa) 
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 	mbus->cnt_events++;
101 	list_for_each (pos, &mbus->r_list) {
102 		r = list_entry(pos, struct mon_reader, r_link);
103 		r->rnf_submit(r->r_data, urb);
104 	}
105 
106 	spin_unlock_irqrestore(&mbus->lock, flags);
107 	return;
108 
109 out_locked:
110 	spin_unlock_irqrestore(&mbus->lock, flags);
111 out_unlocked:
112 	return;
113 }
114 
115 /*
116  */
117 static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
118 {
119 	struct mon_bus *mbus;
120 	unsigned long flags;
121 	struct list_head *pos;
122 	struct mon_reader *r;
123 
124 	mbus = ubus->mon_bus;
125 	if (mbus == NULL)
126 		goto out_unlocked;
127 
128 	spin_lock_irqsave(&mbus->lock, flags);
129 	if (mbus->nreaders == 0)
130 		goto out_locked;
131 
132 	mbus->cnt_events++;
133 	list_for_each (pos, &mbus->r_list) {
134 		r = list_entry(pos, struct mon_reader, r_link);
135 		r->rnf_error(r->r_data, urb, error);
136 	}
137 
138 	spin_unlock_irqrestore(&mbus->lock, flags);
139 	return;
140 
141 out_locked:
142 	spin_unlock_irqrestore(&mbus->lock, flags);
143 out_unlocked:
144 	return;
145 }
146 
147 /*
148  */
149 static void mon_complete(struct usb_bus *ubus, struct urb *urb)
150 {
151 	struct mon_bus *mbus;
152 	unsigned long flags;
153 	struct list_head *pos;
154 	struct mon_reader *r;
155 
156 	mbus = ubus->mon_bus;
157 	if (mbus == NULL) {
158 		/*
159 		 * This should not happen.
160 		 * At this point we do not even know the bus number...
161 		 */
162 		printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
163 		    urb->pipe);
164 		return;
165 	}
166 
167 	spin_lock_irqsave(&mbus->lock, flags);
168 	mbus->cnt_events++;
169 	list_for_each (pos, &mbus->r_list) {
170 		r = list_entry(pos, struct mon_reader, r_link);
171 		r->rnf_complete(r->r_data, urb);
172 	}
173 	spin_unlock_irqrestore(&mbus->lock, flags);
174 }
175 
176 /* int (*unlink_urb) (struct urb *urb, int status); */
177 
178 /*
179  * Stop monitoring.
180  */
181 static void mon_stop(struct mon_bus *mbus)
182 {
183 	struct usb_bus *ubus = mbus->u_bus;
184 
185 	/*
186 	 * A stop can be called for a dissolved mon_bus in case of
187 	 * a reader staying across an rmmod foo_hcd.
188 	 */
189 	if (ubus != NULL) {
190 		ubus->monitored = 0;
191 		mb();
192 	}
193 }
194 
195 /*
196  * Add a USB bus (usually by a modprobe foo-hcd)
197  *
198  * This does not return an error code because the core cannot care less
199  * if monitoring is not established.
200  */
201 static void mon_bus_add(struct usb_bus *ubus)
202 {
203 	mon_bus_init(mon_dir, ubus);
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 
213 	mutex_lock(&mon_lock);
214 	list_del(&mbus->bus_link);
215 	debugfs_remove(mbus->dent_t);
216 	debugfs_remove(mbus->dent_s);
217 
218 	mon_dissolve(mbus, ubus);
219 	kref_put(&mbus->ref, mon_bus_drop);
220 	mutex_unlock(&mon_lock);
221 }
222 
223 static int mon_notify(struct notifier_block *self, unsigned long action,
224 		      void *dev)
225 {
226 	switch (action) {
227 	case USB_BUS_ADD:
228 		mon_bus_add(dev);
229 		break;
230 	case USB_BUS_REMOVE:
231 		mon_bus_remove(dev);
232 	}
233 	return NOTIFY_OK;
234 }
235 
236 static struct notifier_block mon_nb = {
237 	.notifier_call = 	mon_notify,
238 };
239 
240 /*
241  * Ops
242  */
243 static struct usb_mon_operations mon_ops_0 = {
244 	.urb_submit =	mon_submit,
245 	.urb_submit_error = mon_submit_error,
246 	.urb_complete =	mon_complete,
247 };
248 
249 /*
250  * Tear usb_bus and mon_bus apart.
251  */
252 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus)
253 {
254 
255 	/*
256 	 * Never happens, but...
257 	 */
258 	if (ubus->monitored) {
259 		printk(KERN_ERR TAG ": bus %d is dissolved while monitored\n",
260 		    ubus->busnum);
261 		ubus->monitored = 0;
262 		mb();
263 	}
264 
265 	ubus->mon_bus = NULL;
266 	mbus->u_bus = NULL;
267 	mb();
268 }
269 
270 /*
271  */
272 static void mon_bus_drop(struct kref *r)
273 {
274 	struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
275 	kfree(mbus);
276 }
277 
278 /*
279  * Initialize a bus for us:
280  *  - allocate mon_bus
281  *  - refcount USB bus struct
282  *  - link
283  */
284 static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus)
285 {
286 	struct dentry *d;
287 	struct mon_bus *mbus;
288 	enum { NAMESZ = 10 };
289 	char name[NAMESZ];
290 	int rc;
291 
292 	if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
293 		goto err_alloc;
294 	kref_init(&mbus->ref);
295 	spin_lock_init(&mbus->lock);
296 	INIT_LIST_HEAD(&mbus->r_list);
297 
298 	/*
299 	 * We don't need to take a reference to ubus, because we receive
300 	 * a notification if the bus is about to be removed.
301 	 */
302 	mbus->u_bus = ubus;
303 	ubus->mon_bus = mbus;
304 	mbus->uses_dma = ubus->uses_dma;
305 
306 	rc = snprintf(name, NAMESZ, "%dt", ubus->busnum);
307 	if (rc <= 0 || rc >= NAMESZ)
308 		goto err_print_t;
309 	d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_text);
310 	if (d == NULL)
311 		goto err_create_t;
312 	mbus->dent_t = d;
313 
314 	rc = snprintf(name, NAMESZ, "%ds", ubus->busnum);
315 	if (rc <= 0 || rc >= NAMESZ)
316 		goto err_print_s;
317 	d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_stat);
318 	if (d == NULL)
319 		goto err_create_s;
320 	mbus->dent_s = d;
321 
322 	mutex_lock(&mon_lock);
323 	list_add_tail(&mbus->bus_link, &mon_buses);
324 	mutex_unlock(&mon_lock);
325 	return;
326 
327 err_create_s:
328 err_print_s:
329 	debugfs_remove(mbus->dent_t);
330 err_create_t:
331 err_print_t:
332 	kfree(mbus);
333 err_alloc:
334 	return;
335 }
336 
337 static int __init mon_init(void)
338 {
339 	struct usb_bus *ubus;
340 	struct dentry *mondir;
341 
342 	mondir = debugfs_create_dir("usbmon", NULL);
343 	if (IS_ERR(mondir)) {
344 		printk(KERN_NOTICE TAG ": debugfs is not available\n");
345 		return -ENODEV;
346 	}
347 	if (mondir == NULL) {
348 		printk(KERN_NOTICE TAG ": unable to create usbmon directory\n");
349 		return -ENODEV;
350 	}
351 	mon_dir = mondir;
352 
353 	if (usb_mon_register(&mon_ops_0) != 0) {
354 		printk(KERN_NOTICE TAG ": unable to register with the core\n");
355 		debugfs_remove(mondir);
356 		return -ENODEV;
357 	}
358 	// MOD_INC_USE_COUNT(which_module?);
359 
360 	usb_register_notify(&mon_nb);
361 
362 	mutex_lock(&usb_bus_list_lock);
363 	list_for_each_entry (ubus, &usb_bus_list, bus_list) {
364 		mon_bus_init(mondir, ubus);
365 	}
366 	mutex_unlock(&usb_bus_list_lock);
367 	return 0;
368 }
369 
370 static void __exit mon_exit(void)
371 {
372 	struct mon_bus *mbus;
373 	struct list_head *p;
374 
375 	usb_unregister_notify(&mon_nb);
376 	usb_mon_deregister();
377 
378 	mutex_lock(&mon_lock);
379 	while (!list_empty(&mon_buses)) {
380 		p = mon_buses.next;
381 		mbus = list_entry(p, struct mon_bus, bus_link);
382 		list_del(p);
383 
384 		debugfs_remove(mbus->dent_t);
385 		debugfs_remove(mbus->dent_s);
386 
387 		/*
388 		 * This never happens, because the open/close paths in
389 		 * file level maintain module use counters and so rmmod fails
390 		 * before reaching here. However, better be safe...
391 		 */
392 		if (mbus->nreaders) {
393 			printk(KERN_ERR TAG
394 			    ": Outstanding opens (%d) on usb%d, leaking...\n",
395 			    mbus->nreaders, mbus->u_bus->busnum);
396 			atomic_set(&mbus->ref.refcount, 2);	/* Force leak */
397 		}
398 
399 		mon_dissolve(mbus, mbus->u_bus);
400 		kref_put(&mbus->ref, mon_bus_drop);
401 	}
402 	mutex_unlock(&mon_lock);
403 
404 	debugfs_remove(mon_dir);
405 }
406 
407 module_init(mon_init);
408 module_exit(mon_exit);
409 
410 MODULE_LICENSE("GPL");
411