[go: nahoru, domu]

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
47struct mon_iso_desc {
48	int status;
49	unsigned int offset;
50	unsigned int length;	/* Unsigned here, signed in URB. Historic. */
51};
52
53struct 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
77struct 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
91static struct dentry *mon_dir;		/* Usually /sys/kernel/debug/usbmon */
92
93static void mon_text_ctor(void *);
94
95struct mon_text_ptr {
96	int cnt, limit;
97	char *pbuf;
98};
99
100static struct mon_event_text *
101    mon_text_read_wait(struct mon_reader_text *rp, struct file *file);
102static void mon_text_read_head_t(struct mon_reader_text *rp,
103	struct mon_text_ptr *p, const struct mon_event_text *ep);
104static void mon_text_read_head_u(struct mon_reader_text *rp,
105	struct mon_text_ptr *p, const struct mon_event_text *ep);
106static void mon_text_read_statset(struct mon_reader_text *rp,
107	struct mon_text_ptr *p, const struct mon_event_text *ep);
108static void mon_text_read_intstat(struct mon_reader_text *rp,
109	struct mon_text_ptr *p, const struct mon_event_text *ep);
110static void mon_text_read_isostat(struct mon_reader_text *rp,
111	struct mon_text_ptr *p, const struct mon_event_text *ep);
112static void mon_text_read_isodesc(struct mon_reader_text *rp,
113	struct mon_text_ptr *p, const struct mon_event_text *ep);
114static 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
126static 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
140static 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
177static 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
188static 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
254static 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
260static 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
266static 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 */
299static 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 */
319static 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);
367err_slab:
368	kfree(rp->printf_buf);
369err_alloc_pr:
370	kfree(rp);
371err_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 */
382static 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
409static 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
445static 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
476static 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
494static 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
512static 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
533static 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
540static 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
553static 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
575static 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
607static 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
650static 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
658static 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
666int 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
706err_create_s:
707err_print_s:
708	debugfs_remove(mbus->dent_u);
709	mbus->dent_u = NULL;
710err_create_u:
711err_print_u:
712	if (ubus != NULL) {
713		debugfs_remove(mbus->dent_t);
714		mbus->dent_t = NULL;
715	}
716err_create_t:
717err_print_t:
718	return 0;
719}
720
721void 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 */
732static 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
741int __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
758void mon_text_exit(void)
759{
760	debugfs_remove(mon_dir);
761}
762