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/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         // usb_bus_put(ubus);
 269 }
 270
 271 /*
 272  */
 273 static void mon_bus_drop(struct kref *r)
 274 {
 275         struct mon_bus *mbus = container_of(r, struct mon_bus, ref);
 276         kfree(mbus);
 277 }
 278
 279 /*
 280  * Initialize a bus for us:
 281  *  - allocate mon_bus
 282  *  - refcount USB bus struct
 283  *  - link
 284  */
 285 static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus)
 286 {
 287         struct dentry *d;
 288         struct mon_bus *mbus;
 289         enum { NAMESZ = 10 };
 290         char name[NAMESZ];
 291         int rc;
 292
 293         if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
 294                 goto err_alloc;
 295         kref_init(&mbus->ref);
 296         spin_lock_init(&mbus->lock);
 297         INIT_LIST_HEAD(&mbus->r_list);
 298
 299         /*
 300          * This usb_bus_get here is superfluous, because we receive
 301          * a notification if usb_bus is about to be removed.
 302          */
 303         // usb_bus_get(ubus);
 304         mbus->u_bus = ubus;
 305         ubus->mon_bus = mbus;
 306
 307         rc = snprintf(name, NAMESZ, "%dt", ubus->busnum);
 308         if (rc <= 0 || rc >= NAMESZ)
 309                 goto err_print_t;
 310         d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_text);
 311         if (d == NULL)
 312                 goto err_create_t;
 313         mbus->dent_t = d;
 314
 315         rc = snprintf(name, NAMESZ, "%ds", ubus->busnum);
 316         if (rc <= 0 || rc >= NAMESZ)
 317                 goto err_print_s;
 318         d = debugfs_create_file(name, 0600, mondir, mbus, &mon_fops_stat);
 319         if (d == NULL)
 320                 goto err_create_s;
 321         mbus->dent_s = d;
 322
 323         mutex_lock(&mon_lock);
 324         list_add_tail(&mbus->bus_link, &mon_buses);
 325         mutex_unlock(&mon_lock);
 326         return;
 327
 328 err_create_s:
 329 err_print_s:
 330         debugfs_remove(mbus->dent_t);
 331 err_create_t:
 332 err_print_t:
 333         kfree(mbus);
 334 err_alloc:
 335         return;
 336 }
 337
 338 static int __init mon_init(void)
 339 {
 340         struct usb_bus *ubus;
 341         struct dentry *mondir;
 342
 343         mondir = debugfs_create_dir("usbmon", NULL);
 344         if (IS_ERR(mondir)) {
 345                 printk(KERN_NOTICE TAG ": debugfs is not available\n");
 346                 return -ENODEV;
 347         }
 348         if (mondir == NULL) {
 349                 printk(KERN_NOTICE TAG ": unable to create usbmon directory\n");
 350                 return -ENODEV;
 351         }
 352         mon_dir = mondir;
 353
 354         if (usb_mon_register(&mon_ops_0) != 0) {
 355                 printk(KERN_NOTICE TAG ": unable to register with the core\n");
 356                 debugfs_remove(mondir);
 357                 return -ENODEV;
 358         }
 359         // MOD_INC_USE_COUNT(which_module?);
 360
 361         usb_register_notify(&mon_nb);
 362
 363         mutex_lock(&usb_bus_list_lock);
 364         list_for_each_entry (ubus, &usb_bus_list, bus_list) {
 365                 mon_bus_init(mondir, ubus);
 366         }
 367         mutex_unlock(&usb_bus_list_lock);
 368         return 0;
 369 }
 370
 371 static void __exit mon_exit(void)
 372 {
 373         struct mon_bus *mbus;
 374         struct list_head *p;
 375
 376         usb_unregister_notify(&mon_nb);
 377         usb_mon_deregister();
 378
 379         mutex_lock(&mon_lock);
 380         while (!list_empty(&mon_buses)) {
 381                 p = mon_buses.next;
 382                 mbus = list_entry(p, struct mon_bus, bus_link);
 383                 list_del(p);
 384
 385                 debugfs_remove(mbus->dent_t);
 386                 debugfs_remove(mbus->dent_s);
 387
 388                 /*
 389                  * This never happens, because the open/close paths in
 390                  * file level maintain module use counters and so rmmod fails
 391                  * before reaching here. However, better be safe...
 392                  */
 393                 if (mbus->nreaders) {
 394                         printk(KERN_ERR TAG
 395                             ": Outstanding opens (%d) on usb%d, leaking...\n",
 396                             mbus->nreaders, mbus->u_bus->busnum);
 397                         atomic_set(&mbus->ref.refcount, 2);     /* Force leak */
 398                 }
 399
 400                 mon_dissolve(mbus, mbus->u_bus);
 401                 kref_put(&mbus->ref, mon_bus_drop);
 402         }
 403         mutex_unlock(&mon_lock);
 404
 405         debugfs_remove(mon_dir);
 406 }
 407
 408 module_init(mon_init);
 409 module_exit(mon_exit);
 410
 411 MODULE_LICENSE("GPL");