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