blob: ddf7f9a1b3362c37178ac2cccc9f81f828d7bfcd [file] [log] [blame]
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001/*
2 * The USB Monitor, inspired by Dave Harding's USBMon.
3 *
4 * This is a binary format reader.
5 *
6 * Copyright (C) 2006 Paolo Abeni (paolo.abeni@email.it)
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07007 * Copyright (C) 2006,2007 Pete Zaitcev (zaitcev@redhat.com)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08008 */
9
10#include <linux/kernel.h>
11#include <linux/types.h>
12#include <linux/fs.h>
13#include <linux/cdev.h>
14#include <linux/usb.h>
15#include <linux/poll.h>
16#include <linux/compat.h>
17#include <linux/mm.h>
Jonathan Corbet1af46fd2008-05-16 14:23:31 -060018#include <linux/smp_lock.h>
Alan Sternb375e112009-11-06 12:32:23 -050019#include <linux/scatterlist.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Pete Zaitcev6f23ee12006-12-30 22:43:10 -080021
22#include <asm/uaccess.h>
23
24#include "usb_mon.h"
25
26/*
27 * Defined by USB 2.0 clause 9.3, table 9.2.
28 */
29#define SETUP_LEN 8
30
31/* ioctl macros */
32#define MON_IOC_MAGIC 0x92
33
34#define MON_IOCQ_URB_LEN _IO(MON_IOC_MAGIC, 1)
35/* #2 used to be MON_IOCX_URB, removed before it got into Linus tree */
36#define MON_IOCG_STATS _IOR(MON_IOC_MAGIC, 3, struct mon_bin_stats)
37#define MON_IOCT_RING_SIZE _IO(MON_IOC_MAGIC, 4)
38#define MON_IOCQ_RING_SIZE _IO(MON_IOC_MAGIC, 5)
39#define MON_IOCX_GET _IOW(MON_IOC_MAGIC, 6, struct mon_bin_get)
40#define MON_IOCX_MFETCH _IOWR(MON_IOC_MAGIC, 7, struct mon_bin_mfetch)
41#define MON_IOCH_MFLUSH _IO(MON_IOC_MAGIC, 8)
Pete Zaitcev471c6042009-02-19 22:54:45 -070042/* #9 was MON_IOCT_SETAPI */
43#define MON_IOCX_GETX _IOW(MON_IOC_MAGIC, 10, struct mon_bin_get)
Pete Zaitcev7abce6b2008-12-20 12:56:08 -070044
Pete Zaitcev6f23ee12006-12-30 22:43:10 -080045#ifdef CONFIG_COMPAT
46#define MON_IOCX_GET32 _IOW(MON_IOC_MAGIC, 6, struct mon_bin_get32)
47#define MON_IOCX_MFETCH32 _IOWR(MON_IOC_MAGIC, 7, struct mon_bin_mfetch32)
Pete Zaitcev471c6042009-02-19 22:54:45 -070048#define MON_IOCX_GETX32 _IOW(MON_IOC_MAGIC, 10, struct mon_bin_get32)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -080049#endif
50
51/*
52 * Some architectures have enormous basic pages (16KB for ia64, 64KB for ppc).
53 * But it's all right. Just use a simple way to make sure the chunk is never
54 * smaller than a page.
55 *
56 * N.B. An application does not know our chunk size.
57 *
58 * Woops, get_zeroed_page() returns a single page. I guess we're stuck with
59 * page-sized chunks for the time being.
60 */
61#define CHUNK_SIZE PAGE_SIZE
62#define CHUNK_ALIGN(x) (((x)+CHUNK_SIZE-1) & ~(CHUNK_SIZE-1))
63
64/*
65 * The magic limit was calculated so that it allows the monitoring
66 * application to pick data once in two ticks. This way, another application,
67 * which presumably drives the bus, gets to hog CPU, yet we collect our data.
68 * If HZ is 100, a 480 mbit/s bus drives 614 KB every jiffy. USB has an
69 * enormous overhead built into the bus protocol, so we need about 1000 KB.
70 *
71 * This is still too much for most cases, where we just snoop a few
72 * descriptor fetches for enumeration. So, the default is a "reasonable"
73 * amount for systems with HZ=250 and incomplete bus saturation.
74 *
75 * XXX What about multi-megabyte URBs which take minutes to transfer?
76 */
77#define BUFF_MAX CHUNK_ALIGN(1200*1024)
78#define BUFF_DFL CHUNK_ALIGN(300*1024)
79#define BUFF_MIN CHUNK_ALIGN(8*1024)
80
81/*
82 * The per-event API header (2 per URB).
83 *
84 * This structure is seen in userland as defined by the documentation.
85 */
86struct mon_bin_hdr {
87 u64 id; /* URB ID - from submission to callback */
88 unsigned char type; /* Same as in text API; extensible. */
89 unsigned char xfer_type; /* ISO, Intr, Control, Bulk */
90 unsigned char epnum; /* Endpoint number and transfer direction */
91 unsigned char devnum; /* Device address */
92 unsigned short busnum; /* Bus number */
93 char flag_setup;
94 char flag_data;
95 s64 ts_sec; /* gettimeofday */
96 s32 ts_usec; /* gettimeofday */
97 int status;
98 unsigned int len_urb; /* Length of data (submitted or actual) */
99 unsigned int len_cap; /* Delivered length */
Pete Zaitcev471c6042009-02-19 22:54:45 -0700100 union {
101 unsigned char setup[SETUP_LEN]; /* Only for Control S-type */
102 struct iso_rec {
103 int error_count;
104 int numdesc;
105 } iso;
106 } s;
107 int interval;
108 int start_frame;
109 unsigned int xfer_flags;
110 unsigned int ndesc; /* Actual number of ISO descriptors */
111};
112
113/*
114 * ISO vector, packed into the head of data stream.
115 * This has to take 16 bytes to make sure that the end of buffer
116 * wrap is not happening in the middle of a descriptor.
117 */
118struct mon_bin_isodesc {
119 int iso_status;
120 unsigned int iso_off;
121 unsigned int iso_len;
122 u32 _pad;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800123};
124
125/* per file statistic */
126struct mon_bin_stats {
127 u32 queued;
128 u32 dropped;
129};
130
131struct mon_bin_get {
Pete Zaitcev471c6042009-02-19 22:54:45 -0700132 struct mon_bin_hdr __user *hdr; /* Can be 48 bytes or 64. */
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800133 void __user *data;
134 size_t alloc; /* Length of data (can be zero) */
135};
136
137struct mon_bin_mfetch {
138 u32 __user *offvec; /* Vector of events fetched */
139 u32 nfetch; /* Number of events to fetch (out: fetched) */
140 u32 nflush; /* Number of events to flush */
141};
142
143#ifdef CONFIG_COMPAT
144struct mon_bin_get32 {
145 u32 hdr32;
146 u32 data32;
147 u32 alloc32;
148};
149
150struct mon_bin_mfetch32 {
151 u32 offvec32;
152 u32 nfetch32;
153 u32 nflush32;
154};
155#endif
156
157/* Having these two values same prevents wrapping of the mon_bin_hdr */
158#define PKT_ALIGN 64
159#define PKT_SIZE 64
160
Pete Zaitcev471c6042009-02-19 22:54:45 -0700161#define PKT_SZ_API0 48 /* API 0 (2.6.20) size */
162#define PKT_SZ_API1 64 /* API 1 size: extra fields */
163
164#define ISODESC_MAX 128 /* Same number as usbfs allows, 2048 bytes. */
165
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800166/* max number of USB bus supported */
167#define MON_BIN_MAX_MINOR 128
168
169/*
170 * The buffer: map of used pages.
171 */
172struct mon_pgmap {
173 struct page *pg;
174 unsigned char *ptr; /* XXX just use page_to_virt everywhere? */
175};
176
177/*
178 * This gets associated with an open file struct.
179 */
180struct mon_reader_bin {
181 /* The buffer: one per open. */
182 spinlock_t b_lock; /* Protect b_cnt, b_in */
183 unsigned int b_size; /* Current size of the buffer - bytes */
184 unsigned int b_cnt; /* Bytes used */
185 unsigned int b_in, b_out; /* Offsets into buffer - bytes */
186 unsigned int b_read; /* Amount of read data in curr. pkt. */
187 struct mon_pgmap *b_vec; /* The map array */
188 wait_queue_head_t b_wait; /* Wait for data here */
189
190 struct mutex fetch_lock; /* Protect b_read, b_out */
191 int mmap_active;
192
193 /* A list of these is needed for "bus 0". Some time later. */
194 struct mon_reader r;
195
196 /* Stats */
197 unsigned int cnt_lost;
198};
199
200static inline struct mon_bin_hdr *MON_OFF2HDR(const struct mon_reader_bin *rp,
201 unsigned int offset)
202{
203 return (struct mon_bin_hdr *)
204 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
205}
206
207#define MON_RING_EMPTY(rp) ((rp)->b_cnt == 0)
208
Pete Zaitcev30c74312007-08-14 00:33:40 -0700209static unsigned char xfer_to_pipe[4] = {
210 PIPE_CONTROL, PIPE_ISOCHRONOUS, PIPE_BULK, PIPE_INTERRUPT
211};
212
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -0700213static struct class *mon_bin_class;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800214static dev_t mon_bin_dev0;
215static struct cdev mon_bin_cdev;
216
217static void mon_buff_area_fill(const struct mon_reader_bin *rp,
218 unsigned int offset, unsigned int size);
219static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp);
220static int mon_alloc_buff(struct mon_pgmap *map, int npages);
221static void mon_free_buff(struct mon_pgmap *map, int npages);
222
223/*
224 * This is a "chunked memcpy". It does not manipulate any counters.
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800225 */
Alan Sternb375e112009-11-06 12:32:23 -0500226static unsigned int mon_copy_to_buff(const struct mon_reader_bin *this,
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800227 unsigned int off, const unsigned char *from, unsigned int length)
228{
229 unsigned int step_len;
230 unsigned char *buf;
231 unsigned int in_page;
232
233 while (length) {
234 /*
235 * Determine step_len.
236 */
237 step_len = length;
238 in_page = CHUNK_SIZE - (off & (CHUNK_SIZE-1));
239 if (in_page < step_len)
240 step_len = in_page;
241
242 /*
243 * Copy data and advance pointers.
244 */
245 buf = this->b_vec[off / CHUNK_SIZE].ptr + off % CHUNK_SIZE;
246 memcpy(buf, from, step_len);
247 if ((off += step_len) >= this->b_size) off = 0;
248 from += step_len;
249 length -= step_len;
250 }
Alan Sternb375e112009-11-06 12:32:23 -0500251 return off;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800252}
253
254/*
255 * This is a little worse than the above because it's "chunked copy_to_user".
256 * The return value is an error code, not an offset.
257 */
258static int copy_from_buf(const struct mon_reader_bin *this, unsigned int off,
259 char __user *to, int length)
260{
261 unsigned int step_len;
262 unsigned char *buf;
263 unsigned int in_page;
264
265 while (length) {
266 /*
267 * Determine step_len.
268 */
269 step_len = length;
270 in_page = CHUNK_SIZE - (off & (CHUNK_SIZE-1));
271 if (in_page < step_len)
272 step_len = in_page;
273
274 /*
275 * Copy data and advance pointers.
276 */
277 buf = this->b_vec[off / CHUNK_SIZE].ptr + off % CHUNK_SIZE;
278 if (copy_to_user(to, buf, step_len))
279 return -EINVAL;
280 if ((off += step_len) >= this->b_size) off = 0;
281 to += step_len;
282 length -= step_len;
283 }
284 return 0;
285}
286
287/*
288 * Allocate an (aligned) area in the buffer.
289 * This is called under b_lock.
290 * Returns ~0 on failure.
291 */
292static unsigned int mon_buff_area_alloc(struct mon_reader_bin *rp,
293 unsigned int size)
294{
295 unsigned int offset;
296
297 size = (size + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
298 if (rp->b_cnt + size > rp->b_size)
299 return ~0;
300 offset = rp->b_in;
301 rp->b_cnt += size;
302 if ((rp->b_in += size) >= rp->b_size)
303 rp->b_in -= rp->b_size;
304 return offset;
305}
306
307/*
308 * This is the same thing as mon_buff_area_alloc, only it does not allow
309 * buffers to wrap. This is needed by applications which pass references
310 * into mmap-ed buffers up their stacks (libpcap can do that).
311 *
312 * Currently, we always have the header stuck with the data, although
313 * it is not strictly speaking necessary.
314 *
315 * When a buffer would wrap, we place a filler packet to mark the space.
316 */
317static unsigned int mon_buff_area_alloc_contiguous(struct mon_reader_bin *rp,
318 unsigned int size)
319{
320 unsigned int offset;
321 unsigned int fill_size;
322
323 size = (size + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
324 if (rp->b_cnt + size > rp->b_size)
325 return ~0;
326 if (rp->b_in + size > rp->b_size) {
327 /*
328 * This would wrap. Find if we still have space after
329 * skipping to the end of the buffer. If we do, place
330 * a filler packet and allocate a new packet.
331 */
332 fill_size = rp->b_size - rp->b_in;
333 if (rp->b_cnt + size + fill_size > rp->b_size)
334 return ~0;
335 mon_buff_area_fill(rp, rp->b_in, fill_size);
336
337 offset = 0;
338 rp->b_in = size;
339 rp->b_cnt += size + fill_size;
340 } else if (rp->b_in + size == rp->b_size) {
341 offset = rp->b_in;
342 rp->b_in = 0;
343 rp->b_cnt += size;
344 } else {
345 offset = rp->b_in;
346 rp->b_in += size;
347 rp->b_cnt += size;
348 }
349 return offset;
350}
351
352/*
353 * Return a few (kilo-)bytes to the head of the buffer.
Alan Sternfca94742009-11-04 11:35:53 -0500354 * This is used if a data fetch fails.
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800355 */
356static void mon_buff_area_shrink(struct mon_reader_bin *rp, unsigned int size)
357{
358
Alan Sternfca94742009-11-04 11:35:53 -0500359 /* size &= ~(PKT_ALIGN-1); -- we're called with aligned size */
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800360 rp->b_cnt -= size;
361 if (rp->b_in < size)
362 rp->b_in += rp->b_size;
363 rp->b_in -= size;
364}
365
366/*
367 * This has to be called under both b_lock and fetch_lock, because
368 * it accesses both b_cnt and b_out.
369 */
370static void mon_buff_area_free(struct mon_reader_bin *rp, unsigned int size)
371{
372
373 size = (size + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
374 rp->b_cnt -= size;
375 if ((rp->b_out += size) >= rp->b_size)
376 rp->b_out -= rp->b_size;
377}
378
379static void mon_buff_area_fill(const struct mon_reader_bin *rp,
380 unsigned int offset, unsigned int size)
381{
382 struct mon_bin_hdr *ep;
383
384 ep = MON_OFF2HDR(rp, offset);
385 memset(ep, 0, PKT_SIZE);
386 ep->type = '@';
387 ep->len_cap = size - PKT_SIZE;
388}
389
390static inline char mon_bin_get_setup(unsigned char *setupb,
391 const struct urb *urb, char ev_type)
392{
393
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800394 if (urb->setup_packet == NULL)
395 return 'Z';
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800396 memcpy(setupb, urb->setup_packet, SETUP_LEN);
397 return 0;
398}
399
Alan Sternb375e112009-11-06 12:32:23 -0500400static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
401 unsigned int offset, struct urb *urb, unsigned int length,
402 char *flag)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800403{
Alan Sternb375e112009-11-06 12:32:23 -0500404 int i;
405 struct scatterlist *sg;
406 unsigned int this_len;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800407
Alan Sternb375e112009-11-06 12:32:23 -0500408 *flag = 0;
409 if (urb->num_sgs == 0) {
410 if (urb->transfer_buffer == NULL) {
411 *flag = 'Z';
412 return length;
413 }
414 mon_copy_to_buff(rp, offset, urb->transfer_buffer, length);
415 length = 0;
416
417 } else {
418 /* If IOMMU coalescing occurred, we cannot trust sg_page */
419 if (urb->sg->nents != urb->num_sgs) {
420 *flag = 'D';
421 return length;
422 }
423
424 /* Copy up to the first non-addressable segment */
425 for_each_sg(urb->sg->sg, sg, urb->num_sgs, i) {
426 if (length == 0 || PageHighMem(sg_page(sg)))
427 break;
428 this_len = min_t(unsigned int, sg->length, length);
429 offset = mon_copy_to_buff(rp, offset, sg_virt(sg),
430 this_len);
431 length -= this_len;
432 }
433 if (i == 0)
434 *flag = 'D';
435 }
436
437 return length;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800438}
439
Pete Zaitcev471c6042009-02-19 22:54:45 -0700440static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
441 unsigned int offset, struct urb *urb, char ev_type, unsigned int ndesc)
442{
443 struct mon_bin_isodesc *dp;
444 struct usb_iso_packet_descriptor *fp;
445
446 fp = urb->iso_frame_desc;
447 while (ndesc-- != 0) {
448 dp = (struct mon_bin_isodesc *)
449 (rp->b_vec[offset / CHUNK_SIZE].ptr + offset % CHUNK_SIZE);
450 dp->iso_status = fp->status;
451 dp->iso_off = fp->offset;
452 dp->iso_len = (ev_type == 'S') ? fp->length : fp->actual_length;
453 dp->_pad = 0;
454 if ((offset += sizeof(struct mon_bin_isodesc)) >= rp->b_size)
455 offset = 0;
456 fp++;
457 }
458}
459
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800460static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
Alan Stern9347d512007-08-24 15:41:41 -0400461 char ev_type, int status)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800462{
Pete Zaitcev30c74312007-08-14 00:33:40 -0700463 const struct usb_endpoint_descriptor *epd = &urb->ep->desc;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800464 struct timeval ts;
Pete Zaitcev2bc0d1092010-01-05 11:50:07 -0700465 unsigned long flags;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800466 unsigned int urb_length;
467 unsigned int offset;
468 unsigned int length;
Alan Sternfca94742009-11-04 11:35:53 -0500469 unsigned int delta;
Pete Zaitcev471c6042009-02-19 22:54:45 -0700470 unsigned int ndesc, lendesc;
Pete Zaitcev30c74312007-08-14 00:33:40 -0700471 unsigned char dir;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800472 struct mon_bin_hdr *ep;
473 char data_tag = 0;
474
475 do_gettimeofday(&ts);
476
477 spin_lock_irqsave(&rp->b_lock, flags);
478
479 /*
480 * Find the maximum allowable length, then allocate space.
481 */
Pete Zaitcev471c6042009-02-19 22:54:45 -0700482 if (usb_endpoint_xfer_isoc(epd)) {
483 if (urb->number_of_packets < 0) {
484 ndesc = 0;
485 } else if (urb->number_of_packets >= ISODESC_MAX) {
486 ndesc = ISODESC_MAX;
487 } else {
488 ndesc = urb->number_of_packets;
489 }
490 } else {
491 ndesc = 0;
492 }
493 lendesc = ndesc*sizeof(struct mon_bin_isodesc);
494
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800495 urb_length = (ev_type == 'S') ?
496 urb->transfer_buffer_length : urb->actual_length;
497 length = urb_length;
498
499 if (length >= rp->b_size/5)
500 length = rp->b_size/5;
501
Alan Stern18ea5d02007-07-30 17:10:36 -0400502 if (usb_urb_dir_in(urb)) {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800503 if (ev_type == 'S') {
504 length = 0;
505 data_tag = '<';
506 }
Pete Zaitcev30c74312007-08-14 00:33:40 -0700507 /* Cannot rely on endpoint number in case of control ep.0 */
508 dir = USB_DIR_IN;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800509 } else {
510 if (ev_type == 'C') {
511 length = 0;
512 data_tag = '>';
513 }
Pete Zaitcev30c74312007-08-14 00:33:40 -0700514 dir = 0;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800515 }
516
Pete Zaitcev471c6042009-02-19 22:54:45 -0700517 if (rp->mmap_active) {
518 offset = mon_buff_area_alloc_contiguous(rp,
519 length + PKT_SIZE + lendesc);
520 } else {
521 offset = mon_buff_area_alloc(rp, length + PKT_SIZE + lendesc);
522 }
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800523 if (offset == ~0) {
524 rp->cnt_lost++;
525 spin_unlock_irqrestore(&rp->b_lock, flags);
526 return;
527 }
528
529 ep = MON_OFF2HDR(rp, offset);
530 if ((offset += PKT_SIZE) >= rp->b_size) offset = 0;
531
532 /*
533 * Fill the allocated area.
534 */
535 memset(ep, 0, PKT_SIZE);
536 ep->type = ev_type;
Pete Zaitcev30c74312007-08-14 00:33:40 -0700537 ep->xfer_type = xfer_to_pipe[usb_endpoint_type(epd)];
538 ep->epnum = dir | usb_endpoint_num(epd);
Alan Stern18ea5d02007-07-30 17:10:36 -0400539 ep->devnum = urb->dev->devnum;
Pete Zaitcevecb658d2007-04-11 13:47:26 -0700540 ep->busnum = urb->dev->bus->busnum;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800541 ep->id = (unsigned long) urb;
542 ep->ts_sec = ts.tv_sec;
543 ep->ts_usec = ts.tv_usec;
Alan Stern9347d512007-08-24 15:41:41 -0400544 ep->status = status;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800545 ep->len_urb = urb_length;
Pete Zaitcev471c6042009-02-19 22:54:45 -0700546 ep->len_cap = length + lendesc;
547 ep->xfer_flags = urb->transfer_flags;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800548
Pete Zaitcev471c6042009-02-19 22:54:45 -0700549 if (usb_endpoint_xfer_int(epd)) {
550 ep->interval = urb->interval;
551 } else if (usb_endpoint_xfer_isoc(epd)) {
552 ep->interval = urb->interval;
553 ep->start_frame = urb->start_frame;
554 ep->s.iso.error_count = urb->error_count;
555 ep->s.iso.numdesc = urb->number_of_packets;
556 }
557
558 if (usb_endpoint_xfer_control(epd) && ev_type == 'S') {
559 ep->flag_setup = mon_bin_get_setup(ep->s.setup, urb, ev_type);
560 } else {
561 ep->flag_setup = '-';
562 }
563
564 if (ndesc != 0) {
565 ep->ndesc = ndesc;
566 mon_bin_get_isodesc(rp, offset, urb, ev_type, ndesc);
567 if ((offset += lendesc) >= rp->b_size)
568 offset -= rp->b_size;
569 }
570
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800571 if (length != 0) {
Alan Sternb375e112009-11-06 12:32:23 -0500572 length = mon_bin_get_data(rp, offset, urb, length,
573 &ep->flag_data);
574 if (length > 0) {
Alan Sternfca94742009-11-04 11:35:53 -0500575 delta = (ep->len_cap + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
576 ep->len_cap -= length;
577 delta -= (ep->len_cap + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
578 mon_buff_area_shrink(rp, delta);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800579 }
580 } else {
581 ep->flag_data = data_tag;
582 }
583
584 spin_unlock_irqrestore(&rp->b_lock, flags);
585
586 wake_up(&rp->b_wait);
587}
588
589static void mon_bin_submit(void *data, struct urb *urb)
590{
591 struct mon_reader_bin *rp = data;
Alan Stern9347d512007-08-24 15:41:41 -0400592 mon_bin_event(rp, urb, 'S', -EINPROGRESS);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800593}
594
Alan Stern9347d512007-08-24 15:41:41 -0400595static void mon_bin_complete(void *data, struct urb *urb, int status)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800596{
597 struct mon_reader_bin *rp = data;
Alan Stern9347d512007-08-24 15:41:41 -0400598 mon_bin_event(rp, urb, 'C', status);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800599}
600
601static void mon_bin_error(void *data, struct urb *urb, int error)
602{
603 struct mon_reader_bin *rp = data;
Pete Zaitcev2bc0d1092010-01-05 11:50:07 -0700604 struct timeval ts;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800605 unsigned long flags;
606 unsigned int offset;
607 struct mon_bin_hdr *ep;
608
Pete Zaitcev2bc0d1092010-01-05 11:50:07 -0700609 do_gettimeofday(&ts);
610
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800611 spin_lock_irqsave(&rp->b_lock, flags);
612
613 offset = mon_buff_area_alloc(rp, PKT_SIZE);
614 if (offset == ~0) {
615 /* Not incrementing cnt_lost. Just because. */
616 spin_unlock_irqrestore(&rp->b_lock, flags);
617 return;
618 }
619
620 ep = MON_OFF2HDR(rp, offset);
621
622 memset(ep, 0, PKT_SIZE);
623 ep->type = 'E';
Pete Zaitcev30c74312007-08-14 00:33:40 -0700624 ep->xfer_type = xfer_to_pipe[usb_endpoint_type(&urb->ep->desc)];
625 ep->epnum = usb_urb_dir_in(urb) ? USB_DIR_IN : 0;
626 ep->epnum |= usb_endpoint_num(&urb->ep->desc);
Alan Stern18ea5d02007-07-30 17:10:36 -0400627 ep->devnum = urb->dev->devnum;
Pete Zaitcevecb658d2007-04-11 13:47:26 -0700628 ep->busnum = urb->dev->bus->busnum;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800629 ep->id = (unsigned long) urb;
Pete Zaitcev2bc0d1092010-01-05 11:50:07 -0700630 ep->ts_sec = ts.tv_sec;
631 ep->ts_usec = ts.tv_usec;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800632 ep->status = error;
633
634 ep->flag_setup = '-';
635 ep->flag_data = 'E';
636
637 spin_unlock_irqrestore(&rp->b_lock, flags);
638
639 wake_up(&rp->b_wait);
640}
641
642static int mon_bin_open(struct inode *inode, struct file *file)
643{
644 struct mon_bus *mbus;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800645 struct mon_reader_bin *rp;
646 size_t size;
647 int rc;
648
Jonathan Corbet1af46fd2008-05-16 14:23:31 -0600649 lock_kernel();
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800650 mutex_lock(&mon_lock);
651 if ((mbus = mon_bus_lookup(iminor(inode))) == NULL) {
652 mutex_unlock(&mon_lock);
Jonathan Corbet1af46fd2008-05-16 14:23:31 -0600653 unlock_kernel();
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800654 return -ENODEV;
655 }
Pete Zaitcevecb658d2007-04-11 13:47:26 -0700656 if (mbus != &mon_bus0 && mbus->u_bus == NULL) {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800657 printk(KERN_ERR TAG ": consistency error on open\n");
658 mutex_unlock(&mon_lock);
Jonathan Corbet1af46fd2008-05-16 14:23:31 -0600659 unlock_kernel();
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800660 return -ENODEV;
661 }
662
663 rp = kzalloc(sizeof(struct mon_reader_bin), GFP_KERNEL);
664 if (rp == NULL) {
665 rc = -ENOMEM;
666 goto err_alloc;
667 }
668 spin_lock_init(&rp->b_lock);
669 init_waitqueue_head(&rp->b_wait);
670 mutex_init(&rp->fetch_lock);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800671 rp->b_size = BUFF_DFL;
672
673 size = sizeof(struct mon_pgmap) * (rp->b_size/CHUNK_SIZE);
674 if ((rp->b_vec = kzalloc(size, GFP_KERNEL)) == NULL) {
675 rc = -ENOMEM;
676 goto err_allocvec;
677 }
678
679 if ((rc = mon_alloc_buff(rp->b_vec, rp->b_size/CHUNK_SIZE)) < 0)
680 goto err_allocbuff;
681
682 rp->r.m_bus = mbus;
683 rp->r.r_data = rp;
684 rp->r.rnf_submit = mon_bin_submit;
685 rp->r.rnf_error = mon_bin_error;
686 rp->r.rnf_complete = mon_bin_complete;
687
688 mon_reader_add(mbus, &rp->r);
689
690 file->private_data = rp;
691 mutex_unlock(&mon_lock);
Jonathan Corbet1af46fd2008-05-16 14:23:31 -0600692 unlock_kernel();
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800693 return 0;
694
695err_allocbuff:
696 kfree(rp->b_vec);
697err_allocvec:
698 kfree(rp);
699err_alloc:
700 mutex_unlock(&mon_lock);
Jonathan Corbet1af46fd2008-05-16 14:23:31 -0600701 unlock_kernel();
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800702 return rc;
703}
704
705/*
706 * Extract an event from buffer and copy it to user space.
707 * Wait if there is no event ready.
708 * Returns zero or error.
709 */
710static int mon_bin_get_event(struct file *file, struct mon_reader_bin *rp,
Pete Zaitcev471c6042009-02-19 22:54:45 -0700711 struct mon_bin_hdr __user *hdr, unsigned int hdrbytes,
712 void __user *data, unsigned int nbytes)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800713{
714 unsigned long flags;
715 struct mon_bin_hdr *ep;
716 size_t step_len;
717 unsigned int offset;
718 int rc;
719
720 mutex_lock(&rp->fetch_lock);
721
722 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
723 mutex_unlock(&rp->fetch_lock);
724 return rc;
725 }
726
727 ep = MON_OFF2HDR(rp, rp->b_out);
728
Pete Zaitcev471c6042009-02-19 22:54:45 -0700729 if (copy_to_user(hdr, ep, hdrbytes)) {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800730 mutex_unlock(&rp->fetch_lock);
731 return -EFAULT;
732 }
733
734 step_len = min(ep->len_cap, nbytes);
735 if ((offset = rp->b_out + PKT_SIZE) >= rp->b_size) offset = 0;
736
737 if (copy_from_buf(rp, offset, data, step_len)) {
738 mutex_unlock(&rp->fetch_lock);
739 return -EFAULT;
740 }
741
742 spin_lock_irqsave(&rp->b_lock, flags);
743 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
744 spin_unlock_irqrestore(&rp->b_lock, flags);
745 rp->b_read = 0;
746
747 mutex_unlock(&rp->fetch_lock);
748 return 0;
749}
750
751static int mon_bin_release(struct inode *inode, struct file *file)
752{
753 struct mon_reader_bin *rp = file->private_data;
754 struct mon_bus* mbus = rp->r.m_bus;
755
756 mutex_lock(&mon_lock);
757
758 if (mbus->nreaders <= 0) {
759 printk(KERN_ERR TAG ": consistency error on close\n");
760 mutex_unlock(&mon_lock);
761 return 0;
762 }
763 mon_reader_del(mbus, &rp->r);
764
765 mon_free_buff(rp->b_vec, rp->b_size/CHUNK_SIZE);
766 kfree(rp->b_vec);
767 kfree(rp);
768
769 mutex_unlock(&mon_lock);
770 return 0;
771}
772
773static ssize_t mon_bin_read(struct file *file, char __user *buf,
774 size_t nbytes, loff_t *ppos)
775{
776 struct mon_reader_bin *rp = file->private_data;
Pete Zaitcev471c6042009-02-19 22:54:45 -0700777 unsigned int hdrbytes = PKT_SZ_API0;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800778 unsigned long flags;
779 struct mon_bin_hdr *ep;
780 unsigned int offset;
781 size_t step_len;
782 char *ptr;
783 ssize_t done = 0;
784 int rc;
785
786 mutex_lock(&rp->fetch_lock);
787
788 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
789 mutex_unlock(&rp->fetch_lock);
790 return rc;
791 }
792
793 ep = MON_OFF2HDR(rp, rp->b_out);
794
Pete Zaitcev471c6042009-02-19 22:54:45 -0700795 if (rp->b_read < hdrbytes) {
796 step_len = min(nbytes, (size_t)(hdrbytes - rp->b_read));
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800797 ptr = ((char *)ep) + rp->b_read;
798 if (step_len && copy_to_user(buf, ptr, step_len)) {
799 mutex_unlock(&rp->fetch_lock);
800 return -EFAULT;
801 }
802 nbytes -= step_len;
803 buf += step_len;
804 rp->b_read += step_len;
805 done += step_len;
806 }
807
Pete Zaitcev471c6042009-02-19 22:54:45 -0700808 if (rp->b_read >= hdrbytes) {
Pete Zaitcevf1c0a2a2008-11-14 09:47:41 -0700809 step_len = ep->len_cap;
Pete Zaitcev471c6042009-02-19 22:54:45 -0700810 step_len -= rp->b_read - hdrbytes;
Pete Zaitcevf1c0a2a2008-11-14 09:47:41 -0700811 if (step_len > nbytes)
812 step_len = nbytes;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800813 offset = rp->b_out + PKT_SIZE;
Pete Zaitcev471c6042009-02-19 22:54:45 -0700814 offset += rp->b_read - hdrbytes;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800815 if (offset >= rp->b_size)
816 offset -= rp->b_size;
817 if (copy_from_buf(rp, offset, buf, step_len)) {
818 mutex_unlock(&rp->fetch_lock);
819 return -EFAULT;
820 }
821 nbytes -= step_len;
822 buf += step_len;
823 rp->b_read += step_len;
824 done += step_len;
825 }
826
827 /*
828 * Check if whole packet was read, and if so, jump to the next one.
829 */
Pete Zaitcev471c6042009-02-19 22:54:45 -0700830 if (rp->b_read >= hdrbytes + ep->len_cap) {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -0800831 spin_lock_irqsave(&rp->b_lock, flags);
832 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
833 spin_unlock_irqrestore(&rp->b_lock, flags);
834 rp->b_read = 0;
835 }
836
837 mutex_unlock(&rp->fetch_lock);
838 return done;
839}
840
841/*
842 * Remove at most nevents from chunked buffer.
843 * Returns the number of removed events.
844 */
845static int mon_bin_flush(struct mon_reader_bin *rp, unsigned nevents)
846{
847 unsigned long flags;
848 struct mon_bin_hdr *ep;
849 int i;
850
851 mutex_lock(&rp->fetch_lock);
852 spin_lock_irqsave(&rp->b_lock, flags);
853 for (i = 0; i < nevents; ++i) {
854 if (MON_RING_EMPTY(rp))
855 break;
856
857 ep = MON_OFF2HDR(rp, rp->b_out);
858 mon_buff_area_free(rp, PKT_SIZE + ep->len_cap);
859 }
860 spin_unlock_irqrestore(&rp->b_lock, flags);
861 rp->b_read = 0;
862 mutex_unlock(&rp->fetch_lock);
863 return i;
864}
865
866/*
867 * Fetch at most max event offsets into the buffer and put them into vec.
868 * The events are usually freed later with mon_bin_flush.
869 * Return the effective number of events fetched.
870 */
871static int mon_bin_fetch(struct file *file, struct mon_reader_bin *rp,
872 u32 __user *vec, unsigned int max)
873{
874 unsigned int cur_out;
875 unsigned int bytes, avail;
876 unsigned int size;
877 unsigned int nevents;
878 struct mon_bin_hdr *ep;
879 unsigned long flags;
880 int rc;
881
882 mutex_lock(&rp->fetch_lock);
883
884 if ((rc = mon_bin_wait_event(file, rp)) < 0) {
885 mutex_unlock(&rp->fetch_lock);
886 return rc;
887 }
888
889 spin_lock_irqsave(&rp->b_lock, flags);
890 avail = rp->b_cnt;
891 spin_unlock_irqrestore(&rp->b_lock, flags);
892
893 cur_out = rp->b_out;
894 nevents = 0;
895 bytes = 0;
896 while (bytes < avail) {
897 if (nevents >= max)
898 break;
899
900 ep = MON_OFF2HDR(rp, cur_out);
901 if (put_user(cur_out, &vec[nevents])) {
902 mutex_unlock(&rp->fetch_lock);
903 return -EFAULT;
904 }
905
906 nevents++;
907 size = ep->len_cap + PKT_SIZE;
908 size = (size + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
909 if ((cur_out += size) >= rp->b_size)
910 cur_out -= rp->b_size;
911 bytes += size;
912 }
913
914 mutex_unlock(&rp->fetch_lock);
915 return nevents;
916}
917
918/*
919 * Count events. This is almost the same as the above mon_bin_fetch,
920 * only we do not store offsets into user vector, and we have no limit.
921 */
922static int mon_bin_queued(struct mon_reader_bin *rp)
923{
924 unsigned int cur_out;
925 unsigned int bytes, avail;
926 unsigned int size;
927 unsigned int nevents;
928 struct mon_bin_hdr *ep;
929 unsigned long flags;
930
931 mutex_lock(&rp->fetch_lock);
932
933 spin_lock_irqsave(&rp->b_lock, flags);
934 avail = rp->b_cnt;
935 spin_unlock_irqrestore(&rp->b_lock, flags);
936
937 cur_out = rp->b_out;
938 nevents = 0;
939 bytes = 0;
940 while (bytes < avail) {
941 ep = MON_OFF2HDR(rp, cur_out);
942
943 nevents++;
944 size = ep->len_cap + PKT_SIZE;
945 size = (size + PKT_ALIGN-1) & ~(PKT_ALIGN-1);
946 if ((cur_out += size) >= rp->b_size)
947 cur_out -= rp->b_size;
948 bytes += size;
949 }
950
951 mutex_unlock(&rp->fetch_lock);
952 return nevents;
953}
954
955/*
956 */
957static int mon_bin_ioctl(struct inode *inode, struct file *file,
958 unsigned int cmd, unsigned long arg)
959{
960 struct mon_reader_bin *rp = file->private_data;
961 // struct mon_bus* mbus = rp->r.m_bus;
962 int ret = 0;
963 struct mon_bin_hdr *ep;
964 unsigned long flags;
965
966 switch (cmd) {
967
968 case MON_IOCQ_URB_LEN:
969 /*
970 * N.B. This only returns the size of data, without the header.
971 */
972 spin_lock_irqsave(&rp->b_lock, flags);
973 if (!MON_RING_EMPTY(rp)) {
974 ep = MON_OFF2HDR(rp, rp->b_out);
975 ret = ep->len_cap;
976 }
977 spin_unlock_irqrestore(&rp->b_lock, flags);
978 break;
979
980 case MON_IOCQ_RING_SIZE:
981 ret = rp->b_size;
982 break;
983
984 case MON_IOCT_RING_SIZE:
985 /*
986 * Changing the buffer size will flush it's contents; the new
987 * buffer is allocated before releasing the old one to be sure
988 * the device will stay functional also in case of memory
989 * pressure.
990 */
991 {
992 int size;
993 struct mon_pgmap *vec;
994
995 if (arg < BUFF_MIN || arg > BUFF_MAX)
996 return -EINVAL;
997
998 size = CHUNK_ALIGN(arg);
999 if ((vec = kzalloc(sizeof(struct mon_pgmap) * (size/CHUNK_SIZE),
1000 GFP_KERNEL)) == NULL) {
1001 ret = -ENOMEM;
1002 break;
1003 }
1004
1005 ret = mon_alloc_buff(vec, size/CHUNK_SIZE);
1006 if (ret < 0) {
1007 kfree(vec);
1008 break;
1009 }
1010
1011 mutex_lock(&rp->fetch_lock);
1012 spin_lock_irqsave(&rp->b_lock, flags);
1013 mon_free_buff(rp->b_vec, size/CHUNK_SIZE);
1014 kfree(rp->b_vec);
1015 rp->b_vec = vec;
1016 rp->b_size = size;
1017 rp->b_read = rp->b_in = rp->b_out = rp->b_cnt = 0;
1018 rp->cnt_lost = 0;
1019 spin_unlock_irqrestore(&rp->b_lock, flags);
1020 mutex_unlock(&rp->fetch_lock);
1021 }
1022 break;
1023
1024 case MON_IOCH_MFLUSH:
1025 ret = mon_bin_flush(rp, arg);
1026 break;
1027
1028 case MON_IOCX_GET:
Pete Zaitcev471c6042009-02-19 22:54:45 -07001029 case MON_IOCX_GETX:
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001030 {
1031 struct mon_bin_get getb;
1032
1033 if (copy_from_user(&getb, (void __user *)arg,
1034 sizeof(struct mon_bin_get)))
1035 return -EFAULT;
1036
1037 if (getb.alloc > 0x10000000) /* Want to cast to u32 */
1038 return -EINVAL;
Pete Zaitcev471c6042009-02-19 22:54:45 -07001039 ret = mon_bin_get_event(file, rp, getb.hdr,
1040 (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1,
1041 getb.data, (unsigned int)getb.alloc);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001042 }
1043 break;
1044
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001045 case MON_IOCX_MFETCH:
1046 {
1047 struct mon_bin_mfetch mfetch;
1048 struct mon_bin_mfetch __user *uptr;
1049
1050 uptr = (struct mon_bin_mfetch __user *)arg;
1051
1052 if (copy_from_user(&mfetch, uptr, sizeof(mfetch)))
1053 return -EFAULT;
1054
1055 if (mfetch.nflush) {
1056 ret = mon_bin_flush(rp, mfetch.nflush);
1057 if (ret < 0)
1058 return ret;
1059 if (put_user(ret, &uptr->nflush))
1060 return -EFAULT;
1061 }
1062 ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch);
1063 if (ret < 0)
1064 return ret;
1065 if (put_user(ret, &uptr->nfetch))
1066 return -EFAULT;
1067 ret = 0;
1068 }
1069 break;
1070
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001071 case MON_IOCG_STATS: {
1072 struct mon_bin_stats __user *sp;
1073 unsigned int nevents;
1074 unsigned int ndropped;
1075
1076 spin_lock_irqsave(&rp->b_lock, flags);
1077 ndropped = rp->cnt_lost;
1078 rp->cnt_lost = 0;
1079 spin_unlock_irqrestore(&rp->b_lock, flags);
1080 nevents = mon_bin_queued(rp);
1081
1082 sp = (struct mon_bin_stats __user *)arg;
1083 if (put_user(rp->cnt_lost, &sp->dropped))
1084 return -EFAULT;
1085 if (put_user(nevents, &sp->queued))
1086 return -EFAULT;
1087
1088 }
1089 break;
1090
1091 default:
1092 return -ENOTTY;
1093 }
1094
1095 return ret;
1096}
1097
Pete Zaitcev7abce6b2008-12-20 12:56:08 -07001098#ifdef CONFIG_COMPAT
1099static long mon_bin_compat_ioctl(struct file *file,
1100 unsigned int cmd, unsigned long arg)
1101{
1102 struct mon_reader_bin *rp = file->private_data;
1103 int ret;
1104
1105 switch (cmd) {
1106
Pete Zaitcev471c6042009-02-19 22:54:45 -07001107 case MON_IOCX_GET32:
1108 case MON_IOCX_GETX32:
1109 {
Pete Zaitcev7abce6b2008-12-20 12:56:08 -07001110 struct mon_bin_get32 getb;
1111
1112 if (copy_from_user(&getb, (void __user *)arg,
1113 sizeof(struct mon_bin_get32)))
1114 return -EFAULT;
1115
Pete Zaitcev471c6042009-02-19 22:54:45 -07001116 ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32),
1117 (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1,
1118 compat_ptr(getb.data32), getb.alloc32);
Pete Zaitcev7abce6b2008-12-20 12:56:08 -07001119 if (ret < 0)
1120 return ret;
1121 }
1122 return 0;
1123
1124 case MON_IOCX_MFETCH32:
1125 {
1126 struct mon_bin_mfetch32 mfetch;
1127 struct mon_bin_mfetch32 __user *uptr;
1128
1129 uptr = (struct mon_bin_mfetch32 __user *) compat_ptr(arg);
1130
1131 if (copy_from_user(&mfetch, uptr, sizeof(mfetch)))
1132 return -EFAULT;
1133
1134 if (mfetch.nflush32) {
1135 ret = mon_bin_flush(rp, mfetch.nflush32);
1136 if (ret < 0)
1137 return ret;
1138 if (put_user(ret, &uptr->nflush32))
1139 return -EFAULT;
1140 }
1141 ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32),
1142 mfetch.nfetch32);
1143 if (ret < 0)
1144 return ret;
1145 if (put_user(ret, &uptr->nfetch32))
1146 return -EFAULT;
1147 }
1148 return 0;
1149
1150 case MON_IOCG_STATS:
1151 return mon_bin_ioctl(NULL, file, cmd,
1152 (unsigned long) compat_ptr(arg));
1153
1154 case MON_IOCQ_URB_LEN:
1155 case MON_IOCQ_RING_SIZE:
1156 case MON_IOCT_RING_SIZE:
1157 case MON_IOCH_MFLUSH:
1158 return mon_bin_ioctl(NULL, file, cmd, arg);
1159
1160 default:
1161 ;
1162 }
1163 return -ENOTTY;
1164}
1165#endif /* CONFIG_COMPAT */
1166
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001167static unsigned int
1168mon_bin_poll(struct file *file, struct poll_table_struct *wait)
1169{
1170 struct mon_reader_bin *rp = file->private_data;
1171 unsigned int mask = 0;
1172 unsigned long flags;
1173
1174 if (file->f_mode & FMODE_READ)
1175 poll_wait(file, &rp->b_wait, wait);
1176
1177 spin_lock_irqsave(&rp->b_lock, flags);
1178 if (!MON_RING_EMPTY(rp))
1179 mask |= POLLIN | POLLRDNORM; /* readable */
1180 spin_unlock_irqrestore(&rp->b_lock, flags);
1181 return mask;
1182}
1183
1184/*
1185 * open and close: just keep track of how many times the device is
1186 * mapped, to use the proper memory allocation function.
1187 */
1188static void mon_bin_vma_open(struct vm_area_struct *vma)
1189{
1190 struct mon_reader_bin *rp = vma->vm_private_data;
1191 rp->mmap_active++;
1192}
1193
1194static void mon_bin_vma_close(struct vm_area_struct *vma)
1195{
1196 struct mon_reader_bin *rp = vma->vm_private_data;
1197 rp->mmap_active--;
1198}
1199
1200/*
1201 * Map ring pages to user space.
1202 */
Nick Piggin041509d2007-12-13 16:15:35 -08001203static int mon_bin_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001204{
1205 struct mon_reader_bin *rp = vma->vm_private_data;
1206 unsigned long offset, chunk_idx;
1207 struct page *pageptr;
1208
Nick Piggin041509d2007-12-13 16:15:35 -08001209 offset = vmf->pgoff << PAGE_SHIFT;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001210 if (offset >= rp->b_size)
Nick Piggin041509d2007-12-13 16:15:35 -08001211 return VM_FAULT_SIGBUS;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001212 chunk_idx = offset / CHUNK_SIZE;
1213 pageptr = rp->b_vec[chunk_idx].pg;
1214 get_page(pageptr);
Nick Piggin041509d2007-12-13 16:15:35 -08001215 vmf->page = pageptr;
1216 return 0;
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001217}
1218
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04001219static const struct vm_operations_struct mon_bin_vm_ops = {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001220 .open = mon_bin_vma_open,
1221 .close = mon_bin_vma_close,
Nick Piggin041509d2007-12-13 16:15:35 -08001222 .fault = mon_bin_vma_fault,
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001223};
1224
Pete Zaitcev454459b2008-03-19 22:29:51 -07001225static int mon_bin_mmap(struct file *filp, struct vm_area_struct *vma)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001226{
Nick Piggin041509d2007-12-13 16:15:35 -08001227 /* don't do anything here: "fault" will set up page table entries */
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001228 vma->vm_ops = &mon_bin_vm_ops;
1229 vma->vm_flags |= VM_RESERVED;
1230 vma->vm_private_data = filp->private_data;
1231 mon_bin_vma_open(vma);
1232 return 0;
1233}
1234
Jan Engelhardt0b3f5fe2008-01-22 20:51:11 +01001235static const struct file_operations mon_fops_binary = {
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001236 .owner = THIS_MODULE,
1237 .open = mon_bin_open,
1238 .llseek = no_llseek,
1239 .read = mon_bin_read,
1240 /* .write = mon_text_write, */
1241 .poll = mon_bin_poll,
1242 .ioctl = mon_bin_ioctl,
Pete Zaitcev7abce6b2008-12-20 12:56:08 -07001243#ifdef CONFIG_COMPAT
1244 .compat_ioctl = mon_bin_compat_ioctl,
1245#endif
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001246 .release = mon_bin_release,
Pete Zaitcev454459b2008-03-19 22:29:51 -07001247 .mmap = mon_bin_mmap,
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001248};
1249
1250static int mon_bin_wait_event(struct file *file, struct mon_reader_bin *rp)
1251{
1252 DECLARE_WAITQUEUE(waita, current);
1253 unsigned long flags;
1254
1255 add_wait_queue(&rp->b_wait, &waita);
1256 set_current_state(TASK_INTERRUPTIBLE);
1257
1258 spin_lock_irqsave(&rp->b_lock, flags);
1259 while (MON_RING_EMPTY(rp)) {
1260 spin_unlock_irqrestore(&rp->b_lock, flags);
1261
1262 if (file->f_flags & O_NONBLOCK) {
1263 set_current_state(TASK_RUNNING);
1264 remove_wait_queue(&rp->b_wait, &waita);
1265 return -EWOULDBLOCK; /* Same as EAGAIN in Linux */
1266 }
1267 schedule();
1268 if (signal_pending(current)) {
1269 remove_wait_queue(&rp->b_wait, &waita);
1270 return -EINTR;
1271 }
1272 set_current_state(TASK_INTERRUPTIBLE);
1273
1274 spin_lock_irqsave(&rp->b_lock, flags);
1275 }
1276 spin_unlock_irqrestore(&rp->b_lock, flags);
1277
1278 set_current_state(TASK_RUNNING);
1279 remove_wait_queue(&rp->b_wait, &waita);
1280 return 0;
1281}
1282
1283static int mon_alloc_buff(struct mon_pgmap *map, int npages)
1284{
1285 int n;
1286 unsigned long vaddr;
1287
1288 for (n = 0; n < npages; n++) {
1289 vaddr = get_zeroed_page(GFP_KERNEL);
1290 if (vaddr == 0) {
1291 while (n-- != 0)
1292 free_page((unsigned long) map[n].ptr);
1293 return -ENOMEM;
1294 }
1295 map[n].ptr = (unsigned char *) vaddr;
Kevin Cernekee5bfd7562009-07-05 12:08:19 -07001296 map[n].pg = virt_to_page((void *) vaddr);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001297 }
1298 return 0;
1299}
1300
1301static void mon_free_buff(struct mon_pgmap *map, int npages)
1302{
1303 int n;
1304
1305 for (n = 0; n < npages; n++)
1306 free_page((unsigned long) map[n].ptr);
1307}
1308
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07001309int mon_bin_add(struct mon_bus *mbus, const struct usb_bus *ubus)
1310{
1311 struct device *dev;
1312 unsigned minor = ubus? ubus->busnum: 0;
1313
1314 if (minor >= MON_BIN_MAX_MINOR)
1315 return 0;
1316
Greg Kroah-Hartmanb0b090e2008-07-21 20:03:34 -07001317 dev = device_create(mon_bin_class, ubus ? ubus->controller : NULL,
1318 MKDEV(MAJOR(mon_bin_dev0), minor), NULL,
1319 "usbmon%d", minor);
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07001320 if (IS_ERR(dev))
1321 return 0;
1322
1323 mbus->classdev = dev;
1324 return 1;
1325}
1326
1327void mon_bin_del(struct mon_bus *mbus)
1328{
1329 device_destroy(mon_bin_class, mbus->classdev->devt);
1330}
1331
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001332int __init mon_bin_init(void)
1333{
1334 int rc;
1335
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07001336 mon_bin_class = class_create(THIS_MODULE, "usbmon");
1337 if (IS_ERR(mon_bin_class)) {
1338 rc = PTR_ERR(mon_bin_class);
1339 goto err_class;
1340 }
1341
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001342 rc = alloc_chrdev_region(&mon_bin_dev0, 0, MON_BIN_MAX_MINOR, "usbmon");
1343 if (rc < 0)
1344 goto err_dev;
1345
1346 cdev_init(&mon_bin_cdev, &mon_fops_binary);
1347 mon_bin_cdev.owner = THIS_MODULE;
1348
1349 rc = cdev_add(&mon_bin_cdev, mon_bin_dev0, MON_BIN_MAX_MINOR);
1350 if (rc < 0)
1351 goto err_add;
1352
1353 return 0;
1354
1355err_add:
1356 unregister_chrdev_region(mon_bin_dev0, MON_BIN_MAX_MINOR);
1357err_dev:
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07001358 class_destroy(mon_bin_class);
1359err_class:
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001360 return rc;
1361}
1362
Pete Zaitcev21641e32007-02-20 10:37:52 -08001363void mon_bin_exit(void)
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001364{
1365 cdev_del(&mon_bin_cdev);
1366 unregister_chrdev_region(mon_bin_dev0, MON_BIN_MAX_MINOR);
Pete Zaitcevce7cd137f2007-05-03 16:51:16 -07001367 class_destroy(mon_bin_class);
Pete Zaitcev6f23ee12006-12-30 22:43:10 -08001368}