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