1 /* 2 * The USB Monitor, inspired by Dave Harding's USBMon. 3 * 4 * This is a text format reader. 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/list.h> 9 #include <linux/usb.h> 10 #include <linux/time.h> 11 #include <linux/mutex.h> 12 #include <linux/debugfs.h> 13 #include <asm/uaccess.h> 14 15 #include "usb_mon.h" 16 17 /* 18 * No, we do not want arbitrarily long data strings. 19 * Use the binary interface if you want to capture bulk data! 20 */ 21 #define DATA_MAX 32 22 23 /* 24 * Defined by USB 2.0 clause 9.3, table 9.2. 25 */ 26 #define SETUP_MAX 8 27 28 /* 29 * This limit exists to prevent OOMs when the user process stops reading. 30 * If usbmon were available to unprivileged processes, it might be open 31 * to a local DoS. But we have to keep to root in order to prevent 32 * password sniffing from HID devices. 33 */ 34 #define EVENT_MAX (4*PAGE_SIZE / sizeof(struct mon_event_text)) 35 36 /* 37 * Potentially unlimited number; we limit it for similar allocations. 38 * The usbfs limits this to 128, but we're not quite as generous. 39 */ 40 #define ISODESC_MAX 5 41 42 #define PRINTF_DFL 250 /* with 5 ISOs segs */ 43 44 struct mon_iso_desc { 45 int status; 46 unsigned int offset; 47 unsigned int length; /* Unsigned here, signed in URB. Historic. */ 48 }; 49 50 struct mon_event_text { 51 struct list_head e_link; 52 int type; /* submit, complete, etc. */ 53 unsigned long id; /* From pointer, most of the time */ 54 unsigned int tstamp; 55 int busnum; 56 char devnum; 57 char epnum; 58 char is_in; 59 char xfertype; 60 int length; /* Depends on type: xfer length or act length */ 61 int status; 62 int interval; 63 int start_frame; 64 int error_count; 65 char setup_flag; 66 char data_flag; 67 int numdesc; /* Full number */ 68 struct mon_iso_desc isodesc[ISODESC_MAX]; 69 unsigned char setup[SETUP_MAX]; 70 unsigned char data[DATA_MAX]; 71 }; 72 73 #define SLAB_NAME_SZ 30 74 struct mon_reader_text { 75 struct kmem_cache *e_slab; 76 int nevents; 77 struct list_head e_list; 78 struct mon_reader r; /* In C, parent class can be placed anywhere */ 79 80 wait_queue_head_t wait; 81 int printf_size; 82 char *printf_buf; 83 struct mutex printf_lock; 84 85 char slab_name[SLAB_NAME_SZ]; 86 }; 87 88 static struct dentry *mon_dir; /* Usually /sys/kernel/debug/usbmon */ 89 90 static void mon_text_ctor(struct kmem_cache *, void *); 91 92 struct mon_text_ptr { 93 int cnt, limit; 94 char *pbuf; 95 }; 96 97 static struct mon_event_text * 98 mon_text_read_wait(struct mon_reader_text *rp, struct file *file); 99 static void mon_text_read_head_t(struct mon_reader_text *rp, 100 struct mon_text_ptr *p, const struct mon_event_text *ep); 101 static void mon_text_read_head_u(struct mon_reader_text *rp, 102 struct mon_text_ptr *p, const struct mon_event_text *ep); 103 static void mon_text_read_statset(struct mon_reader_text *rp, 104 struct mon_text_ptr *p, const struct mon_event_text *ep); 105 static void mon_text_read_intstat(struct mon_reader_text *rp, 106 struct mon_text_ptr *p, const struct mon_event_text *ep); 107 static void mon_text_read_isostat(struct mon_reader_text *rp, 108 struct mon_text_ptr *p, const struct mon_event_text *ep); 109 static void mon_text_read_isodesc(struct mon_reader_text *rp, 110 struct mon_text_ptr *p, const struct mon_event_text *ep); 111 static void mon_text_read_data(struct mon_reader_text *rp, 112 struct mon_text_ptr *p, const struct mon_event_text *ep); 113 114 /* 115 * mon_text_submit 116 * mon_text_complete 117 * 118 * May be called from an interrupt. 119 * 120 * This is called with the whole mon_bus locked, so no additional lock. 121 */ 122 123 static inline char mon_text_get_setup(struct mon_event_text *ep, 124 struct urb *urb, char ev_type, struct mon_bus *mbus) 125 { 126 127 if (ep->xfertype != USB_ENDPOINT_XFER_CONTROL || ev_type != 'S') 128 return '-'; 129 130 if (urb->setup_packet == NULL) 131 return 'Z'; /* '0' would be not as pretty. */ 132 133 memcpy(ep->setup, urb->setup_packet, SETUP_MAX); 134 return 0; 135 } 136 137 static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb, 138 int len, char ev_type, struct mon_bus *mbus) 139 { 140 if (len <= 0) 141 return 'L'; 142 if (len >= DATA_MAX) 143 len = DATA_MAX; 144 145 if (ep->is_in) { 146 if (ev_type != 'C') 147 return '<'; 148 } else { 149 if (ev_type != 'S') 150 return '>'; 151 } 152 153 /* 154 * The check to see if it's safe to poke at data has an enormous 155 * number of corner cases, but it seems that the following is 156 * more or less safe. 157 * 158 * We do not even try to look at transfer_buffer, because it can 159 * contain non-NULL garbage in case the upper level promised to 160 * set DMA for the HCD. 161 */ 162 if (urb->dev->bus->uses_dma && 163 (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) { 164 return mon_dmapeek(ep->data, urb->transfer_dma, len); 165 } 166 167 if (urb->transfer_buffer == NULL) 168 return 'Z'; /* '0' would be not as pretty. */ 169 170 memcpy(ep->data, urb->transfer_buffer, len); 171 return 0; 172 } 173 174 static inline unsigned int mon_get_timestamp(void) 175 { 176 struct timeval tval; 177 unsigned int stamp; 178 179 do_gettimeofday(&tval); 180 stamp = tval.tv_sec & 0xFFFF; /* 2^32 = 4294967296. Limit to 4096s. */ 181 stamp = stamp * 1000000 + tval.tv_usec; 182 return stamp; 183 } 184 185 static void mon_text_event(struct mon_reader_text *rp, struct urb *urb, 186 char ev_type, int status) 187 { 188 struct mon_event_text *ep; 189 unsigned int stamp; 190 struct usb_iso_packet_descriptor *fp; 191 struct mon_iso_desc *dp; 192 int i, ndesc; 193 194 stamp = mon_get_timestamp(); 195 196 if (rp->nevents >= EVENT_MAX || 197 (ep = kmem_cache_alloc(rp->e_slab, GFP_ATOMIC)) == NULL) { 198 rp->r.m_bus->cnt_text_lost++; 199 return; 200 } 201 202 ep->type = ev_type; 203 ep->id = (unsigned long) urb; 204 ep->busnum = urb->dev->bus->busnum; 205 ep->devnum = urb->dev->devnum; 206 ep->epnum = usb_endpoint_num(&urb->ep->desc); 207 ep->xfertype = usb_endpoint_type(&urb->ep->desc); 208 ep->is_in = usb_urb_dir_in(urb); 209 ep->tstamp = stamp; 210 ep->length = (ev_type == 'S') ? 211 urb->transfer_buffer_length : urb->actual_length; 212 /* Collecting status makes debugging sense for submits, too */ 213 ep->status = status; 214 215 if (ep->xfertype == USB_ENDPOINT_XFER_INT) { 216 ep->interval = urb->interval; 217 } else if (ep->xfertype == USB_ENDPOINT_XFER_ISOC) { 218 ep->interval = urb->interval; 219 ep->start_frame = urb->start_frame; 220 ep->error_count = urb->error_count; 221 } 222 ep->numdesc = urb->number_of_packets; 223 if (ep->xfertype == USB_ENDPOINT_XFER_ISOC && 224 urb->number_of_packets > 0) { 225 if ((ndesc = urb->number_of_packets) > ISODESC_MAX) 226 ndesc = ISODESC_MAX; 227 fp = urb->iso_frame_desc; 228 dp = ep->isodesc; 229 for (i = 0; i < ndesc; i++) { 230 dp->status = fp->status; 231 dp->offset = fp->offset; 232 dp->length = (ev_type == 'S') ? 233 fp->length : fp->actual_length; 234 fp++; 235 dp++; 236 } 237 } 238 239 ep->setup_flag = mon_text_get_setup(ep, urb, ev_type, rp->r.m_bus); 240 ep->data_flag = mon_text_get_data(ep, urb, ep->length, ev_type, 241 rp->r.m_bus); 242 243 rp->nevents++; 244 list_add_tail(&ep->e_link, &rp->e_list); 245 wake_up(&rp->wait); 246 } 247 248 static void mon_text_submit(void *data, struct urb *urb) 249 { 250 struct mon_reader_text *rp = data; 251 mon_text_event(rp, urb, 'S', -EINPROGRESS); 252 } 253 254 static void mon_text_complete(void *data, struct urb *urb, int status) 255 { 256 struct mon_reader_text *rp = data; 257 mon_text_event(rp, urb, 'C', status); 258 } 259 260 static void mon_text_error(void *data, struct urb *urb, int error) 261 { 262 struct mon_reader_text *rp = data; 263 struct mon_event_text *ep; 264 265 if (rp->nevents >= EVENT_MAX || 266 (ep = kmem_cache_alloc(rp->e_slab, GFP_ATOMIC)) == NULL) { 267 rp->r.m_bus->cnt_text_lost++; 268 return; 269 } 270 271 ep->type = 'E'; 272 ep->id = (unsigned long) urb; 273 ep->busnum = 0; 274 ep->devnum = urb->dev->devnum; 275 ep->epnum = usb_endpoint_num(&urb->ep->desc); 276 ep->xfertype = usb_endpoint_type(&urb->ep->desc); 277 ep->is_in = usb_urb_dir_in(urb); 278 ep->tstamp = 0; 279 ep->length = 0; 280 ep->status = error; 281 282 ep->setup_flag = '-'; 283 ep->data_flag = 'E'; 284 285 rp->nevents++; 286 list_add_tail(&ep->e_link, &rp->e_list); 287 wake_up(&rp->wait); 288 } 289 290 /* 291 * Fetch next event from the circular buffer. 292 */ 293 static struct mon_event_text *mon_text_fetch(struct mon_reader_text *rp, 294 struct mon_bus *mbus) 295 { 296 struct list_head *p; 297 unsigned long flags; 298 299 spin_lock_irqsave(&mbus->lock, flags); 300 if (list_empty(&rp->e_list)) { 301 spin_unlock_irqrestore(&mbus->lock, flags); 302 return NULL; 303 } 304 p = rp->e_list.next; 305 list_del(p); 306 --rp->nevents; 307 spin_unlock_irqrestore(&mbus->lock, flags); 308 return list_entry(p, struct mon_event_text, e_link); 309 } 310 311 /* 312 */ 313 static int mon_text_open(struct inode *inode, struct file *file) 314 { 315 struct mon_bus *mbus; 316 struct mon_reader_text *rp; 317 int rc; 318 319 mutex_lock(&mon_lock); 320 mbus = inode->i_private; 321 322 rp = kzalloc(sizeof(struct mon_reader_text), GFP_KERNEL); 323 if (rp == NULL) { 324 rc = -ENOMEM; 325 goto err_alloc; 326 } 327 INIT_LIST_HEAD(&rp->e_list); 328 init_waitqueue_head(&rp->wait); 329 mutex_init(&rp->printf_lock); 330 331 rp->printf_size = PRINTF_DFL; 332 rp->printf_buf = kmalloc(rp->printf_size, GFP_KERNEL); 333 if (rp->printf_buf == NULL) { 334 rc = -ENOMEM; 335 goto err_alloc_pr; 336 } 337 338 rp->r.m_bus = mbus; 339 rp->r.r_data = rp; 340 rp->r.rnf_submit = mon_text_submit; 341 rp->r.rnf_error = mon_text_error; 342 rp->r.rnf_complete = mon_text_complete; 343 344 snprintf(rp->slab_name, SLAB_NAME_SZ, "mon_text_%p", rp); 345 rp->e_slab = kmem_cache_create(rp->slab_name, 346 sizeof(struct mon_event_text), sizeof(long), 0, 347 mon_text_ctor); 348 if (rp->e_slab == NULL) { 349 rc = -ENOMEM; 350 goto err_slab; 351 } 352 353 mon_reader_add(mbus, &rp->r); 354 355 file->private_data = rp; 356 mutex_unlock(&mon_lock); 357 return 0; 358 359 // err_busy: 360 // kmem_cache_destroy(rp->e_slab); 361 err_slab: 362 kfree(rp->printf_buf); 363 err_alloc_pr: 364 kfree(rp); 365 err_alloc: 366 mutex_unlock(&mon_lock); 367 return rc; 368 } 369 370 /* 371 * For simplicity, we read one record in one system call and throw out 372 * what does not fit. This means that the following does not work: 373 * dd if=/dbg/usbmon/0t bs=10 374 * Also, we do not allow seeks and do not bother advancing the offset. 375 */ 376 static ssize_t mon_text_read_t(struct file *file, char __user *buf, 377 size_t nbytes, loff_t *ppos) 378 { 379 struct mon_reader_text *rp = file->private_data; 380 struct mon_event_text *ep; 381 struct mon_text_ptr ptr; 382 383 if (IS_ERR(ep = mon_text_read_wait(rp, file))) 384 return PTR_ERR(ep); 385 mutex_lock(&rp->printf_lock); 386 ptr.cnt = 0; 387 ptr.pbuf = rp->printf_buf; 388 ptr.limit = rp->printf_size; 389 390 mon_text_read_head_t(rp, &ptr, ep); 391 mon_text_read_statset(rp, &ptr, ep); 392 ptr.cnt += snprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt, 393 " %d", ep->length); 394 mon_text_read_data(rp, &ptr, ep); 395 396 if (copy_to_user(buf, rp->printf_buf, ptr.cnt)) 397 ptr.cnt = -EFAULT; 398 mutex_unlock(&rp->printf_lock); 399 kmem_cache_free(rp->e_slab, ep); 400 return ptr.cnt; 401 } 402 403 static ssize_t mon_text_read_u(struct file *file, char __user *buf, 404 size_t nbytes, loff_t *ppos) 405 { 406 struct mon_reader_text *rp = file->private_data; 407 struct mon_event_text *ep; 408 struct mon_text_ptr ptr; 409 410 if (IS_ERR(ep = mon_text_read_wait(rp, file))) 411 return PTR_ERR(ep); 412 mutex_lock(&rp->printf_lock); 413 ptr.cnt = 0; 414 ptr.pbuf = rp->printf_buf; 415 ptr.limit = rp->printf_size; 416 417 mon_text_read_head_u(rp, &ptr, ep); 418 if (ep->type == 'E') { 419 mon_text_read_statset(rp, &ptr, ep); 420 } else if (ep->xfertype == USB_ENDPOINT_XFER_ISOC) { 421 mon_text_read_isostat(rp, &ptr, ep); 422 mon_text_read_isodesc(rp, &ptr, ep); 423 } else if (ep->xfertype == USB_ENDPOINT_XFER_INT) { 424 mon_text_read_intstat(rp, &ptr, ep); 425 } else { 426 mon_text_read_statset(rp, &ptr, ep); 427 } 428 ptr.cnt += snprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt, 429 " %d", ep->length); 430 mon_text_read_data(rp, &ptr, ep); 431 432 if (copy_to_user(buf, rp->printf_buf, ptr.cnt)) 433 ptr.cnt = -EFAULT; 434 mutex_unlock(&rp->printf_lock); 435 kmem_cache_free(rp->e_slab, ep); 436 return ptr.cnt; 437 } 438 439 static struct mon_event_text *mon_text_read_wait(struct mon_reader_text *rp, 440 struct file *file) 441 { 442 struct mon_bus *mbus = rp->r.m_bus; 443 DECLARE_WAITQUEUE(waita, current); 444 struct mon_event_text *ep; 445 446 add_wait_queue(&rp->wait, &waita); 447 set_current_state(TASK_INTERRUPTIBLE); 448 while ((ep = mon_text_fetch(rp, mbus)) == NULL) { 449 if (file->f_flags & O_NONBLOCK) { 450 set_current_state(TASK_RUNNING); 451 remove_wait_queue(&rp->wait, &waita); 452 return ERR_PTR(-EWOULDBLOCK); 453 } 454 /* 455 * We do not count nwaiters, because ->release is supposed 456 * to be called when all openers are gone only. 457 */ 458 schedule(); 459 if (signal_pending(current)) { 460 remove_wait_queue(&rp->wait, &waita); 461 return ERR_PTR(-EINTR); 462 } 463 set_current_state(TASK_INTERRUPTIBLE); 464 } 465 set_current_state(TASK_RUNNING); 466 remove_wait_queue(&rp->wait, &waita); 467 return ep; 468 } 469 470 static void mon_text_read_head_t(struct mon_reader_text *rp, 471 struct mon_text_ptr *p, const struct mon_event_text *ep) 472 { 473 char udir, utype; 474 475 udir = (ep->is_in ? 'i' : 'o'); 476 switch (ep->xfertype) { 477 case USB_ENDPOINT_XFER_ISOC: utype = 'Z'; break; 478 case USB_ENDPOINT_XFER_INT: utype = 'I'; break; 479 case USB_ENDPOINT_XFER_CONTROL: utype = 'C'; break; 480 default: /* PIPE_BULK */ utype = 'B'; 481 } 482 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 483 "%lx %u %c %c%c:%03u:%02u", 484 ep->id, ep->tstamp, ep->type, 485 utype, udir, ep->devnum, ep->epnum); 486 } 487 488 static void mon_text_read_head_u(struct mon_reader_text *rp, 489 struct mon_text_ptr *p, const struct mon_event_text *ep) 490 { 491 char udir, utype; 492 493 udir = (ep->is_in ? 'i' : 'o'); 494 switch (ep->xfertype) { 495 case USB_ENDPOINT_XFER_ISOC: utype = 'Z'; break; 496 case USB_ENDPOINT_XFER_INT: utype = 'I'; break; 497 case USB_ENDPOINT_XFER_CONTROL: utype = 'C'; break; 498 default: /* PIPE_BULK */ utype = 'B'; 499 } 500 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 501 "%lx %u %c %c%c:%d:%03u:%u", 502 ep->id, ep->tstamp, ep->type, 503 utype, udir, ep->busnum, ep->devnum, ep->epnum); 504 } 505 506 static void mon_text_read_statset(struct mon_reader_text *rp, 507 struct mon_text_ptr *p, const struct mon_event_text *ep) 508 { 509 510 if (ep->setup_flag == 0) { /* Setup packet is present and captured */ 511 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 512 " s %02x %02x %04x %04x %04x", 513 ep->setup[0], 514 ep->setup[1], 515 (ep->setup[3] << 8) | ep->setup[2], 516 (ep->setup[5] << 8) | ep->setup[4], 517 (ep->setup[7] << 8) | ep->setup[6]); 518 } else if (ep->setup_flag != '-') { /* Unable to capture setup packet */ 519 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 520 " %c __ __ ____ ____ ____", ep->setup_flag); 521 } else { /* No setup for this kind of URB */ 522 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 523 " %d", ep->status); 524 } 525 } 526 527 static void mon_text_read_intstat(struct mon_reader_text *rp, 528 struct mon_text_ptr *p, const struct mon_event_text *ep) 529 { 530 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 531 " %d:%d", ep->status, ep->interval); 532 } 533 534 static void mon_text_read_isostat(struct mon_reader_text *rp, 535 struct mon_text_ptr *p, const struct mon_event_text *ep) 536 { 537 if (ep->type == 'S') { 538 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 539 " %d:%d:%d", ep->status, ep->interval, ep->start_frame); 540 } else { 541 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 542 " %d:%d:%d:%d", 543 ep->status, ep->interval, ep->start_frame, ep->error_count); 544 } 545 } 546 547 static void mon_text_read_isodesc(struct mon_reader_text *rp, 548 struct mon_text_ptr *p, const struct mon_event_text *ep) 549 { 550 int ndesc; /* Display this many */ 551 int i; 552 const struct mon_iso_desc *dp; 553 554 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 555 " %d", ep->numdesc); 556 ndesc = ep->numdesc; 557 if (ndesc > ISODESC_MAX) 558 ndesc = ISODESC_MAX; 559 if (ndesc < 0) 560 ndesc = 0; 561 dp = ep->isodesc; 562 for (i = 0; i < ndesc; i++) { 563 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 564 " %d:%u:%u", dp->status, dp->offset, dp->length); 565 dp++; 566 } 567 } 568 569 static void mon_text_read_data(struct mon_reader_text *rp, 570 struct mon_text_ptr *p, const struct mon_event_text *ep) 571 { 572 int data_len, i; 573 574 if ((data_len = ep->length) > 0) { 575 if (ep->data_flag == 0) { 576 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 577 " ="); 578 if (data_len >= DATA_MAX) 579 data_len = DATA_MAX; 580 for (i = 0; i < data_len; i++) { 581 if (i % 4 == 0) { 582 p->cnt += snprintf(p->pbuf + p->cnt, 583 p->limit - p->cnt, 584 " "); 585 } 586 p->cnt += snprintf(p->pbuf + p->cnt, 587 p->limit - p->cnt, 588 "%02x", ep->data[i]); 589 } 590 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 591 "\n"); 592 } else { 593 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, 594 " %c\n", ep->data_flag); 595 } 596 } else { 597 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, "\n"); 598 } 599 } 600 601 static int mon_text_release(struct inode *inode, struct file *file) 602 { 603 struct mon_reader_text *rp = file->private_data; 604 struct mon_bus *mbus; 605 /* unsigned long flags; */ 606 struct list_head *p; 607 struct mon_event_text *ep; 608 609 mutex_lock(&mon_lock); 610 mbus = inode->i_private; 611 612 if (mbus->nreaders <= 0) { 613 printk(KERN_ERR TAG ": consistency error on close\n"); 614 mutex_unlock(&mon_lock); 615 return 0; 616 } 617 mon_reader_del(mbus, &rp->r); 618 619 /* 620 * In theory, e_list is protected by mbus->lock. However, 621 * after mon_reader_del has finished, the following is the case: 622 * - we are not on reader list anymore, so new events won't be added; 623 * - whole mbus may be dropped if it was orphaned. 624 * So, we better not touch mbus. 625 */ 626 /* spin_lock_irqsave(&mbus->lock, flags); */ 627 while (!list_empty(&rp->e_list)) { 628 p = rp->e_list.next; 629 ep = list_entry(p, struct mon_event_text, e_link); 630 list_del(p); 631 --rp->nevents; 632 kmem_cache_free(rp->e_slab, ep); 633 } 634 /* spin_unlock_irqrestore(&mbus->lock, flags); */ 635 636 kmem_cache_destroy(rp->e_slab); 637 kfree(rp->printf_buf); 638 kfree(rp); 639 640 mutex_unlock(&mon_lock); 641 return 0; 642 } 643 644 static const struct file_operations mon_fops_text_t = { 645 .owner = THIS_MODULE, 646 .open = mon_text_open, 647 .llseek = no_llseek, 648 .read = mon_text_read_t, 649 .release = mon_text_release, 650 }; 651 652 static const struct file_operations mon_fops_text_u = { 653 .owner = THIS_MODULE, 654 .open = mon_text_open, 655 .llseek = no_llseek, 656 .read = mon_text_read_u, 657 .release = mon_text_release, 658 }; 659 660 int mon_text_add(struct mon_bus *mbus, const struct usb_bus *ubus) 661 { 662 struct dentry *d; 663 enum { NAMESZ = 10 }; 664 char name[NAMESZ]; 665 int busnum = ubus? ubus->busnum: 0; 666 int rc; 667 668 if (ubus != NULL) { 669 rc = snprintf(name, NAMESZ, "%dt", busnum); 670 if (rc <= 0 || rc >= NAMESZ) 671 goto err_print_t; 672 d = debugfs_create_file(name, 0600, mon_dir, mbus, 673 &mon_fops_text_t); 674 if (d == NULL) 675 goto err_create_t; 676 mbus->dent_t = d; 677 } 678 679 rc = snprintf(name, NAMESZ, "%du", busnum); 680 if (rc <= 0 || rc >= NAMESZ) 681 goto err_print_u; 682 d = debugfs_create_file(name, 0600, mon_dir, mbus, &mon_fops_text_u); 683 if (d == NULL) 684 goto err_create_u; 685 mbus->dent_u = d; 686 687 rc = snprintf(name, NAMESZ, "%ds", busnum); 688 if (rc <= 0 || rc >= NAMESZ) 689 goto err_print_s; 690 d = debugfs_create_file(name, 0600, mon_dir, mbus, &mon_fops_stat); 691 if (d == NULL) 692 goto err_create_s; 693 mbus->dent_s = d; 694 695 return 1; 696 697 err_create_s: 698 err_print_s: 699 debugfs_remove(mbus->dent_u); 700 mbus->dent_u = NULL; 701 err_create_u: 702 err_print_u: 703 if (ubus != NULL) { 704 debugfs_remove(mbus->dent_t); 705 mbus->dent_t = NULL; 706 } 707 err_create_t: 708 err_print_t: 709 return 0; 710 } 711 712 void mon_text_del(struct mon_bus *mbus) 713 { 714 debugfs_remove(mbus->dent_u); 715 if (mbus->dent_t != NULL) 716 debugfs_remove(mbus->dent_t); 717 debugfs_remove(mbus->dent_s); 718 } 719 720 /* 721 * Slab interface: constructor. 722 */ 723 static void mon_text_ctor(struct kmem_cache *slab, void *mem) 724 { 725 /* 726 * Nothing to initialize. No, really! 727 * So, we fill it with garbage to emulate a reused object. 728 */ 729 memset(mem, 0xe5, sizeof(struct mon_event_text)); 730 } 731 732 int __init mon_text_init(void) 733 { 734 struct dentry *mondir; 735 736 mondir = debugfs_create_dir("usbmon", NULL); 737 if (IS_ERR(mondir)) { 738 printk(KERN_NOTICE TAG ": debugfs is not available\n"); 739 return -ENODEV; 740 } 741 if (mondir == NULL) { 742 printk(KERN_NOTICE TAG ": unable to create usbmon directory\n"); 743 return -ENODEV; 744 } 745 mon_dir = mondir; 746 return 0; 747 } 748 749 void mon_text_exit(void) 750 { 751 debugfs_remove(mon_dir); 752 } 753