USB: add binary API to usbmon
[linux-2.6.git] / drivers / usb / mon / mon_main.c
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/smp_lock.h>
13 #include <linux/notifier.h>
14 #include <linux/mutex.h>
15
16 #include "usb_mon.h"
17 #include "../core/hcd.h"
18
19 static void mon_submit(struct usb_bus *ubus, struct urb *urb);
20 static void mon_complete(struct usb_bus *ubus, struct urb *urb);
21 static void mon_stop(struct mon_bus *mbus);
22 static void mon_dissolve(struct mon_bus *mbus, struct usb_bus *ubus);
23 static void mon_bus_drop(struct kref *r);
24 static void mon_bus_init(struct usb_bus *ubus);
25
26 DEFINE_MUTEX(mon_lock);
27
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         mbus->cnt_events++;
99         list_for_each (pos, &mbus->r_list) {
100                 r = list_entry(pos, struct mon_reader, r_link);
101                 r->rnf_submit(r->r_data, urb);
102         }
103
104         spin_unlock_irqrestore(&mbus->lock, flags);
105         return;
106
107 out_locked:
108         spin_unlock_irqrestore(&mbus->lock, flags);
109 out_unlocked:
110         return;
111 }
112
113 /*
114  */
115 static void mon_submit_error(struct usb_bus *ubus, struct urb *urb, int error)
116 {
117         struct mon_bus *mbus;
118         unsigned long flags;
119         struct list_head *pos;
120         struct mon_reader *r;
121
122         mbus = ubus->mon_bus;
123         if (mbus == NULL)
124                 goto out_unlocked;
125
126         spin_lock_irqsave(&mbus->lock, flags);
127         if (mbus->nreaders == 0)
128                 goto out_locked;
129
130         mbus->cnt_events++;
131         list_for_each (pos, &mbus->r_list) {
132                 r = list_entry(pos, struct mon_reader, r_link);
133                 r->rnf_error(r->r_data, urb, error);
134         }
135
136         spin_unlock_irqrestore(&mbus->lock, flags);
137         return;
138
139 out_locked:
140         spin_unlock_irqrestore(&mbus->lock, flags);
141 out_unlocked:
142         return;
143 }
144
145 /*
146  */
147 static void mon_complete(struct usb_bus *ubus, struct urb *urb)
148 {
149         struct mon_bus *mbus;
150         unsigned long flags;
151         struct list_head *pos;
152         struct mon_reader *r;
153
154         mbus = ubus->mon_bus;
155         if (mbus == NULL) {
156                 /*
157                  * This should not happen.
158                  * At this point we do not even know the bus number...
159                  */
160                 printk(KERN_ERR TAG ": Null mon bus in URB, pipe 0x%x\n",
161                     urb->pipe);
162                 return;
163         }
164
165         spin_lock_irqsave(&mbus->lock, flags);
166         mbus->cnt_events++;
167         list_for_each (pos, &mbus->r_list) {
168                 r = list_entry(pos, struct mon_reader, r_link);
169                 r->rnf_complete(r->r_data, urb);
170         }
171         spin_unlock_irqrestore(&mbus->lock, flags);
172 }
173
174 /* int (*unlink_urb) (struct urb *urb, int status); */
175
176 /*
177  * Stop monitoring.
178  */
179 static void mon_stop(struct mon_bus *mbus)
180 {
181         struct usb_bus *ubus = mbus->u_bus;
182
183         /*
184          * A stop can be called for a dissolved mon_bus in case of
185          * a reader staying across an rmmod foo_hcd.
186          */
187         if (ubus != NULL) {
188                 ubus->monitored = 0;
189                 mb();
190         }
191 }
192
193 /*
194  * Add a USB bus (usually by a modprobe foo-hcd)
195  *
196  * This does not return an error code because the core cannot care less
197  * if monitoring is not established.
198  */
199 static void mon_bus_add(struct usb_bus *ubus)
200 {
201         mon_bus_init(ubus);
202 }
203
204 /*
205  * Remove a USB bus (either from rmmod foo-hcd or from a hot-remove event).
206  */
207 static void mon_bus_remove(struct usb_bus *ubus)
208 {
209         struct mon_bus *mbus = ubus->mon_bus;
210
211         mutex_lock(&mon_lock);
212         list_del(&mbus->bus_link);
213         if (mbus->text_inited)
214                 mon_text_del(mbus);
215
216         mon_dissolve(mbus, ubus);
217         kref_put(&mbus->ref, mon_bus_drop);
218         mutex_unlock(&mon_lock);
219 }
220
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
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,
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
253         /*
254          * Never happens, but...
255          */
256         if (ubus->monitored) {
257                 printk(KERN_ERR TAG ": bus %d is dissolved while monitored\n",
258                     ubus->busnum);
259                 ubus->monitored = 0;
260                 mb();
261         }
262
263         ubus->mon_bus = NULL;
264         mbus->u_bus = NULL;
265         mb();
266 }
267
268 /*
269  */
270 static void mon_bus_drop(struct kref *r)
271 {
272         struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
273         kfree(mbus);
274 }
275
276 /*
277  * Initialize a bus for us:
278  *  - allocate mon_bus
279  *  - refcount USB bus struct
280  *  - link
281  */
282 static void mon_bus_init(struct usb_bus *ubus)
283 {
284         struct mon_bus *mbus;
285
286         if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
287                 goto err_alloc;
288         kref_init(&mbus->ref);
289         spin_lock_init(&mbus->lock);
290         INIT_LIST_HEAD(&mbus->r_list);
291
292         /*
293          * We don't need to take a reference to ubus, because we receive
294          * a notification if the bus is about to be removed.
295          */
296         mbus->u_bus = ubus;
297         ubus->mon_bus = mbus;
298         mbus->uses_dma = ubus->uses_dma;
299
300         mbus->text_inited = mon_text_add(mbus, ubus);
301         // mon_bin_add(...)
302
303         mutex_lock(&mon_lock);
304         list_add_tail(&mbus->bus_link, &mon_buses);
305         mutex_unlock(&mon_lock);
306         return;
307
308 err_alloc:
309         return;
310 }
311
312 /*
313  * Search a USB bus by number. Notice that USB bus numbers start from one,
314  * which we may later use to identify "all" with zero.
315  *
316  * This function must be called with mon_lock held.
317  *
318  * This is obviously inefficient and may be revised in the future.
319  */
320 struct mon_bus *mon_bus_lookup(unsigned int num)
321 {
322         struct list_head *p;
323         struct mon_bus *mbus;
324
325         list_for_each (p, &mon_buses) {
326                 mbus = list_entry(p, struct mon_bus, bus_link);
327                 if (mbus->u_bus->busnum == num) {
328                         return mbus;
329                 }
330         }
331         return NULL;
332 }
333
334 static int __init mon_init(void)
335 {
336         struct usb_bus *ubus;
337         int rc;
338
339         if ((rc = mon_text_init()) != 0)
340                 goto err_text;
341         if ((rc = mon_bin_init()) != 0)
342                 goto err_bin;
343
344         if (usb_mon_register(&mon_ops_0) != 0) {
345                 printk(KERN_NOTICE TAG ": unable to register with the core\n");
346                 rc = -ENODEV;
347                 goto err_reg;
348         }
349         // MOD_INC_USE_COUNT(which_module?);
350
351         usb_register_notify(&mon_nb);
352
353         mutex_lock(&usb_bus_list_lock);
354         list_for_each_entry (ubus, &usb_bus_list, bus_list) {
355                 mon_bus_init(ubus);
356         }
357         mutex_unlock(&usb_bus_list_lock);
358         return 0;
359
360 err_reg:
361         mon_bin_exit();
362 err_bin:
363         mon_text_exit();
364 err_text:
365         return rc;
366 }
367
368 static void __exit mon_exit(void)
369 {
370         struct mon_bus *mbus;
371         struct list_head *p;
372
373         usb_unregister_notify(&mon_nb);
374         usb_mon_deregister();
375
376         mutex_lock(&mon_lock);
377         while (!list_empty(&mon_buses)) {
378                 p = mon_buses.next;
379                 mbus = list_entry(p, struct mon_bus, bus_link);
380                 list_del(p);
381
382                 if (mbus->text_inited)
383                         mon_text_del(mbus);
384
385                 /*
386                  * This never happens, because the open/close paths in
387                  * file level maintain module use counters and so rmmod fails
388                  * before reaching here. However, better be safe...
389                  */
390                 if (mbus->nreaders) {
391                         printk(KERN_ERR TAG
392                             ": Outstanding opens (%d) on usb%d, leaking...\n",
393                             mbus->nreaders, mbus->u_bus->busnum);
394                         atomic_set(&mbus->ref.refcount, 2);     /* Force leak */
395                 }
396
397                 mon_dissolve(mbus, mbus->u_bus);
398                 kref_put(&mbus->ref, mon_bus_drop);
399         }
400         mutex_unlock(&mon_lock);
401
402         mon_text_exit();
403         mon_bin_exit();
404 }
405
406 module_init(mon_init);
407 module_exit(mon_exit);
408
409 MODULE_LICENSE("GPL");