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