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