Branch data Line data Source code
1 : : /*****************************************************************************/
2 : :
3 : : /*
4 : : * devio.c -- User space communication with USB devices.
5 : : *
6 : : * Copyright (C) 1999-2000 Thomas Sailer (sailer@ife.ee.ethz.ch)
7 : : *
8 : : * This program is free software; you can redistribute it and/or modify
9 : : * it under the terms of the GNU General Public License as published by
10 : : * the Free Software Foundation; either version 2 of the License, or
11 : : * (at your option) any later version.
12 : : *
13 : : * This program is distributed in the hope that it will be useful,
14 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : : * GNU General Public License for more details.
17 : : *
18 : : * You should have received a copy of the GNU General Public License
19 : : * along with this program; if not, write to the Free Software
20 : : * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 : : *
22 : : * This file implements the usbfs/x/y files, where
23 : : * x is the bus number and y the device number.
24 : : *
25 : : * It allows user space programs/"drivers" to communicate directly
26 : : * with USB devices without intervening kernel driver.
27 : : *
28 : : * Revision history
29 : : * 22.12.1999 0.1 Initial release (split from proc_usb.c)
30 : : * 04.01.2000 0.2 Turned into its own filesystem
31 : : * 30.09.2005 0.3 Fix user-triggerable oops in async URB delivery
32 : : * (CAN-2005-3055)
33 : : */
34 : :
35 : : /*****************************************************************************/
36 : :
37 : : #include <linux/fs.h>
38 : : #include <linux/mm.h>
39 : : #include <linux/slab.h>
40 : : #include <linux/signal.h>
41 : : #include <linux/poll.h>
42 : : #include <linux/module.h>
43 : : #include <linux/string.h>
44 : : #include <linux/usb.h>
45 : : #include <linux/usbdevice_fs.h>
46 : : #include <linux/usb/hcd.h> /* for usbcore internals */
47 : : #include <linux/cdev.h>
48 : : #include <linux/notifier.h>
49 : : #include <linux/security.h>
50 : : #include <linux/user_namespace.h>
51 : : #include <linux/scatterlist.h>
52 : : #include <linux/uaccess.h>
53 : : #include <asm/byteorder.h>
54 : : #include <linux/moduleparam.h>
55 : :
56 : : #include "usb.h"
57 : :
58 : : #define USB_MAXBUS 64
59 : : #define USB_DEVICE_MAX (USB_MAXBUS * 128)
60 : : #define USB_SG_SIZE 16384 /* split-size for large txs */
61 : :
62 : : /* Mutual exclusion for removal, open, and release */
63 : : DEFINE_MUTEX(usbfs_mutex);
64 : :
65 : : struct dev_state {
66 : : struct list_head list; /* state list */
67 : : struct usb_device *dev;
68 : : struct file *file;
69 : : spinlock_t lock; /* protects the async urb lists */
70 : : struct list_head async_pending;
71 : : struct list_head async_completed;
72 : : wait_queue_head_t wait; /* wake up if a request completed */
73 : : unsigned int discsignr;
74 : : struct pid *disc_pid;
75 : : const struct cred *cred;
76 : : void __user *disccontext;
77 : : unsigned long ifclaimed;
78 : : u32 secid;
79 : : u32 disabled_bulk_eps;
80 : : };
81 : :
82 : : struct async {
83 : : struct list_head asynclist;
84 : : struct dev_state *ps;
85 : : struct pid *pid;
86 : : const struct cred *cred;
87 : : unsigned int signr;
88 : : unsigned int ifnum;
89 : : void __user *userbuffer;
90 : : void __user *userurb;
91 : : struct urb *urb;
92 : : unsigned int mem_usage;
93 : : int status;
94 : : u32 secid;
95 : : u8 bulk_addr;
96 : : u8 bulk_status;
97 : : };
98 : :
99 : : static bool usbfs_snoop;
100 : : module_param(usbfs_snoop, bool, S_IRUGO | S_IWUSR);
101 : : MODULE_PARM_DESC(usbfs_snoop, "true to log all usbfs traffic");
102 : :
103 : : #define snoop(dev, format, arg...) \
104 : : do { \
105 : : if (usbfs_snoop) \
106 : : dev_info(dev , format , ## arg); \
107 : : } while (0)
108 : :
109 : : enum snoop_when {
110 : : SUBMIT, COMPLETE
111 : : };
112 : :
113 : : #define USB_DEVICE_DEV MKDEV(USB_DEVICE_MAJOR, 0)
114 : :
115 : : /* Limit on the total amount of memory we can allocate for transfers */
116 : : static unsigned usbfs_memory_mb = 16;
117 : : module_param(usbfs_memory_mb, uint, 0644);
118 : : MODULE_PARM_DESC(usbfs_memory_mb,
119 : : "maximum MB allowed for usbfs buffers (0 = no limit)");
120 : :
121 : : /* Hard limit, necessary to avoid arithmetic overflow */
122 : : #define USBFS_XFER_MAX (UINT_MAX / 2 - 1000000)
123 : :
124 : : static atomic_t usbfs_memory_usage; /* Total memory currently allocated */
125 : :
126 : : /* Check whether it's okay to allocate more memory for a transfer */
127 : 0 : static int usbfs_increase_memory_usage(unsigned amount)
128 : : {
129 : : unsigned lim;
130 : :
131 : : /*
132 : : * Convert usbfs_memory_mb to bytes, avoiding overflows.
133 : : * 0 means use the hard limit (effectively unlimited).
134 : : */
135 : 0 : lim = ACCESS_ONCE(usbfs_memory_mb);
136 [ # # ]: 0 : if (lim == 0 || lim > (USBFS_XFER_MAX >> 20))
137 : : lim = USBFS_XFER_MAX;
138 : : else
139 : 0 : lim <<= 20;
140 : :
141 : 0 : atomic_add(amount, &usbfs_memory_usage);
142 [ # # ]: 0 : if (atomic_read(&usbfs_memory_usage) <= lim)
143 : : return 0;
144 : : atomic_sub(amount, &usbfs_memory_usage);
145 : 0 : return -ENOMEM;
146 : : }
147 : :
148 : : /* Memory for a transfer is being deallocated */
149 : : static void usbfs_decrease_memory_usage(unsigned amount)
150 : : {
151 : 0 : atomic_sub(amount, &usbfs_memory_usage);
152 : : }
153 : :
154 : : static int connected(struct dev_state *ps)
155 : : {
156 [ # # ][ # # ]: 0 : return (!list_empty(&ps->list) &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
157 : 0 : ps->dev->state != USB_STATE_NOTATTACHED);
158 : : }
159 : :
160 : 0 : static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
161 : : {
162 : : loff_t ret;
163 : :
164 : 0 : mutex_lock(&file_inode(file)->i_mutex);
165 : :
166 [ # # # ]: 0 : switch (orig) {
167 : : case 0:
168 : 0 : file->f_pos = offset;
169 : : ret = file->f_pos;
170 : 0 : break;
171 : : case 1:
172 : 0 : file->f_pos += offset;
173 : : ret = file->f_pos;
174 : 0 : break;
175 : : case 2:
176 : : default:
177 : : ret = -EINVAL;
178 : : }
179 : :
180 : 0 : mutex_unlock(&file_inode(file)->i_mutex);
181 : 0 : return ret;
182 : : }
183 : :
184 : 0 : static ssize_t usbdev_read(struct file *file, char __user *buf, size_t nbytes,
185 : : loff_t *ppos)
186 : : {
187 : 0 : struct dev_state *ps = file->private_data;
188 : 0 : struct usb_device *dev = ps->dev;
189 : : ssize_t ret = 0;
190 : : unsigned len;
191 : : loff_t pos;
192 : : int i;
193 : :
194 : 0 : pos = *ppos;
195 : : usb_lock_device(dev);
196 [ # # ]: 0 : if (!connected(ps)) {
197 : : ret = -ENODEV;
198 : : goto err;
199 [ # # ]: 0 : } else if (pos < 0) {
200 : : ret = -EINVAL;
201 : : goto err;
202 : : }
203 : :
204 [ # # ]: 0 : if (pos < sizeof(struct usb_device_descriptor)) {
205 : : /* 18 bytes - fits on the stack */
206 : : struct usb_device_descriptor temp_desc;
207 : :
208 : 0 : memcpy(&temp_desc, &dev->descriptor, sizeof(dev->descriptor));
209 : : le16_to_cpus(&temp_desc.bcdUSB);
210 : : le16_to_cpus(&temp_desc.idVendor);
211 : : le16_to_cpus(&temp_desc.idProduct);
212 : : le16_to_cpus(&temp_desc.bcdDevice);
213 : :
214 : 0 : len = sizeof(struct usb_device_descriptor) - pos;
215 [ # # ]: 0 : if (len > nbytes)
216 : : len = nbytes;
217 [ # # ]: 0 : if (copy_to_user(buf, ((char *)&temp_desc) + pos, len)) {
218 : : ret = -EFAULT;
219 : 0 : goto err;
220 : : }
221 : :
222 : 0 : *ppos += len;
223 : 0 : buf += len;
224 : 0 : nbytes -= len;
225 : 0 : ret += len;
226 : : }
227 : :
228 : : pos = sizeof(struct usb_device_descriptor);
229 [ # # ][ # # ]: 0 : for (i = 0; nbytes && i < dev->descriptor.bNumConfigurations; i++) {
230 : 0 : struct usb_config_descriptor *config =
231 : 0 : (struct usb_config_descriptor *)dev->rawdescriptors[i];
232 : 0 : unsigned int length = le16_to_cpu(config->wTotalLength);
233 : :
234 [ # # ]: 0 : if (*ppos < pos + length) {
235 : :
236 : : /* The descriptor may claim to be longer than it
237 : : * really is. Here is the actual allocated length. */
238 : 0 : unsigned alloclen =
239 : 0 : le16_to_cpu(dev->config[i].desc.wTotalLength);
240 : :
241 : 0 : len = length - (*ppos - pos);
242 [ # # ]: 0 : if (len > nbytes)
243 : : len = nbytes;
244 : :
245 : : /* Simply don't write (skip over) unallocated parts */
246 [ # # ]: 0 : if (alloclen > (*ppos - pos)) {
247 : 0 : alloclen -= (*ppos - pos);
248 [ # # ]: 0 : if (copy_to_user(buf,
249 : 0 : dev->rawdescriptors[i] + (*ppos - pos),
250 : 0 : min(len, alloclen))) {
251 : : ret = -EFAULT;
252 : : goto err;
253 : : }
254 : : }
255 : :
256 : 0 : *ppos += len;
257 : 0 : buf += len;
258 : 0 : nbytes -= len;
259 : 0 : ret += len;
260 : : }
261 : :
262 : : pos += length;
263 : : }
264 : :
265 : : err:
266 : : usb_unlock_device(dev);
267 : 0 : return ret;
268 : : }
269 : :
270 : : /*
271 : : * async list handling
272 : : */
273 : :
274 : 0 : static struct async *alloc_async(unsigned int numisoframes)
275 : : {
276 : : struct async *as;
277 : :
278 : : as = kzalloc(sizeof(struct async), GFP_KERNEL);
279 [ # # ]: 0 : if (!as)
280 : : return NULL;
281 : 0 : as->urb = usb_alloc_urb(numisoframes, GFP_KERNEL);
282 [ # # ]: 0 : if (!as->urb) {
283 : 0 : kfree(as);
284 : 0 : return NULL;
285 : : }
286 : : return as;
287 : : }
288 : :
289 : 0 : static void free_async(struct async *as)
290 : : {
291 : : int i;
292 : :
293 : 0 : put_pid(as->pid);
294 [ # # ]: 0 : if (as->cred)
295 : : put_cred(as->cred);
296 [ # # ]: 0 : for (i = 0; i < as->urb->num_sgs; i++) {
297 [ # # ]: 0 : if (sg_page(&as->urb->sg[i]))
298 : 0 : kfree(sg_virt(&as->urb->sg[i]));
299 : : }
300 : 0 : kfree(as->urb->sg);
301 : 0 : kfree(as->urb->transfer_buffer);
302 : 0 : kfree(as->urb->setup_packet);
303 : 0 : usb_free_urb(as->urb);
304 : 0 : usbfs_decrease_memory_usage(as->mem_usage);
305 : 0 : kfree(as);
306 : 0 : }
307 : :
308 : 0 : static void async_newpending(struct async *as)
309 : : {
310 : 0 : struct dev_state *ps = as->ps;
311 : : unsigned long flags;
312 : :
313 : 0 : spin_lock_irqsave(&ps->lock, flags);
314 : 0 : list_add_tail(&as->asynclist, &ps->async_pending);
315 : : spin_unlock_irqrestore(&ps->lock, flags);
316 : 0 : }
317 : :
318 : 0 : static void async_removepending(struct async *as)
319 : : {
320 : 0 : struct dev_state *ps = as->ps;
321 : : unsigned long flags;
322 : :
323 : 0 : spin_lock_irqsave(&ps->lock, flags);
324 : 0 : list_del_init(&as->asynclist);
325 : : spin_unlock_irqrestore(&ps->lock, flags);
326 : 0 : }
327 : :
328 : 0 : static struct async *async_getcompleted(struct dev_state *ps)
329 : : {
330 : : unsigned long flags;
331 : : struct async *as = NULL;
332 : :
333 : 0 : spin_lock_irqsave(&ps->lock, flags);
334 [ # # ]: 0 : if (!list_empty(&ps->async_completed)) {
335 : : as = list_entry(ps->async_completed.next, struct async,
336 : : asynclist);
337 : 0 : list_del_init(&as->asynclist);
338 : : }
339 : : spin_unlock_irqrestore(&ps->lock, flags);
340 : 0 : return as;
341 : : }
342 : :
343 : : static struct async *async_getpending(struct dev_state *ps,
344 : : void __user *userurb)
345 : : {
346 : : struct async *as;
347 : :
348 [ # # ]: 0 : list_for_each_entry(as, &ps->async_pending, asynclist)
349 [ # # ]: 0 : if (as->userurb == userurb) {
350 : : list_del_init(&as->asynclist);
351 : : return as;
352 : : }
353 : :
354 : : return NULL;
355 : : }
356 : :
357 : 0 : static void snoop_urb(struct usb_device *udev,
358 : : void __user *userurb, int pipe, unsigned length,
359 : : int timeout_or_status, enum snoop_when when,
360 : : unsigned char *data, unsigned data_len)
361 : : {
362 : : static const char *types[] = {"isoc", "int", "ctrl", "bulk"};
363 : : static const char *dirs[] = {"out", "in"};
364 : : int ep;
365 : : const char *t, *d;
366 : :
367 [ # # ]: 0 : if (!usbfs_snoop)
368 : 0 : return;
369 : :
370 : 0 : ep = usb_pipeendpoint(pipe);
371 : 0 : t = types[usb_pipetype(pipe)];
372 : 0 : d = dirs[!!usb_pipein(pipe)];
373 : :
374 [ # # ]: 0 : if (userurb) { /* Async */
375 [ # # ]: 0 : if (when == SUBMIT)
376 : 0 : dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
377 : : "length %u\n",
378 : : userurb, ep, t, d, length);
379 : : else
380 : 0 : dev_info(&udev->dev, "userurb %p, ep%d %s-%s, "
381 : : "actual_length %u status %d\n",
382 : : userurb, ep, t, d, length,
383 : : timeout_or_status);
384 : : } else {
385 [ # # ]: 0 : if (when == SUBMIT)
386 : 0 : dev_info(&udev->dev, "ep%d %s-%s, length %u, "
387 : : "timeout %d\n",
388 : : ep, t, d, length, timeout_or_status);
389 : : else
390 : 0 : dev_info(&udev->dev, "ep%d %s-%s, actual_length %u, "
391 : : "status %d\n",
392 : : ep, t, d, length, timeout_or_status);
393 : : }
394 : :
395 [ # # ]: 0 : if (data && data_len > 0) {
396 : 0 : print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
397 : : data, data_len, 1);
398 : : }
399 : : }
400 : :
401 : 0 : static void snoop_urb_data(struct urb *urb, unsigned len)
402 : : {
403 : : int i, size;
404 : :
405 [ # # ]: 0 : if (!usbfs_snoop)
406 : : return;
407 : :
408 [ # # ]: 0 : if (urb->num_sgs == 0) {
409 : 0 : print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
410 : 0 : urb->transfer_buffer, len, 1);
411 : 0 : return;
412 : : }
413 : :
414 [ # # ][ # # ]: 0 : for (i = 0; i < urb->num_sgs && len; i++) {
415 : 0 : size = (len > USB_SG_SIZE) ? USB_SG_SIZE : len;
416 : 0 : print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_NONE, 32, 1,
417 : 0 : sg_virt(&urb->sg[i]), size, 1);
418 : 0 : len -= size;
419 : : }
420 : : }
421 : :
422 : 0 : static int copy_urb_data_to_user(u8 __user *userbuffer, struct urb *urb)
423 : : {
424 : : unsigned i, len, size;
425 : :
426 [ # # ]: 0 : if (urb->number_of_packets > 0) /* Isochronous */
427 : 0 : len = urb->transfer_buffer_length;
428 : : else /* Non-Isoc */
429 : 0 : len = urb->actual_length;
430 : :
431 [ # # ]: 0 : if (urb->num_sgs == 0) {
432 [ # # ]: 0 : if (copy_to_user(userbuffer, urb->transfer_buffer, len))
433 : : return -EFAULT;
434 : 0 : return 0;
435 : : }
436 : :
437 [ # # ][ # # ]: 0 : for (i = 0; i < urb->num_sgs && len; i++) {
438 : 0 : size = (len > USB_SG_SIZE) ? USB_SG_SIZE : len;
439 [ # # ]: 0 : if (copy_to_user(userbuffer, sg_virt(&urb->sg[i]), size))
440 : : return -EFAULT;
441 : 0 : userbuffer += size;
442 : 0 : len -= size;
443 : : }
444 : :
445 : : return 0;
446 : : }
447 : :
448 : : #define AS_CONTINUATION 1
449 : : #define AS_UNLINK 2
450 : :
451 : 0 : static void cancel_bulk_urbs(struct dev_state *ps, unsigned bulk_addr)
452 : : __releases(ps->lock)
453 : : __acquires(ps->lock)
454 : : {
455 : : struct urb *urb;
456 : : struct async *as;
457 : :
458 : : /* Mark all the pending URBs that match bulk_addr, up to but not
459 : : * including the first one without AS_CONTINUATION. If such an
460 : : * URB is encountered then a new transfer has already started so
461 : : * the endpoint doesn't need to be disabled; otherwise it does.
462 : : */
463 [ # # ]: 0 : list_for_each_entry(as, &ps->async_pending, asynclist) {
464 [ # # ]: 0 : if (as->bulk_addr == bulk_addr) {
465 [ # # ]: 0 : if (as->bulk_status != AS_CONTINUATION)
466 : : goto rescan;
467 : 0 : as->bulk_status = AS_UNLINK;
468 : 0 : as->bulk_addr = 0;
469 : : }
470 : : }
471 : 0 : ps->disabled_bulk_eps |= (1 << bulk_addr);
472 : :
473 : : /* Now carefully unlink all the marked pending URBs */
474 : : rescan:
475 [ # # ]: 0 : list_for_each_entry(as, &ps->async_pending, asynclist) {
476 [ # # ]: 0 : if (as->bulk_status == AS_UNLINK) {
477 : 0 : as->bulk_status = 0; /* Only once */
478 : 0 : urb = as->urb;
479 : 0 : usb_get_urb(urb);
480 : : spin_unlock(&ps->lock); /* Allow completions */
481 : 0 : usb_unlink_urb(urb);
482 : 0 : usb_put_urb(urb);
483 : : spin_lock(&ps->lock);
484 : : goto rescan;
485 : : }
486 : : }
487 : 0 : }
488 : :
489 : 0 : static void async_completed(struct urb *urb)
490 : : {
491 : 0 : struct async *as = urb->context;
492 : 0 : struct dev_state *ps = as->ps;
493 : : struct siginfo sinfo;
494 : : struct pid *pid = NULL;
495 : : u32 secid = 0;
496 : : const struct cred *cred = NULL;
497 : : int signr;
498 : :
499 : : spin_lock(&ps->lock);
500 : 0 : list_move_tail(&as->asynclist, &ps->async_completed);
501 : 0 : as->status = urb->status;
502 : 0 : signr = as->signr;
503 [ # # ]: 0 : if (signr) {
504 : 0 : sinfo.si_signo = as->signr;
505 : 0 : sinfo.si_errno = as->status;
506 : 0 : sinfo.si_code = SI_ASYNCIO;
507 : 0 : sinfo.si_addr = as->userurb;
508 : 0 : pid = get_pid(as->pid);
509 : 0 : cred = get_cred(as->cred);
510 : 0 : secid = as->secid;
511 : : }
512 [ # # ]: 0 : snoop(&urb->dev->dev, "urb complete\n");
513 : 0 : snoop_urb(urb->dev, as->userurb, urb->pipe, urb->actual_length,
514 : : as->status, COMPLETE, NULL, 0);
515 : : if ((urb->transfer_flags & URB_DIR_MASK) == USB_DIR_IN)
516 : : snoop_urb_data(urb, urb->actual_length);
517 : :
518 [ # # ][ # # ]: 0 : if (as->status < 0 && as->bulk_addr && as->status != -ECONNRESET &&
[ # # ][ # # ]
519 : : as->status != -ENOENT)
520 : 0 : cancel_bulk_urbs(ps, as->bulk_addr);
521 : : spin_unlock(&ps->lock);
522 : :
523 [ # # ]: 0 : if (signr) {
524 : 0 : kill_pid_info_as_cred(sinfo.si_signo, &sinfo, pid, cred, secid);
525 : 0 : put_pid(pid);
526 : : put_cred(cred);
527 : : }
528 : :
529 : 0 : wake_up(&ps->wait);
530 : 0 : }
531 : :
532 : 0 : static void destroy_async(struct dev_state *ps, struct list_head *list)
533 : : {
534 : : struct urb *urb;
535 : : struct async *as;
536 : : unsigned long flags;
537 : :
538 : 0 : spin_lock_irqsave(&ps->lock, flags);
539 [ # # ]: 0 : while (!list_empty(list)) {
540 : : as = list_entry(list->next, struct async, asynclist);
541 : 0 : list_del_init(&as->asynclist);
542 : 0 : urb = as->urb;
543 : 0 : usb_get_urb(urb);
544 : :
545 : : /* drop the spinlock so the completion handler can run */
546 : : spin_unlock_irqrestore(&ps->lock, flags);
547 : 0 : usb_kill_urb(urb);
548 : 0 : usb_put_urb(urb);
549 : 0 : spin_lock_irqsave(&ps->lock, flags);
550 : : }
551 : : spin_unlock_irqrestore(&ps->lock, flags);
552 : 0 : }
553 : :
554 : 0 : static void destroy_async_on_interface(struct dev_state *ps,
555 : : unsigned int ifnum)
556 : : {
557 : : struct list_head *p, *q, hitlist;
558 : : unsigned long flags;
559 : :
560 : : INIT_LIST_HEAD(&hitlist);
561 : 0 : spin_lock_irqsave(&ps->lock, flags);
562 [ # # ]: 0 : list_for_each_safe(p, q, &ps->async_pending)
563 [ # # ]: 0 : if (ifnum == list_entry(p, struct async, asynclist)->ifnum)
564 : : list_move_tail(p, &hitlist);
565 : : spin_unlock_irqrestore(&ps->lock, flags);
566 : 0 : destroy_async(ps, &hitlist);
567 : 0 : }
568 : :
569 : : static void destroy_all_async(struct dev_state *ps)
570 : : {
571 : 0 : destroy_async(ps, &ps->async_pending);
572 : : }
573 : :
574 : : /*
575 : : * interface claims are made only at the request of user level code,
576 : : * which can also release them (explicitly or by closing files).
577 : : * they're also undone when devices disconnect.
578 : : */
579 : :
580 : 0 : static int driver_probe(struct usb_interface *intf,
581 : : const struct usb_device_id *id)
582 : : {
583 : 0 : return -ENODEV;
584 : : }
585 : :
586 : 0 : static void driver_disconnect(struct usb_interface *intf)
587 : : {
588 : : struct dev_state *ps = usb_get_intfdata(intf);
589 : 0 : unsigned int ifnum = intf->altsetting->desc.bInterfaceNumber;
590 : :
591 [ # # ]: 0 : if (!ps)
592 : 0 : return;
593 : :
594 : : /* NOTE: this relies on usbcore having canceled and completed
595 : : * all pending I/O requests; 2.6 does that.
596 : : */
597 : :
598 [ # # ]: 0 : if (likely(ifnum < 8*sizeof(ps->ifclaimed)))
599 : 0 : clear_bit(ifnum, &ps->ifclaimed);
600 : : else
601 : 0 : dev_warn(&intf->dev, "interface number %u out of range\n",
602 : : ifnum);
603 : :
604 : : usb_set_intfdata(intf, NULL);
605 : :
606 : : /* force async requests to complete */
607 : 0 : destroy_async_on_interface(ps, ifnum);
608 : : }
609 : :
610 : : /* The following routines are merely placeholders. There is no way
611 : : * to inform a user task about suspend or resumes.
612 : : */
613 : 0 : static int driver_suspend(struct usb_interface *intf, pm_message_t msg)
614 : : {
615 : 0 : return 0;
616 : : }
617 : :
618 : 0 : static int driver_resume(struct usb_interface *intf)
619 : : {
620 : 0 : return 0;
621 : : }
622 : :
623 : : struct usb_driver usbfs_driver = {
624 : : .name = "usbfs",
625 : : .probe = driver_probe,
626 : : .disconnect = driver_disconnect,
627 : : .suspend = driver_suspend,
628 : : .resume = driver_resume,
629 : : };
630 : :
631 : 0 : static int claimintf(struct dev_state *ps, unsigned int ifnum)
632 : : {
633 : 0 : struct usb_device *dev = ps->dev;
634 : : struct usb_interface *intf;
635 : : int err;
636 : :
637 [ # # ]: 0 : if (ifnum >= 8*sizeof(ps->ifclaimed))
638 : : return -EINVAL;
639 : : /* already claimed */
640 [ # # ]: 0 : if (test_bit(ifnum, &ps->ifclaimed))
641 : : return 0;
642 : :
643 : 0 : intf = usb_ifnum_to_if(dev, ifnum);
644 [ # # ]: 0 : if (!intf)
645 : : err = -ENOENT;
646 : : else
647 : 0 : err = usb_driver_claim_interface(&usbfs_driver, intf, ps);
648 [ # # ]: 0 : if (err == 0)
649 : 0 : set_bit(ifnum, &ps->ifclaimed);
650 : 0 : return err;
651 : : }
652 : :
653 : 0 : static int releaseintf(struct dev_state *ps, unsigned int ifnum)
654 : : {
655 : : struct usb_device *dev;
656 : : struct usb_interface *intf;
657 : : int err;
658 : :
659 : : err = -EINVAL;
660 [ # # ]: 0 : if (ifnum >= 8*sizeof(ps->ifclaimed))
661 : : return err;
662 : 0 : dev = ps->dev;
663 : 0 : intf = usb_ifnum_to_if(dev, ifnum);
664 [ # # ]: 0 : if (!intf)
665 : : err = -ENOENT;
666 [ # # ]: 0 : else if (test_and_clear_bit(ifnum, &ps->ifclaimed)) {
667 : 0 : usb_driver_release_interface(&usbfs_driver, intf);
668 : : err = 0;
669 : : }
670 : 0 : return err;
671 : : }
672 : :
673 : 0 : static int checkintf(struct dev_state *ps, unsigned int ifnum)
674 : : {
675 [ # # ]: 0 : if (ps->dev->state != USB_STATE_CONFIGURED)
676 : : return -EHOSTUNREACH;
677 [ # # ]: 0 : if (ifnum >= 8*sizeof(ps->ifclaimed))
678 : : return -EINVAL;
679 [ # # ]: 0 : if (test_bit(ifnum, &ps->ifclaimed))
680 : : return 0;
681 : : /* if not yet claimed, claim it for the driver */
682 : 0 : dev_warn(&ps->dev->dev, "usbfs: process %d (%s) did not claim "
683 : : "interface %u before use\n", task_pid_nr(current),
684 : 0 : current->comm, ifnum);
685 : 0 : return claimintf(ps, ifnum);
686 : : }
687 : :
688 : 0 : static int findintfep(struct usb_device *dev, unsigned int ep)
689 : : {
690 : : unsigned int i, j, e;
691 : : struct usb_interface *intf;
692 : : struct usb_host_interface *alts;
693 : : struct usb_endpoint_descriptor *endpt;
694 : :
695 [ # # ]: 0 : if (ep & ~(USB_DIR_IN|0xf))
696 : : return -EINVAL;
697 [ # # ]: 0 : if (!dev->actconfig)
698 : : return -ESRCH;
699 [ # # ]: 0 : for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
700 : 0 : intf = dev->actconfig->interface[i];
701 [ # # ]: 0 : for (j = 0; j < intf->num_altsetting; j++) {
702 : 0 : alts = &intf->altsetting[j];
703 [ # # ]: 0 : for (e = 0; e < alts->desc.bNumEndpoints; e++) {
704 : 0 : endpt = &alts->endpoint[e].desc;
705 [ # # ]: 0 : if (endpt->bEndpointAddress == ep)
706 : 0 : return alts->desc.bInterfaceNumber;
707 : : }
708 : : }
709 : : }
710 : : return -ENOENT;
711 : : }
712 : :
713 : 0 : static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype,
714 : : unsigned int request, unsigned int index)
715 : : {
716 : : int ret = 0;
717 : : struct usb_host_interface *alt_setting;
718 : :
719 [ # # ]: 0 : if (ps->dev->state != USB_STATE_UNAUTHENTICATED
720 : 0 : && ps->dev->state != USB_STATE_ADDRESS
721 [ # # ]: 0 : && ps->dev->state != USB_STATE_CONFIGURED)
722 : : return -EHOSTUNREACH;
723 [ # # ]: 0 : if (USB_TYPE_VENDOR == (USB_TYPE_MASK & requesttype))
724 : : return 0;
725 : :
726 : : /*
727 : : * check for the special corner case 'get_device_id' in the printer
728 : : * class specification, which we always want to allow as it is used
729 : : * to query things like ink level, etc.
730 : : */
731 [ # # ]: 0 : if (requesttype == 0xa1 && request == 0) {
732 : 0 : alt_setting = usb_find_alt_setting(ps->dev->actconfig,
733 : : index >> 8, index & 0xff);
734 [ # # ]: 0 : if (alt_setting
735 [ # # ]: 0 : && alt_setting->desc.bInterfaceClass == USB_CLASS_PRINTER)
736 : : return 0;
737 : : }
738 : :
739 : 0 : index &= 0xff;
740 [ # # # ]: 0 : switch (requesttype & USB_RECIP_MASK) {
741 : : case USB_RECIP_ENDPOINT:
742 [ # # ]: 0 : if ((index & ~USB_DIR_IN) == 0)
743 : : return 0;
744 : 0 : ret = findintfep(ps->dev, index);
745 [ # # ]: 0 : if (ret < 0) {
746 : : /*
747 : : * Some not fully compliant Win apps seem to get
748 : : * index wrong and have the endpoint number here
749 : : * rather than the endpoint address (with the
750 : : * correct direction). Win does let this through,
751 : : * so we'll not reject it here but leave it to
752 : : * the device to not break KVM. But we warn.
753 : : */
754 : 0 : ret = findintfep(ps->dev, index ^ 0x80);
755 [ # # ]: 0 : if (ret >= 0)
756 : 0 : dev_info(&ps->dev->dev,
757 : : "%s: process %i (%s) requesting ep %02x but needs %02x\n",
758 : : __func__, task_pid_nr(current),
759 : : current->comm, index, index ^ 0x80);
760 : : }
761 [ # # ]: 0 : if (ret >= 0)
762 : 0 : ret = checkintf(ps, ret);
763 : : break;
764 : :
765 : : case USB_RECIP_INTERFACE:
766 : 0 : ret = checkintf(ps, index);
767 : 0 : break;
768 : : }
769 : 0 : return ret;
770 : : }
771 : :
772 : 0 : static int match_devt(struct device *dev, void *data)
773 : : {
774 : 0 : return dev->devt == (dev_t) (unsigned long) data;
775 : : }
776 : :
777 : : static struct usb_device *usbdev_lookup_by_devt(dev_t devt)
778 : : {
779 : : struct device *dev;
780 : :
781 : 0 : dev = bus_find_device(&usb_bus_type, NULL,
782 : : (void *) (unsigned long) devt, match_devt);
783 [ # # ]: 0 : if (!dev)
784 : : return NULL;
785 : 0 : return container_of(dev, struct usb_device, dev);
786 : : }
787 : :
788 : : /*
789 : : * file operations
790 : : */
791 : 0 : static int usbdev_open(struct inode *inode, struct file *file)
792 : : {
793 : : struct usb_device *dev = NULL;
794 : : struct dev_state *ps;
795 : : int ret;
796 : :
797 : : ret = -ENOMEM;
798 : : ps = kmalloc(sizeof(struct dev_state), GFP_KERNEL);
799 [ # # ]: 0 : if (!ps)
800 : : goto out_free_ps;
801 : :
802 : : ret = -ENODEV;
803 : :
804 : : /* Protect against simultaneous removal or release */
805 : 0 : mutex_lock(&usbfs_mutex);
806 : :
807 : : /* usbdev device-node */
808 [ # # ]: 0 : if (imajor(inode) == USB_DEVICE_MAJOR)
809 : : dev = usbdev_lookup_by_devt(inode->i_rdev);
810 : :
811 : 0 : mutex_unlock(&usbfs_mutex);
812 : :
813 [ # # ]: 0 : if (!dev)
814 : : goto out_free_ps;
815 : :
816 : : usb_lock_device(dev);
817 [ # # ]: 0 : if (dev->state == USB_STATE_NOTATTACHED)
818 : : goto out_unlock_device;
819 : :
820 : : ret = usb_autoresume_device(dev);
821 : : if (ret)
822 : : goto out_unlock_device;
823 : :
824 : 0 : ps->dev = dev;
825 : 0 : ps->file = file;
826 : 0 : spin_lock_init(&ps->lock);
827 : 0 : INIT_LIST_HEAD(&ps->list);
828 : 0 : INIT_LIST_HEAD(&ps->async_pending);
829 : 0 : INIT_LIST_HEAD(&ps->async_completed);
830 : 0 : init_waitqueue_head(&ps->wait);
831 : 0 : ps->discsignr = 0;
832 : 0 : ps->disc_pid = get_pid(task_pid(current));
833 : 0 : ps->cred = get_current_cred();
834 : 0 : ps->disccontext = NULL;
835 : 0 : ps->ifclaimed = 0;
836 : 0 : security_task_getsecid(current, &ps->secid);
837 : 0 : smp_wmb();
838 : 0 : list_add_tail(&ps->list, &dev->filelist);
839 : 0 : file->private_data = ps;
840 : : usb_unlock_device(dev);
841 [ # # ]: 0 : snoop(&dev->dev, "opened by process %d: %s\n", task_pid_nr(current),
842 : : current->comm);
843 : : return ret;
844 : :
845 : : out_unlock_device:
846 : : usb_unlock_device(dev);
847 : 0 : usb_put_dev(dev);
848 : : out_free_ps:
849 : 0 : kfree(ps);
850 : 0 : return ret;
851 : : }
852 : :
853 : 0 : static int usbdev_release(struct inode *inode, struct file *file)
854 : : {
855 : 0 : struct dev_state *ps = file->private_data;
856 : 0 : struct usb_device *dev = ps->dev;
857 : : unsigned int ifnum;
858 : : struct async *as;
859 : :
860 : : usb_lock_device(dev);
861 : 0 : usb_hub_release_all_ports(dev, ps);
862 : :
863 : 0 : list_del_init(&ps->list);
864 : :
865 [ # # ][ # # ]: 0 : for (ifnum = 0; ps->ifclaimed && ifnum < 8*sizeof(ps->ifclaimed);
866 : 0 : ifnum++) {
867 [ # # ]: 0 : if (test_bit(ifnum, &ps->ifclaimed))
868 : 0 : releaseintf(ps, ifnum);
869 : : }
870 : : destroy_all_async(ps);
871 : : usb_autosuspend_device(dev);
872 : : usb_unlock_device(dev);
873 : 0 : usb_put_dev(dev);
874 : 0 : put_pid(ps->disc_pid);
875 : 0 : put_cred(ps->cred);
876 : :
877 : 0 : as = async_getcompleted(ps);
878 [ # # ]: 0 : while (as) {
879 : 0 : free_async(as);
880 : 0 : as = async_getcompleted(ps);
881 : : }
882 : 0 : kfree(ps);
883 : 0 : return 0;
884 : : }
885 : :
886 : 0 : static int proc_control(struct dev_state *ps, void __user *arg)
887 : : {
888 : 0 : struct usb_device *dev = ps->dev;
889 : : struct usbdevfs_ctrltransfer ctrl;
890 : : unsigned int tmo;
891 : : unsigned char *tbuf;
892 : : unsigned wLength;
893 : : int i, pipe, ret;
894 : :
895 [ # # ]: 0 : if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
896 : : return -EFAULT;
897 : 0 : ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest,
898 : 0 : ctrl.wIndex);
899 [ # # ]: 0 : if (ret)
900 : : return ret;
901 : 0 : wLength = ctrl.wLength; /* To suppress 64k PAGE_SIZE warning */
902 [ # # ]: 0 : if (wLength > PAGE_SIZE)
903 : : return -EINVAL;
904 : 0 : ret = usbfs_increase_memory_usage(PAGE_SIZE + sizeof(struct urb) +
905 : : sizeof(struct usb_ctrlrequest));
906 [ # # ]: 0 : if (ret)
907 : : return ret;
908 : 0 : tbuf = (unsigned char *)__get_free_page(GFP_KERNEL);
909 [ # # ]: 0 : if (!tbuf) {
910 : : ret = -ENOMEM;
911 : : goto done;
912 : : }
913 : 0 : tmo = ctrl.timeout;
914 [ # # ]: 0 : snoop(&dev->dev, "control urb: bRequestType=%02x "
915 : : "bRequest=%02x wValue=%04x "
916 : : "wIndex=%04x wLength=%04x\n",
917 : : ctrl.bRequestType, ctrl.bRequest, ctrl.wValue,
918 : : ctrl.wIndex, ctrl.wLength);
919 [ # # ]: 0 : if (ctrl.bRequestType & 0x80) {
920 [ # # ][ # # ]: 0 : if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data,
921 : : ctrl.wLength)) {
922 : : ret = -EINVAL;
923 : : goto done;
924 : : }
925 : 0 : pipe = usb_rcvctrlpipe(dev, 0);
926 : 0 : snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0);
927 : :
928 : : usb_unlock_device(dev);
929 : 0 : i = usb_control_msg(dev, pipe, ctrl.bRequest,
930 : : ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
931 : : tbuf, ctrl.wLength, tmo);
932 : : usb_lock_device(dev);
933 : 0 : snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE,
934 : : tbuf, max(i, 0));
935 [ # # ][ # # ]: 0 : if ((i > 0) && ctrl.wLength) {
936 [ # # ]: 0 : if (copy_to_user(ctrl.data, tbuf, i)) {
937 : : ret = -EFAULT;
938 : : goto done;
939 : : }
940 : : }
941 : : } else {
942 [ # # ]: 0 : if (ctrl.wLength) {
943 [ # # ]: 0 : if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) {
944 : : ret = -EFAULT;
945 : : goto done;
946 : : }
947 : : }
948 : 0 : pipe = usb_sndctrlpipe(dev, 0);
949 : 0 : snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT,
950 : 0 : tbuf, ctrl.wLength);
951 : :
952 : : usb_unlock_device(dev);
953 : 0 : i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest,
954 : : ctrl.bRequestType, ctrl.wValue, ctrl.wIndex,
955 : : tbuf, ctrl.wLength, tmo);
956 : : usb_lock_device(dev);
957 : 0 : snoop_urb(dev, NULL, pipe, max(i, 0), min(i, 0), COMPLETE, NULL, 0);
958 : : }
959 [ # # ]: 0 : if (i < 0 && i != -EPIPE) {
960 : 0 : dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL "
961 : : "failed cmd %s rqt %u rq %u len %u ret %d\n",
962 : 0 : current->comm, ctrl.bRequestType, ctrl.bRequest,
963 : 0 : ctrl.wLength, i);
964 : : }
965 : : ret = i;
966 : : done:
967 : 0 : free_page((unsigned long) tbuf);
968 : : usbfs_decrease_memory_usage(PAGE_SIZE + sizeof(struct urb) +
969 : : sizeof(struct usb_ctrlrequest));
970 : 0 : return ret;
971 : : }
972 : :
973 : 0 : static int proc_bulk(struct dev_state *ps, void __user *arg)
974 : : {
975 : 0 : struct usb_device *dev = ps->dev;
976 : : struct usbdevfs_bulktransfer bulk;
977 : : unsigned int tmo, len1, pipe;
978 : : int len2;
979 : : unsigned char *tbuf;
980 : : int i, ret;
981 : :
982 [ # # ]: 0 : if (copy_from_user(&bulk, arg, sizeof(bulk)))
983 : : return -EFAULT;
984 : 0 : ret = findintfep(ps->dev, bulk.ep);
985 [ # # ]: 0 : if (ret < 0)
986 : : return ret;
987 : 0 : ret = checkintf(ps, ret);
988 [ # # ]: 0 : if (ret)
989 : : return ret;
990 [ # # ]: 0 : if (bulk.ep & USB_DIR_IN)
991 : 0 : pipe = usb_rcvbulkpipe(dev, bulk.ep & 0x7f);
992 : : else
993 : 0 : pipe = usb_sndbulkpipe(dev, bulk.ep & 0x7f);
994 [ # # ]: 0 : if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN)))
995 : : return -EINVAL;
996 : 0 : len1 = bulk.len;
997 [ # # ]: 0 : if (len1 >= USBFS_XFER_MAX)
998 : : return -EINVAL;
999 : 0 : ret = usbfs_increase_memory_usage(len1 + sizeof(struct urb));
1000 [ # # ]: 0 : if (ret)
1001 : : return ret;
1002 [ # # ]: 0 : if (!(tbuf = kmalloc(len1, GFP_KERNEL))) {
1003 : : ret = -ENOMEM;
1004 : : goto done;
1005 : : }
1006 : 0 : tmo = bulk.timeout;
1007 [ # # ]: 0 : if (bulk.ep & 0x80) {
1008 [ # # ][ # # ]: 0 : if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) {
1009 : : ret = -EINVAL;
1010 : : goto done;
1011 : : }
1012 : 0 : snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT, NULL, 0);
1013 : :
1014 : : usb_unlock_device(dev);
1015 : 0 : i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
1016 : : usb_lock_device(dev);
1017 : 0 : snoop_urb(dev, NULL, pipe, len2, i, COMPLETE, tbuf, len2);
1018 : :
1019 [ # # ][ # # ]: 0 : if (!i && len2) {
1020 [ # # ]: 0 : if (copy_to_user(bulk.data, tbuf, len2)) {
1021 : : ret = -EFAULT;
1022 : : goto done;
1023 : : }
1024 : : }
1025 : : } else {
1026 [ # # ]: 0 : if (len1) {
1027 [ # # ]: 0 : if (copy_from_user(tbuf, bulk.data, len1)) {
1028 : : ret = -EFAULT;
1029 : : goto done;
1030 : : }
1031 : : }
1032 : 0 : snoop_urb(dev, NULL, pipe, len1, tmo, SUBMIT, tbuf, len1);
1033 : :
1034 : : usb_unlock_device(dev);
1035 : 0 : i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
1036 : : usb_lock_device(dev);
1037 : 0 : snoop_urb(dev, NULL, pipe, len2, i, COMPLETE, NULL, 0);
1038 : : }
1039 [ # # ]: 0 : ret = (i < 0 ? i : len2);
1040 : : done:
1041 : 0 : kfree(tbuf);
1042 : : usbfs_decrease_memory_usage(len1 + sizeof(struct urb));
1043 : 0 : return ret;
1044 : : }
1045 : :
1046 : 0 : static int proc_resetep(struct dev_state *ps, void __user *arg)
1047 : : {
1048 : : unsigned int ep;
1049 : : int ret;
1050 : :
1051 [ # # ]: 0 : if (get_user(ep, (unsigned int __user *)arg))
1052 : : return -EFAULT;
1053 : 0 : ret = findintfep(ps->dev, ep);
1054 [ # # ]: 0 : if (ret < 0)
1055 : : return ret;
1056 : 0 : ret = checkintf(ps, ret);
1057 [ # # ]: 0 : if (ret)
1058 : : return ret;
1059 : 0 : usb_reset_endpoint(ps->dev, ep);
1060 : 0 : return 0;
1061 : : }
1062 : :
1063 : 0 : static int proc_clearhalt(struct dev_state *ps, void __user *arg)
1064 : : {
1065 : : unsigned int ep;
1066 : : int pipe;
1067 : : int ret;
1068 : :
1069 [ # # ]: 0 : if (get_user(ep, (unsigned int __user *)arg))
1070 : : return -EFAULT;
1071 : 0 : ret = findintfep(ps->dev, ep);
1072 [ # # ]: 0 : if (ret < 0)
1073 : : return ret;
1074 : 0 : ret = checkintf(ps, ret);
1075 [ # # ]: 0 : if (ret)
1076 : : return ret;
1077 [ # # ]: 0 : if (ep & USB_DIR_IN)
1078 : 0 : pipe = usb_rcvbulkpipe(ps->dev, ep & 0x7f);
1079 : : else
1080 : 0 : pipe = usb_sndbulkpipe(ps->dev, ep & 0x7f);
1081 : :
1082 : 0 : return usb_clear_halt(ps->dev, pipe);
1083 : : }
1084 : :
1085 : 0 : static int proc_getdriver(struct dev_state *ps, void __user *arg)
1086 : : {
1087 : : struct usbdevfs_getdriver gd;
1088 : : struct usb_interface *intf;
1089 : : int ret;
1090 : :
1091 [ # # ]: 0 : if (copy_from_user(&gd, arg, sizeof(gd)))
1092 : : return -EFAULT;
1093 : 0 : intf = usb_ifnum_to_if(ps->dev, gd.interface);
1094 [ # # ][ # # ]: 0 : if (!intf || !intf->dev.driver)
1095 : : ret = -ENODATA;
1096 : : else {
1097 : 0 : strlcpy(gd.driver, intf->dev.driver->name,
1098 : : sizeof(gd.driver));
1099 [ # # ]: 0 : ret = (copy_to_user(arg, &gd, sizeof(gd)) ? -EFAULT : 0);
1100 : : }
1101 : : return ret;
1102 : : }
1103 : :
1104 : 0 : static int proc_connectinfo(struct dev_state *ps, void __user *arg)
1105 : : {
1106 : 0 : struct usbdevfs_connectinfo ci = {
1107 : 0 : .devnum = ps->dev->devnum,
1108 : 0 : .slow = ps->dev->speed == USB_SPEED_LOW
1109 : : };
1110 : :
1111 [ # # ]: 0 : if (copy_to_user(arg, &ci, sizeof(ci)))
1112 : : return -EFAULT;
1113 : : return 0;
1114 : : }
1115 : :
1116 : : static int proc_resetdevice(struct dev_state *ps)
1117 : : {
1118 : 0 : return usb_reset_device(ps->dev);
1119 : : }
1120 : :
1121 : 0 : static int proc_setintf(struct dev_state *ps, void __user *arg)
1122 : : {
1123 : : struct usbdevfs_setinterface setintf;
1124 : : int ret;
1125 : :
1126 [ # # ]: 0 : if (copy_from_user(&setintf, arg, sizeof(setintf)))
1127 : : return -EFAULT;
1128 [ # # ]: 0 : if ((ret = checkintf(ps, setintf.interface)))
1129 : : return ret;
1130 : 0 : return usb_set_interface(ps->dev, setintf.interface,
1131 : 0 : setintf.altsetting);
1132 : : }
1133 : :
1134 : 0 : static int proc_setconfig(struct dev_state *ps, void __user *arg)
1135 : : {
1136 : : int u;
1137 : : int status = 0;
1138 : : struct usb_host_config *actconfig;
1139 : :
1140 [ # # ]: 0 : if (get_user(u, (int __user *)arg))
1141 : : return -EFAULT;
1142 : :
1143 : 0 : actconfig = ps->dev->actconfig;
1144 : :
1145 : : /* Don't touch the device if any interfaces are claimed.
1146 : : * It could interfere with other drivers' operations, and if
1147 : : * an interface is claimed by usbfs it could easily deadlock.
1148 : : */
1149 [ # # ]: 0 : if (actconfig) {
1150 : : int i;
1151 : :
1152 [ # # ]: 0 : for (i = 0; i < actconfig->desc.bNumInterfaces; ++i) {
1153 [ # # ]: 0 : if (usb_interface_claimed(actconfig->interface[i])) {
1154 : 0 : dev_warn(&ps->dev->dev,
1155 : : "usbfs: interface %d claimed by %s "
1156 : : "while '%s' sets config #%d\n",
1157 : : actconfig->interface[i]
1158 : 0 : ->cur_altsetting
1159 : 0 : ->desc.bInterfaceNumber,
1160 : : actconfig->interface[i]
1161 : : ->dev.driver->name,
1162 : 0 : current->comm, u);
1163 : : status = -EBUSY;
1164 : : break;
1165 : : }
1166 : : }
1167 : : }
1168 : :
1169 : : /* SET_CONFIGURATION is often abused as a "cheap" driver reset,
1170 : : * so avoid usb_set_configuration()'s kick to sysfs
1171 : : */
1172 [ # # ]: 0 : if (status == 0) {
1173 [ # # ][ # # ]: 0 : if (actconfig && actconfig->desc.bConfigurationValue == u)
1174 : 0 : status = usb_reset_configuration(ps->dev);
1175 : : else
1176 : 0 : status = usb_set_configuration(ps->dev, u);
1177 : : }
1178 : :
1179 : : return status;
1180 : : }
1181 : :
1182 : 0 : static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
1183 : : struct usbdevfs_iso_packet_desc __user *iso_frame_desc,
1184 : : void __user *arg)
1185 : : {
1186 : : struct usbdevfs_iso_packet_desc *isopkt = NULL;
1187 : : struct usb_host_endpoint *ep;
1188 : : struct async *as = NULL;
1189 : : struct usb_ctrlrequest *dr = NULL;
1190 : : unsigned int u, totlen, isofrmlen;
1191 : : int i, ret, is_in, num_sgs = 0, ifnum = -1;
1192 : : void *buf;
1193 : :
1194 [ # # ]: 0 : if (uurb->flags & ~(USBDEVFS_URB_ISO_ASAP |
1195 : : USBDEVFS_URB_SHORT_NOT_OK |
1196 : : USBDEVFS_URB_BULK_CONTINUATION |
1197 : : USBDEVFS_URB_NO_FSBR |
1198 : : USBDEVFS_URB_ZERO_PACKET |
1199 : : USBDEVFS_URB_NO_INTERRUPT))
1200 : : return -EINVAL;
1201 [ # # ][ # # ]: 0 : if (uurb->buffer_length > 0 && !uurb->buffer)
1202 : : return -EINVAL;
1203 [ # # ][ # # ]: 0 : if (!(uurb->type == USBDEVFS_URB_TYPE_CONTROL &&
1204 : 0 : (uurb->endpoint & ~USB_ENDPOINT_DIR_MASK) == 0)) {
1205 : 0 : ifnum = findintfep(ps->dev, uurb->endpoint);
1206 [ # # ]: 0 : if (ifnum < 0)
1207 : : return ifnum;
1208 : 0 : ret = checkintf(ps, ifnum);
1209 [ # # ]: 0 : if (ret)
1210 : : return ret;
1211 : : }
1212 [ # # ]: 0 : if ((uurb->endpoint & USB_ENDPOINT_DIR_MASK) != 0) {
1213 : : is_in = 1;
1214 : 0 : ep = ps->dev->ep_in[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
1215 : : } else {
1216 : : is_in = 0;
1217 : 0 : ep = ps->dev->ep_out[uurb->endpoint & USB_ENDPOINT_NUMBER_MASK];
1218 : : }
1219 [ # # ]: 0 : if (!ep)
1220 : : return -ENOENT;
1221 : :
1222 : : u = 0;
1223 [ # # # # : 0 : switch(uurb->type) {
# ]
1224 : : case USBDEVFS_URB_TYPE_CONTROL:
1225 [ # # ]: 0 : if (!usb_endpoint_xfer_control(&ep->desc))
1226 : : return -EINVAL;
1227 : : /* min 8 byte setup packet */
1228 [ # # ]: 0 : if (uurb->buffer_length < 8)
1229 : : return -EINVAL;
1230 : : dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
1231 [ # # ]: 0 : if (!dr)
1232 : : return -ENOMEM;
1233 [ # # ]: 0 : if (copy_from_user(dr, uurb->buffer, 8)) {
1234 : : ret = -EFAULT;
1235 : : goto error;
1236 : : }
1237 [ # # ]: 0 : if (uurb->buffer_length < (le16_to_cpup(&dr->wLength) + 8)) {
1238 : : ret = -EINVAL;
1239 : : goto error;
1240 : : }
1241 : 0 : ret = check_ctrlrecip(ps, dr->bRequestType, dr->bRequest,
1242 : 0 : le16_to_cpup(&dr->wIndex));
1243 [ # # ]: 0 : if (ret)
1244 : : goto error;
1245 : 0 : uurb->number_of_packets = 0;
1246 : 0 : uurb->buffer_length = le16_to_cpup(&dr->wLength);
1247 : 0 : uurb->buffer += 8;
1248 [ # # ][ # # ]: 0 : if ((dr->bRequestType & USB_DIR_IN) && uurb->buffer_length) {
1249 : : is_in = 1;
1250 : 0 : uurb->endpoint |= USB_DIR_IN;
1251 : : } else {
1252 : : is_in = 0;
1253 : 0 : uurb->endpoint &= ~USB_DIR_IN;
1254 : : }
1255 [ # # ]: 0 : snoop(&ps->dev->dev, "control urb: bRequestType=%02x "
1256 : : "bRequest=%02x wValue=%04x "
1257 : : "wIndex=%04x wLength=%04x\n",
1258 : : dr->bRequestType, dr->bRequest,
1259 : : __le16_to_cpup(&dr->wValue),
1260 : : __le16_to_cpup(&dr->wIndex),
1261 : : __le16_to_cpup(&dr->wLength));
1262 : : u = sizeof(struct usb_ctrlrequest);
1263 : : break;
1264 : :
1265 : : case USBDEVFS_URB_TYPE_BULK:
1266 [ # # # ]: 0 : switch (usb_endpoint_type(&ep->desc)) {
1267 : : case USB_ENDPOINT_XFER_CONTROL:
1268 : : case USB_ENDPOINT_XFER_ISOC:
1269 : : return -EINVAL;
1270 : : case USB_ENDPOINT_XFER_INT:
1271 : : /* allow single-shot interrupt transfers */
1272 : 0 : uurb->type = USBDEVFS_URB_TYPE_INTERRUPT;
1273 : 0 : goto interrupt_urb;
1274 : : }
1275 : 0 : uurb->number_of_packets = 0;
1276 : 0 : num_sgs = DIV_ROUND_UP(uurb->buffer_length, USB_SG_SIZE);
1277 [ # # ][ # # ]: 0 : if (num_sgs == 1 || num_sgs > ps->dev->bus->sg_tablesize)
1278 : : num_sgs = 0;
1279 : : break;
1280 : :
1281 : : case USBDEVFS_URB_TYPE_INTERRUPT:
1282 [ # # ]: 0 : if (!usb_endpoint_xfer_int(&ep->desc))
1283 : : return -EINVAL;
1284 : : interrupt_urb:
1285 : 0 : uurb->number_of_packets = 0;
1286 : 0 : break;
1287 : :
1288 : : case USBDEVFS_URB_TYPE_ISO:
1289 : : /* arbitrary limit */
1290 [ # # ]: 0 : if (uurb->number_of_packets < 1 ||
1291 : : uurb->number_of_packets > 128)
1292 : : return -EINVAL;
1293 [ # # ]: 0 : if (!usb_endpoint_xfer_isoc(&ep->desc))
1294 : : return -EINVAL;
1295 : 0 : isofrmlen = sizeof(struct usbdevfs_iso_packet_desc) *
1296 : : uurb->number_of_packets;
1297 [ # # ]: 0 : if (!(isopkt = kmalloc(isofrmlen, GFP_KERNEL)))
1298 : : return -ENOMEM;
1299 [ # # ]: 0 : if (copy_from_user(isopkt, iso_frame_desc, isofrmlen)) {
1300 : : ret = -EFAULT;
1301 : : goto error;
1302 : : }
1303 [ # # ]: 0 : for (totlen = u = 0; u < uurb->number_of_packets; u++) {
1304 : : /*
1305 : : * arbitrary limit need for USB 3.0
1306 : : * bMaxBurst (0~15 allowed, 1~16 packets)
1307 : : * bmAttributes (bit 1:0, mult 0~2, 1~3 packets)
1308 : : * sizemax: 1024 * 16 * 3 = 49152
1309 : : */
1310 [ # # ]: 0 : if (isopkt[u].length > 49152) {
1311 : : ret = -EINVAL;
1312 : : goto error;
1313 : : }
1314 : 0 : totlen += isopkt[u].length;
1315 : : }
1316 : 0 : u *= sizeof(struct usb_iso_packet_descriptor);
1317 : 0 : uurb->buffer_length = totlen;
1318 : 0 : break;
1319 : :
1320 : : default:
1321 : : return -EINVAL;
1322 : : }
1323 : :
1324 [ # # ]: 0 : if (uurb->buffer_length >= USBFS_XFER_MAX) {
1325 : : ret = -EINVAL;
1326 : : goto error;
1327 : : }
1328 [ # # ][ # # ]: 0 : if (uurb->buffer_length > 0 &&
1329 : 0 : !access_ok(is_in ? VERIFY_WRITE : VERIFY_READ,
1330 : : uurb->buffer, uurb->buffer_length)) {
1331 : : ret = -EFAULT;
1332 : : goto error;
1333 : : }
1334 : 0 : as = alloc_async(uurb->number_of_packets);
1335 [ # # ]: 0 : if (!as) {
1336 : : ret = -ENOMEM;
1337 : : goto error;
1338 : : }
1339 : :
1340 : 0 : u += sizeof(struct async) + sizeof(struct urb) + uurb->buffer_length +
1341 : 0 : num_sgs * sizeof(struct scatterlist);
1342 : 0 : ret = usbfs_increase_memory_usage(u);
1343 [ # # ]: 0 : if (ret)
1344 : : goto error;
1345 : 0 : as->mem_usage = u;
1346 : :
1347 [ # # ]: 0 : if (num_sgs) {
1348 : 0 : as->urb->sg = kmalloc(num_sgs * sizeof(struct scatterlist),
1349 : : GFP_KERNEL);
1350 [ # # ]: 0 : if (!as->urb->sg) {
1351 : : ret = -ENOMEM;
1352 : : goto error;
1353 : : }
1354 : 0 : as->urb->num_sgs = num_sgs;
1355 : 0 : sg_init_table(as->urb->sg, as->urb->num_sgs);
1356 : :
1357 : 0 : totlen = uurb->buffer_length;
1358 [ # # ]: 0 : for (i = 0; i < as->urb->num_sgs; i++) {
1359 : 0 : u = (totlen > USB_SG_SIZE) ? USB_SG_SIZE : totlen;
1360 : : buf = kmalloc(u, GFP_KERNEL);
1361 [ # # ]: 0 : if (!buf) {
1362 : : ret = -ENOMEM;
1363 : : goto error;
1364 : : }
1365 : 0 : sg_set_buf(&as->urb->sg[i], buf, u);
1366 : :
1367 [ # # ]: 0 : if (!is_in) {
1368 [ # # ]: 0 : if (copy_from_user(buf, uurb->buffer, u)) {
1369 : : ret = -EFAULT;
1370 : : goto error;
1371 : : }
1372 : 0 : uurb->buffer += u;
1373 : : }
1374 : 0 : totlen -= u;
1375 : : }
1376 [ # # ]: 0 : } else if (uurb->buffer_length > 0) {
1377 : 0 : as->urb->transfer_buffer = kmalloc(uurb->buffer_length,
1378 : : GFP_KERNEL);
1379 [ # # ]: 0 : if (!as->urb->transfer_buffer) {
1380 : : ret = -ENOMEM;
1381 : : goto error;
1382 : : }
1383 : :
1384 [ # # ]: 0 : if (!is_in) {
1385 [ # # ]: 0 : if (copy_from_user(as->urb->transfer_buffer,
1386 : 0 : uurb->buffer,
1387 : 0 : uurb->buffer_length)) {
1388 : : ret = -EFAULT;
1389 : : goto error;
1390 : : }
1391 [ # # ]: 0 : } else if (uurb->type == USBDEVFS_URB_TYPE_ISO) {
1392 : : /*
1393 : : * Isochronous input data may end up being
1394 : : * discontiguous if some of the packets are short.
1395 : : * Clear the buffer so that the gaps don't leak
1396 : : * kernel data to userspace.
1397 : : */
1398 [ # # ]: 0 : memset(as->urb->transfer_buffer, 0,
1399 : : uurb->buffer_length);
1400 : : }
1401 : : }
1402 : 0 : as->urb->dev = ps->dev;
1403 : 0 : as->urb->pipe = (uurb->type << 30) |
1404 : 0 : __create_pipe(ps->dev, uurb->endpoint & 0xf) |
1405 : : (uurb->endpoint & USB_DIR_IN);
1406 : :
1407 : : /* This tedious sequence is necessary because the URB_* flags
1408 : : * are internal to the kernel and subject to change, whereas
1409 : : * the USBDEVFS_URB_* flags are a user API and must not be changed.
1410 : : */
1411 [ # # ]: 0 : u = (is_in ? URB_DIR_IN : URB_DIR_OUT);
1412 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_ISO_ASAP)
1413 : 0 : u |= URB_ISO_ASAP;
1414 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_SHORT_NOT_OK)
1415 : 0 : u |= URB_SHORT_NOT_OK;
1416 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_NO_FSBR)
1417 : 0 : u |= URB_NO_FSBR;
1418 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_ZERO_PACKET)
1419 : 0 : u |= URB_ZERO_PACKET;
1420 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_NO_INTERRUPT)
1421 : 0 : u |= URB_NO_INTERRUPT;
1422 : 0 : as->urb->transfer_flags = u;
1423 : :
1424 : 0 : as->urb->transfer_buffer_length = uurb->buffer_length;
1425 : 0 : as->urb->setup_packet = (unsigned char *)dr;
1426 : : dr = NULL;
1427 : 0 : as->urb->start_frame = uurb->start_frame;
1428 : 0 : as->urb->number_of_packets = uurb->number_of_packets;
1429 [ # # ][ # # ]: 0 : if (uurb->type == USBDEVFS_URB_TYPE_ISO ||
1430 : 0 : ps->dev->speed == USB_SPEED_HIGH)
1431 : 0 : as->urb->interval = 1 << min(15, ep->desc.bInterval - 1);
1432 : : else
1433 : 0 : as->urb->interval = ep->desc.bInterval;
1434 : 0 : as->urb->context = as;
1435 : 0 : as->urb->complete = async_completed;
1436 [ # # ]: 0 : for (totlen = u = 0; u < uurb->number_of_packets; u++) {
1437 : 0 : as->urb->iso_frame_desc[u].offset = totlen;
1438 : 0 : as->urb->iso_frame_desc[u].length = isopkt[u].length;
1439 : 0 : totlen += isopkt[u].length;
1440 : : }
1441 : 0 : kfree(isopkt);
1442 : : isopkt = NULL;
1443 : 0 : as->ps = ps;
1444 : 0 : as->userurb = arg;
1445 [ # # ][ # # ]: 0 : if (is_in && uurb->buffer_length > 0)
1446 : 0 : as->userbuffer = uurb->buffer;
1447 : : else
1448 : 0 : as->userbuffer = NULL;
1449 : 0 : as->signr = uurb->signr;
1450 : 0 : as->ifnum = ifnum;
1451 : 0 : as->pid = get_pid(task_pid(current));
1452 : 0 : as->cred = get_current_cred();
1453 : 0 : security_task_getsecid(current, &as->secid);
1454 : 0 : snoop_urb(ps->dev, as->userurb, as->urb->pipe,
1455 : : as->urb->transfer_buffer_length, 0, SUBMIT,
1456 : : NULL, 0);
1457 [ # # ]: 0 : if (!is_in)
1458 : 0 : snoop_urb_data(as->urb, as->urb->transfer_buffer_length);
1459 : :
1460 : 0 : async_newpending(as);
1461 : :
1462 [ # # ]: 0 : if (usb_endpoint_xfer_bulk(&ep->desc)) {
1463 : : spin_lock_irq(&ps->lock);
1464 : :
1465 : : /* Not exactly the endpoint address; the direction bit is
1466 : : * shifted to the 0x10 position so that the value will be
1467 : : * between 0 and 31.
1468 : : */
1469 : 0 : as->bulk_addr = usb_endpoint_num(&ep->desc) |
1470 : 0 : ((ep->desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK)
1471 : 0 : >> 3);
1472 : :
1473 : : /* If this bulk URB is the start of a new transfer, re-enable
1474 : : * the endpoint. Otherwise mark it as a continuation URB.
1475 : : */
1476 [ # # ]: 0 : if (uurb->flags & USBDEVFS_URB_BULK_CONTINUATION)
1477 : 0 : as->bulk_status = AS_CONTINUATION;
1478 : : else
1479 : 0 : ps->disabled_bulk_eps &= ~(1 << as->bulk_addr);
1480 : :
1481 : : /* Don't accept continuation URBs if the endpoint is
1482 : : * disabled because of an earlier error.
1483 : : */
1484 [ # # ]: 0 : if (ps->disabled_bulk_eps & (1 << as->bulk_addr))
1485 : : ret = -EREMOTEIO;
1486 : : else
1487 : 0 : ret = usb_submit_urb(as->urb, GFP_ATOMIC);
1488 : : spin_unlock_irq(&ps->lock);
1489 : : } else {
1490 : 0 : ret = usb_submit_urb(as->urb, GFP_KERNEL);
1491 : : }
1492 : :
1493 [ # # ]: 0 : if (ret) {
1494 : 0 : dev_printk(KERN_DEBUG, &ps->dev->dev,
1495 : : "usbfs: usb_submit_urb returned %d\n", ret);
1496 : 0 : snoop_urb(ps->dev, as->userurb, as->urb->pipe,
1497 : : 0, ret, COMPLETE, NULL, 0);
1498 : 0 : async_removepending(as);
1499 : 0 : goto error;
1500 : : }
1501 : : return 0;
1502 : :
1503 : : error:
1504 : 0 : kfree(isopkt);
1505 : 0 : kfree(dr);
1506 [ # # ]: 0 : if (as)
1507 : 0 : free_async(as);
1508 : 0 : return ret;
1509 : : }
1510 : :
1511 : 0 : static int proc_submiturb(struct dev_state *ps, void __user *arg)
1512 : : {
1513 : : struct usbdevfs_urb uurb;
1514 : :
1515 [ # # ]: 0 : if (copy_from_user(&uurb, arg, sizeof(uurb)))
1516 : : return -EFAULT;
1517 : :
1518 : 0 : return proc_do_submiturb(ps, &uurb,
1519 : 0 : (((struct usbdevfs_urb __user *)arg)->iso_frame_desc),
1520 : : arg);
1521 : : }
1522 : :
1523 : 0 : static int proc_unlinkurb(struct dev_state *ps, void __user *arg)
1524 : : {
1525 : : struct urb *urb;
1526 : : struct async *as;
1527 : : unsigned long flags;
1528 : :
1529 : 0 : spin_lock_irqsave(&ps->lock, flags);
1530 : : as = async_getpending(ps, arg);
1531 [ # # ]: 0 : if (!as) {
1532 : : spin_unlock_irqrestore(&ps->lock, flags);
1533 : 0 : return -EINVAL;
1534 : : }
1535 : :
1536 : 0 : urb = as->urb;
1537 : 0 : usb_get_urb(urb);
1538 : : spin_unlock_irqrestore(&ps->lock, flags);
1539 : :
1540 : 0 : usb_kill_urb(urb);
1541 : 0 : usb_put_urb(urb);
1542 : :
1543 : 0 : return 0;
1544 : : }
1545 : :
1546 : 0 : static int processcompl(struct async *as, void __user * __user *arg)
1547 : : {
1548 : 0 : struct urb *urb = as->urb;
1549 : 0 : struct usbdevfs_urb __user *userurb = as->userurb;
1550 : : void __user *addr = as->userurb;
1551 : : unsigned int i;
1552 : :
1553 [ # # ][ # # ]: 0 : if (as->userbuffer && urb->actual_length) {
1554 [ # # ]: 0 : if (copy_urb_data_to_user(as->userbuffer, urb))
1555 : : goto err_out;
1556 : : }
1557 [ # # ]: 0 : if (put_user(as->status, &userurb->status))
1558 : : goto err_out;
1559 [ # # ]: 0 : if (put_user(urb->actual_length, &userurb->actual_length))
1560 : : goto err_out;
1561 [ # # ]: 0 : if (put_user(urb->error_count, &userurb->error_count))
1562 : : goto err_out;
1563 : :
1564 [ # # ]: 0 : if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1565 [ # # ]: 0 : for (i = 0; i < urb->number_of_packets; i++) {
1566 [ # # ]: 0 : if (put_user(urb->iso_frame_desc[i].actual_length,
1567 : : &userurb->iso_frame_desc[i].actual_length))
1568 : : goto err_out;
1569 [ # # ]: 0 : if (put_user(urb->iso_frame_desc[i].status,
1570 : : &userurb->iso_frame_desc[i].status))
1571 : : goto err_out;
1572 : : }
1573 : : }
1574 : :
1575 [ # # ]: 0 : if (put_user(addr, (void __user * __user *)arg))
1576 : : return -EFAULT;
1577 : 0 : return 0;
1578 : :
1579 : : err_out:
1580 : : return -EFAULT;
1581 : : }
1582 : :
1583 : 0 : static struct async *reap_as(struct dev_state *ps)
1584 : : {
1585 : 0 : DECLARE_WAITQUEUE(wait, current);
1586 : : struct async *as = NULL;
1587 : 0 : struct usb_device *dev = ps->dev;
1588 : :
1589 : 0 : add_wait_queue(&ps->wait, &wait);
1590 : : for (;;) {
1591 : 0 : __set_current_state(TASK_INTERRUPTIBLE);
1592 : 0 : as = async_getcompleted(ps);
1593 [ # # ]: 0 : if (as)
1594 : : break;
1595 [ # # ]: 0 : if (signal_pending(current))
1596 : : break;
1597 : : usb_unlock_device(dev);
1598 : 0 : schedule();
1599 : : usb_lock_device(dev);
1600 : : }
1601 : 0 : remove_wait_queue(&ps->wait, &wait);
1602 : 0 : set_current_state(TASK_RUNNING);
1603 : 0 : return as;
1604 : : }
1605 : :
1606 : 0 : static int proc_reapurb(struct dev_state *ps, void __user *arg)
1607 : : {
1608 : 0 : struct async *as = reap_as(ps);
1609 [ # # ]: 0 : if (as) {
1610 : 0 : int retval = processcompl(as, (void __user * __user *)arg);
1611 : 0 : free_async(as);
1612 : 0 : return retval;
1613 : : }
1614 [ # # ]: 0 : if (signal_pending(current))
1615 : : return -EINTR;
1616 : 0 : return -EIO;
1617 : : }
1618 : :
1619 : 0 : static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
1620 : : {
1621 : : int retval;
1622 : : struct async *as;
1623 : :
1624 : 0 : as = async_getcompleted(ps);
1625 : : retval = -EAGAIN;
1626 [ # # ]: 0 : if (as) {
1627 : 0 : retval = processcompl(as, (void __user * __user *)arg);
1628 : 0 : free_async(as);
1629 : : }
1630 : 0 : return retval;
1631 : : }
1632 : :
1633 : : #ifdef CONFIG_COMPAT
1634 : : static int proc_control_compat(struct dev_state *ps,
1635 : : struct usbdevfs_ctrltransfer32 __user *p32)
1636 : : {
1637 : : struct usbdevfs_ctrltransfer __user *p;
1638 : : __u32 udata;
1639 : : p = compat_alloc_user_space(sizeof(*p));
1640 : : if (copy_in_user(p, p32, (sizeof(*p32) - sizeof(compat_caddr_t))) ||
1641 : : get_user(udata, &p32->data) ||
1642 : : put_user(compat_ptr(udata), &p->data))
1643 : : return -EFAULT;
1644 : : return proc_control(ps, p);
1645 : : }
1646 : :
1647 : : static int proc_bulk_compat(struct dev_state *ps,
1648 : : struct usbdevfs_bulktransfer32 __user *p32)
1649 : : {
1650 : : struct usbdevfs_bulktransfer __user *p;
1651 : : compat_uint_t n;
1652 : : compat_caddr_t addr;
1653 : :
1654 : : p = compat_alloc_user_space(sizeof(*p));
1655 : :
1656 : : if (get_user(n, &p32->ep) || put_user(n, &p->ep) ||
1657 : : get_user(n, &p32->len) || put_user(n, &p->len) ||
1658 : : get_user(n, &p32->timeout) || put_user(n, &p->timeout) ||
1659 : : get_user(addr, &p32->data) || put_user(compat_ptr(addr), &p->data))
1660 : : return -EFAULT;
1661 : :
1662 : : return proc_bulk(ps, p);
1663 : : }
1664 : : static int proc_disconnectsignal_compat(struct dev_state *ps, void __user *arg)
1665 : : {
1666 : : struct usbdevfs_disconnectsignal32 ds;
1667 : :
1668 : : if (copy_from_user(&ds, arg, sizeof(ds)))
1669 : : return -EFAULT;
1670 : : ps->discsignr = ds.signr;
1671 : : ps->disccontext = compat_ptr(ds.context);
1672 : : return 0;
1673 : : }
1674 : :
1675 : : static int get_urb32(struct usbdevfs_urb *kurb,
1676 : : struct usbdevfs_urb32 __user *uurb)
1677 : : {
1678 : : __u32 uptr;
1679 : : if (!access_ok(VERIFY_READ, uurb, sizeof(*uurb)) ||
1680 : : __get_user(kurb->type, &uurb->type) ||
1681 : : __get_user(kurb->endpoint, &uurb->endpoint) ||
1682 : : __get_user(kurb->status, &uurb->status) ||
1683 : : __get_user(kurb->flags, &uurb->flags) ||
1684 : : __get_user(kurb->buffer_length, &uurb->buffer_length) ||
1685 : : __get_user(kurb->actual_length, &uurb->actual_length) ||
1686 : : __get_user(kurb->start_frame, &uurb->start_frame) ||
1687 : : __get_user(kurb->number_of_packets, &uurb->number_of_packets) ||
1688 : : __get_user(kurb->error_count, &uurb->error_count) ||
1689 : : __get_user(kurb->signr, &uurb->signr))
1690 : : return -EFAULT;
1691 : :
1692 : : if (__get_user(uptr, &uurb->buffer))
1693 : : return -EFAULT;
1694 : : kurb->buffer = compat_ptr(uptr);
1695 : : if (__get_user(uptr, &uurb->usercontext))
1696 : : return -EFAULT;
1697 : : kurb->usercontext = compat_ptr(uptr);
1698 : :
1699 : : return 0;
1700 : : }
1701 : :
1702 : : static int proc_submiturb_compat(struct dev_state *ps, void __user *arg)
1703 : : {
1704 : : struct usbdevfs_urb uurb;
1705 : :
1706 : : if (get_urb32(&uurb, (struct usbdevfs_urb32 __user *)arg))
1707 : : return -EFAULT;
1708 : :
1709 : : return proc_do_submiturb(ps, &uurb,
1710 : : ((struct usbdevfs_urb32 __user *)arg)->iso_frame_desc,
1711 : : arg);
1712 : : }
1713 : :
1714 : : static int processcompl_compat(struct async *as, void __user * __user *arg)
1715 : : {
1716 : : struct urb *urb = as->urb;
1717 : : struct usbdevfs_urb32 __user *userurb = as->userurb;
1718 : : void __user *addr = as->userurb;
1719 : : unsigned int i;
1720 : :
1721 : : if (as->userbuffer && urb->actual_length) {
1722 : : if (copy_urb_data_to_user(as->userbuffer, urb))
1723 : : return -EFAULT;
1724 : : }
1725 : : if (put_user(as->status, &userurb->status))
1726 : : return -EFAULT;
1727 : : if (put_user(urb->actual_length, &userurb->actual_length))
1728 : : return -EFAULT;
1729 : : if (put_user(urb->error_count, &userurb->error_count))
1730 : : return -EFAULT;
1731 : :
1732 : : if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1733 : : for (i = 0; i < urb->number_of_packets; i++) {
1734 : : if (put_user(urb->iso_frame_desc[i].actual_length,
1735 : : &userurb->iso_frame_desc[i].actual_length))
1736 : : return -EFAULT;
1737 : : if (put_user(urb->iso_frame_desc[i].status,
1738 : : &userurb->iso_frame_desc[i].status))
1739 : : return -EFAULT;
1740 : : }
1741 : : }
1742 : :
1743 : : if (put_user(ptr_to_compat(addr), (u32 __user *)arg))
1744 : : return -EFAULT;
1745 : : return 0;
1746 : : }
1747 : :
1748 : : static int proc_reapurb_compat(struct dev_state *ps, void __user *arg)
1749 : : {
1750 : : struct async *as = reap_as(ps);
1751 : : if (as) {
1752 : : int retval = processcompl_compat(as, (void __user * __user *)arg);
1753 : : free_async(as);
1754 : : return retval;
1755 : : }
1756 : : if (signal_pending(current))
1757 : : return -EINTR;
1758 : : return -EIO;
1759 : : }
1760 : :
1761 : : static int proc_reapurbnonblock_compat(struct dev_state *ps, void __user *arg)
1762 : : {
1763 : : int retval;
1764 : : struct async *as;
1765 : :
1766 : : retval = -EAGAIN;
1767 : : as = async_getcompleted(ps);
1768 : : if (as) {
1769 : : retval = processcompl_compat(as, (void __user * __user *)arg);
1770 : : free_async(as);
1771 : : }
1772 : : return retval;
1773 : : }
1774 : :
1775 : :
1776 : : #endif
1777 : :
1778 : 0 : static int proc_disconnectsignal(struct dev_state *ps, void __user *arg)
1779 : : {
1780 : : struct usbdevfs_disconnectsignal ds;
1781 : :
1782 [ # # ]: 0 : if (copy_from_user(&ds, arg, sizeof(ds)))
1783 : : return -EFAULT;
1784 : 0 : ps->discsignr = ds.signr;
1785 : 0 : ps->disccontext = ds.context;
1786 : : return 0;
1787 : : }
1788 : :
1789 : 0 : static int proc_claiminterface(struct dev_state *ps, void __user *arg)
1790 : : {
1791 : : unsigned int ifnum;
1792 : :
1793 [ # # ]: 0 : if (get_user(ifnum, (unsigned int __user *)arg))
1794 : : return -EFAULT;
1795 : 0 : return claimintf(ps, ifnum);
1796 : : }
1797 : :
1798 : 0 : static int proc_releaseinterface(struct dev_state *ps, void __user *arg)
1799 : : {
1800 : : unsigned int ifnum;
1801 : : int ret;
1802 : :
1803 [ # # ]: 0 : if (get_user(ifnum, (unsigned int __user *)arg))
1804 : : return -EFAULT;
1805 [ # # ]: 0 : if ((ret = releaseintf(ps, ifnum)) < 0)
1806 : : return ret;
1807 : 0 : destroy_async_on_interface (ps, ifnum);
1808 : 0 : return 0;
1809 : : }
1810 : :
1811 : 0 : static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
1812 : : {
1813 : : int size;
1814 : : void *buf = NULL;
1815 : : int retval = 0;
1816 : : struct usb_interface *intf = NULL;
1817 : : struct usb_driver *driver = NULL;
1818 : :
1819 : : /* alloc buffer */
1820 [ # # ]: 0 : if ((size = _IOC_SIZE(ctl->ioctl_code)) > 0) {
1821 : 0 : buf = kmalloc(size, GFP_KERNEL);
1822 [ # # ]: 0 : if (buf == NULL)
1823 : : return -ENOMEM;
1824 [ # # ]: 0 : if ((_IOC_DIR(ctl->ioctl_code) & _IOC_WRITE)) {
1825 [ # # ]: 0 : if (copy_from_user(buf, ctl->data, size)) {
1826 : 0 : kfree(buf);
1827 : 0 : return -EFAULT;
1828 : : }
1829 : : } else {
1830 [ # # ]: 0 : memset(buf, 0, size);
1831 : : }
1832 : : }
1833 : :
1834 [ # # ]: 0 : if (!connected(ps)) {
1835 : 0 : kfree(buf);
1836 : 0 : return -ENODEV;
1837 : : }
1838 : :
1839 [ # # ]: 0 : if (ps->dev->state != USB_STATE_CONFIGURED)
1840 : : retval = -EHOSTUNREACH;
1841 [ # # ]: 0 : else if (!(intf = usb_ifnum_to_if(ps->dev, ctl->ifno)))
1842 : : retval = -EINVAL;
1843 [ # # # ]: 0 : else switch (ctl->ioctl_code) {
1844 : :
1845 : : /* disconnect kernel driver from interface */
1846 : : case USBDEVFS_DISCONNECT:
1847 [ # # ]: 0 : if (intf->dev.driver) {
1848 : 0 : driver = to_usb_driver(intf->dev.driver);
1849 : : dev_dbg(&intf->dev, "disconnect by usbfs\n");
1850 : 0 : usb_driver_release_interface(driver, intf);
1851 : : } else
1852 : : retval = -ENODATA;
1853 : : break;
1854 : :
1855 : : /* let kernel drivers try to (re)bind to the interface */
1856 : : case USBDEVFS_CONNECT:
1857 [ # # ]: 0 : if (!intf->dev.driver)
1858 : 0 : retval = device_attach(&intf->dev);
1859 : : else
1860 : : retval = -EBUSY;
1861 : : break;
1862 : :
1863 : : /* talk directly to the interface's driver */
1864 : : default:
1865 [ # # ]: 0 : if (intf->dev.driver)
1866 : 0 : driver = to_usb_driver(intf->dev.driver);
1867 [ # # ][ # # ]: 0 : if (driver == NULL || driver->unlocked_ioctl == NULL) {
1868 : : retval = -ENOTTY;
1869 : : } else {
1870 : 0 : retval = driver->unlocked_ioctl(intf, ctl->ioctl_code, buf);
1871 [ # # ]: 0 : if (retval == -ENOIOCTLCMD)
1872 : : retval = -ENOTTY;
1873 : : }
1874 : : }
1875 : :
1876 : : /* cleanup and return */
1877 [ # # ]: 0 : if (retval >= 0
1878 [ # # ]: 0 : && (_IOC_DIR(ctl->ioctl_code) & _IOC_READ) != 0
1879 [ # # ]: 0 : && size > 0
1880 [ # # ]: 0 : && copy_to_user(ctl->data, buf, size) != 0)
1881 : : retval = -EFAULT;
1882 : :
1883 : 0 : kfree(buf);
1884 : 0 : return retval;
1885 : : }
1886 : :
1887 : 0 : static int proc_ioctl_default(struct dev_state *ps, void __user *arg)
1888 : : {
1889 : : struct usbdevfs_ioctl ctrl;
1890 : :
1891 [ # # ]: 0 : if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
1892 : : return -EFAULT;
1893 : 0 : return proc_ioctl(ps, &ctrl);
1894 : : }
1895 : :
1896 : : #ifdef CONFIG_COMPAT
1897 : : static int proc_ioctl_compat(struct dev_state *ps, compat_uptr_t arg)
1898 : : {
1899 : : struct usbdevfs_ioctl32 __user *uioc;
1900 : : struct usbdevfs_ioctl ctrl;
1901 : : u32 udata;
1902 : :
1903 : : uioc = compat_ptr((long)arg);
1904 : : if (!access_ok(VERIFY_READ, uioc, sizeof(*uioc)) ||
1905 : : __get_user(ctrl.ifno, &uioc->ifno) ||
1906 : : __get_user(ctrl.ioctl_code, &uioc->ioctl_code) ||
1907 : : __get_user(udata, &uioc->data))
1908 : : return -EFAULT;
1909 : : ctrl.data = compat_ptr(udata);
1910 : :
1911 : : return proc_ioctl(ps, &ctrl);
1912 : : }
1913 : : #endif
1914 : :
1915 : 0 : static int proc_claim_port(struct dev_state *ps, void __user *arg)
1916 : : {
1917 : : unsigned portnum;
1918 : : int rc;
1919 : :
1920 [ # # ]: 0 : if (get_user(portnum, (unsigned __user *) arg))
1921 : : return -EFAULT;
1922 : 0 : rc = usb_hub_claim_port(ps->dev, portnum, ps);
1923 [ # # ]: 0 : if (rc == 0)
1924 [ # # ]: 0 : snoop(&ps->dev->dev, "port %d claimed by process %d: %s\n",
1925 : : portnum, task_pid_nr(current), current->comm);
1926 : 0 : return rc;
1927 : : }
1928 : :
1929 : 0 : static int proc_release_port(struct dev_state *ps, void __user *arg)
1930 : : {
1931 : : unsigned portnum;
1932 : :
1933 [ # # ]: 0 : if (get_user(portnum, (unsigned __user *) arg))
1934 : : return -EFAULT;
1935 : 0 : return usb_hub_release_port(ps->dev, portnum, ps);
1936 : : }
1937 : :
1938 : 0 : static int proc_get_capabilities(struct dev_state *ps, void __user *arg)
1939 : : {
1940 : : __u32 caps;
1941 : :
1942 : : caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM;
1943 [ # # ]: 0 : if (!ps->dev->bus->no_stop_on_short)
1944 : : caps |= USBDEVFS_CAP_BULK_CONTINUATION;
1945 [ # # ]: 0 : if (ps->dev->bus->sg_tablesize)
1946 : 0 : caps |= USBDEVFS_CAP_BULK_SCATTER_GATHER;
1947 : :
1948 [ # # ]: 0 : if (put_user(caps, (__u32 __user *)arg))
1949 : : return -EFAULT;
1950 : :
1951 : : return 0;
1952 : : }
1953 : :
1954 : 0 : static int proc_disconnect_claim(struct dev_state *ps, void __user *arg)
1955 : : {
1956 : : struct usbdevfs_disconnect_claim dc;
1957 : : struct usb_interface *intf;
1958 : :
1959 [ # # ]: 0 : if (copy_from_user(&dc, arg, sizeof(dc)))
1960 : : return -EFAULT;
1961 : :
1962 : 0 : intf = usb_ifnum_to_if(ps->dev, dc.interface);
1963 [ # # ]: 0 : if (!intf)
1964 : : return -EINVAL;
1965 : :
1966 [ # # ]: 0 : if (intf->dev.driver) {
1967 : 0 : struct usb_driver *driver = to_usb_driver(intf->dev.driver);
1968 : :
1969 [ # # ][ # # ]: 0 : if ((dc.flags & USBDEVFS_DISCONNECT_CLAIM_IF_DRIVER) &&
1970 : 0 : strncmp(dc.driver, intf->dev.driver->name,
1971 : : sizeof(dc.driver)) != 0)
1972 : : return -EBUSY;
1973 : :
1974 [ # # ][ # # ]: 0 : if ((dc.flags & USBDEVFS_DISCONNECT_CLAIM_EXCEPT_DRIVER) &&
1975 : 0 : strncmp(dc.driver, intf->dev.driver->name,
1976 : : sizeof(dc.driver)) == 0)
1977 : : return -EBUSY;
1978 : :
1979 : : dev_dbg(&intf->dev, "disconnect by usbfs\n");
1980 : 0 : usb_driver_release_interface(driver, intf);
1981 : : }
1982 : :
1983 : 0 : return claimintf(ps, dc.interface);
1984 : : }
1985 : :
1986 : : /*
1987 : : * NOTE: All requests here that have interface numbers as parameters
1988 : : * are assuming that somehow the configuration has been prevented from
1989 : : * changing. But there's no mechanism to ensure that...
1990 : : */
1991 : 0 : static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
1992 : : void __user *p)
1993 : : {
1994 : 0 : struct dev_state *ps = file->private_data;
1995 : : struct inode *inode = file_inode(file);
1996 : 0 : struct usb_device *dev = ps->dev;
1997 : : int ret = -ENOTTY;
1998 : :
1999 [ # # ]: 0 : if (!(file->f_mode & FMODE_WRITE))
2000 : : return -EPERM;
2001 : :
2002 : : usb_lock_device(dev);
2003 [ # # ]: 0 : if (!connected(ps)) {
2004 : : usb_unlock_device(dev);
2005 : 0 : return -ENODEV;
2006 : : }
2007 : :
2008 [ # # # # : 0 : switch (cmd) {
# # # # #
# # # # #
# # # # #
# # # ]
2009 : : case USBDEVFS_CONTROL:
2010 [ # # ]: 0 : snoop(&dev->dev, "%s: CONTROL\n", __func__);
2011 : 0 : ret = proc_control(ps, p);
2012 [ # # ]: 0 : if (ret >= 0)
2013 : 0 : inode->i_mtime = CURRENT_TIME;
2014 : : break;
2015 : :
2016 : : case USBDEVFS_BULK:
2017 [ # # ]: 0 : snoop(&dev->dev, "%s: BULK\n", __func__);
2018 : 0 : ret = proc_bulk(ps, p);
2019 [ # # ]: 0 : if (ret >= 0)
2020 : 0 : inode->i_mtime = CURRENT_TIME;
2021 : : break;
2022 : :
2023 : : case USBDEVFS_RESETEP:
2024 [ # # ]: 0 : snoop(&dev->dev, "%s: RESETEP\n", __func__);
2025 : 0 : ret = proc_resetep(ps, p);
2026 [ # # ]: 0 : if (ret >= 0)
2027 : 0 : inode->i_mtime = CURRENT_TIME;
2028 : : break;
2029 : :
2030 : : case USBDEVFS_RESET:
2031 [ # # ]: 0 : snoop(&dev->dev, "%s: RESET\n", __func__);
2032 : : ret = proc_resetdevice(ps);
2033 : 0 : break;
2034 : :
2035 : : case USBDEVFS_CLEAR_HALT:
2036 [ # # ]: 0 : snoop(&dev->dev, "%s: CLEAR_HALT\n", __func__);
2037 : 0 : ret = proc_clearhalt(ps, p);
2038 [ # # ]: 0 : if (ret >= 0)
2039 : 0 : inode->i_mtime = CURRENT_TIME;
2040 : : break;
2041 : :
2042 : : case USBDEVFS_GETDRIVER:
2043 [ # # ]: 0 : snoop(&dev->dev, "%s: GETDRIVER\n", __func__);
2044 : 0 : ret = proc_getdriver(ps, p);
2045 : 0 : break;
2046 : :
2047 : : case USBDEVFS_CONNECTINFO:
2048 [ # # ]: 0 : snoop(&dev->dev, "%s: CONNECTINFO\n", __func__);
2049 : 0 : ret = proc_connectinfo(ps, p);
2050 : 0 : break;
2051 : :
2052 : : case USBDEVFS_SETINTERFACE:
2053 [ # # ]: 0 : snoop(&dev->dev, "%s: SETINTERFACE\n", __func__);
2054 : 0 : ret = proc_setintf(ps, p);
2055 : 0 : break;
2056 : :
2057 : : case USBDEVFS_SETCONFIGURATION:
2058 [ # # ]: 0 : snoop(&dev->dev, "%s: SETCONFIGURATION\n", __func__);
2059 : 0 : ret = proc_setconfig(ps, p);
2060 : 0 : break;
2061 : :
2062 : : case USBDEVFS_SUBMITURB:
2063 [ # # ]: 0 : snoop(&dev->dev, "%s: SUBMITURB\n", __func__);
2064 : 0 : ret = proc_submiturb(ps, p);
2065 [ # # ]: 0 : if (ret >= 0)
2066 : 0 : inode->i_mtime = CURRENT_TIME;
2067 : : break;
2068 : :
2069 : : #ifdef CONFIG_COMPAT
2070 : : case USBDEVFS_CONTROL32:
2071 : : snoop(&dev->dev, "%s: CONTROL32\n", __func__);
2072 : : ret = proc_control_compat(ps, p);
2073 : : if (ret >= 0)
2074 : : inode->i_mtime = CURRENT_TIME;
2075 : : break;
2076 : :
2077 : : case USBDEVFS_BULK32:
2078 : : snoop(&dev->dev, "%s: BULK32\n", __func__);
2079 : : ret = proc_bulk_compat(ps, p);
2080 : : if (ret >= 0)
2081 : : inode->i_mtime = CURRENT_TIME;
2082 : : break;
2083 : :
2084 : : case USBDEVFS_DISCSIGNAL32:
2085 : : snoop(&dev->dev, "%s: DISCSIGNAL32\n", __func__);
2086 : : ret = proc_disconnectsignal_compat(ps, p);
2087 : : break;
2088 : :
2089 : : case USBDEVFS_SUBMITURB32:
2090 : : snoop(&dev->dev, "%s: SUBMITURB32\n", __func__);
2091 : : ret = proc_submiturb_compat(ps, p);
2092 : : if (ret >= 0)
2093 : : inode->i_mtime = CURRENT_TIME;
2094 : : break;
2095 : :
2096 : : case USBDEVFS_REAPURB32:
2097 : : snoop(&dev->dev, "%s: REAPURB32\n", __func__);
2098 : : ret = proc_reapurb_compat(ps, p);
2099 : : break;
2100 : :
2101 : : case USBDEVFS_REAPURBNDELAY32:
2102 : : snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
2103 : : ret = proc_reapurbnonblock_compat(ps, p);
2104 : : break;
2105 : :
2106 : : case USBDEVFS_IOCTL32:
2107 : : snoop(&dev->dev, "%s: IOCTL32\n", __func__);
2108 : : ret = proc_ioctl_compat(ps, ptr_to_compat(p));
2109 : : break;
2110 : : #endif
2111 : :
2112 : : case USBDEVFS_DISCARDURB:
2113 [ # # ]: 0 : snoop(&dev->dev, "%s: DISCARDURB\n", __func__);
2114 : 0 : ret = proc_unlinkurb(ps, p);
2115 : 0 : break;
2116 : :
2117 : : case USBDEVFS_REAPURB:
2118 [ # # ]: 0 : snoop(&dev->dev, "%s: REAPURB\n", __func__);
2119 : 0 : ret = proc_reapurb(ps, p);
2120 : 0 : break;
2121 : :
2122 : : case USBDEVFS_REAPURBNDELAY:
2123 [ # # ]: 0 : snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
2124 : 0 : ret = proc_reapurbnonblock(ps, p);
2125 : 0 : break;
2126 : :
2127 : : case USBDEVFS_DISCSIGNAL:
2128 [ # # ]: 0 : snoop(&dev->dev, "%s: DISCSIGNAL\n", __func__);
2129 : 0 : ret = proc_disconnectsignal(ps, p);
2130 : 0 : break;
2131 : :
2132 : : case USBDEVFS_CLAIMINTERFACE:
2133 [ # # ]: 0 : snoop(&dev->dev, "%s: CLAIMINTERFACE\n", __func__);
2134 : 0 : ret = proc_claiminterface(ps, p);
2135 : 0 : break;
2136 : :
2137 : : case USBDEVFS_RELEASEINTERFACE:
2138 [ # # ]: 0 : snoop(&dev->dev, "%s: RELEASEINTERFACE\n", __func__);
2139 : 0 : ret = proc_releaseinterface(ps, p);
2140 : 0 : break;
2141 : :
2142 : : case USBDEVFS_IOCTL:
2143 [ # # ]: 0 : snoop(&dev->dev, "%s: IOCTL\n", __func__);
2144 : 0 : ret = proc_ioctl_default(ps, p);
2145 : 0 : break;
2146 : :
2147 : : case USBDEVFS_CLAIM_PORT:
2148 [ # # ]: 0 : snoop(&dev->dev, "%s: CLAIM_PORT\n", __func__);
2149 : 0 : ret = proc_claim_port(ps, p);
2150 : 0 : break;
2151 : :
2152 : : case USBDEVFS_RELEASE_PORT:
2153 [ # # ]: 0 : snoop(&dev->dev, "%s: RELEASE_PORT\n", __func__);
2154 : 0 : ret = proc_release_port(ps, p);
2155 : 0 : break;
2156 : : case USBDEVFS_GET_CAPABILITIES:
2157 : 0 : ret = proc_get_capabilities(ps, p);
2158 : 0 : break;
2159 : : case USBDEVFS_DISCONNECT_CLAIM:
2160 : 0 : ret = proc_disconnect_claim(ps, p);
2161 : 0 : break;
2162 : : }
2163 : : usb_unlock_device(dev);
2164 [ # # ]: 0 : if (ret >= 0)
2165 : 0 : inode->i_atime = CURRENT_TIME;
2166 : 0 : return ret;
2167 : : }
2168 : :
2169 : 0 : static long usbdev_ioctl(struct file *file, unsigned int cmd,
2170 : : unsigned long arg)
2171 : : {
2172 : : int ret;
2173 : :
2174 : 0 : ret = usbdev_do_ioctl(file, cmd, (void __user *)arg);
2175 : :
2176 : 0 : return ret;
2177 : : }
2178 : :
2179 : : #ifdef CONFIG_COMPAT
2180 : : static long usbdev_compat_ioctl(struct file *file, unsigned int cmd,
2181 : : unsigned long arg)
2182 : : {
2183 : : int ret;
2184 : :
2185 : : ret = usbdev_do_ioctl(file, cmd, compat_ptr(arg));
2186 : :
2187 : : return ret;
2188 : : }
2189 : : #endif
2190 : :
2191 : : /* No kernel lock - fine */
2192 : 0 : static unsigned int usbdev_poll(struct file *file,
2193 : : struct poll_table_struct *wait)
2194 : : {
2195 : 0 : struct dev_state *ps = file->private_data;
2196 : : unsigned int mask = 0;
2197 : :
2198 : 0 : poll_wait(file, &ps->wait, wait);
2199 [ # # ][ # # ]: 0 : if (file->f_mode & FMODE_WRITE && !list_empty(&ps->async_completed))
2200 : : mask |= POLLOUT | POLLWRNORM;
2201 [ # # ]: 0 : if (!connected(ps))
2202 : 0 : mask |= POLLERR | POLLHUP;
2203 : 0 : return mask;
2204 : : }
2205 : :
2206 : : const struct file_operations usbdev_file_operations = {
2207 : : .owner = THIS_MODULE,
2208 : : .llseek = usbdev_lseek,
2209 : : .read = usbdev_read,
2210 : : .poll = usbdev_poll,
2211 : : .unlocked_ioctl = usbdev_ioctl,
2212 : : #ifdef CONFIG_COMPAT
2213 : : .compat_ioctl = usbdev_compat_ioctl,
2214 : : #endif
2215 : : .open = usbdev_open,
2216 : : .release = usbdev_release,
2217 : : };
2218 : :
2219 : 0 : static void usbdev_remove(struct usb_device *udev)
2220 : : {
2221 : : struct dev_state *ps;
2222 : : struct siginfo sinfo;
2223 : :
2224 [ - + ]: 4 : while (!list_empty(&udev->filelist)) {
2225 : : ps = list_entry(udev->filelist.next, struct dev_state, list);
2226 : : destroy_all_async(ps);
2227 : 0 : wake_up_all(&ps->wait);
2228 : 2 : list_del_init(&ps->list);
2229 [ - - ]: 2 : if (ps->discsignr) {
2230 : 0 : sinfo.si_signo = ps->discsignr;
2231 : 0 : sinfo.si_errno = EPIPE;
2232 : 0 : sinfo.si_code = SI_ASYNCIO;
2233 : 0 : sinfo.si_addr = ps->disccontext;
2234 : 2 : kill_pid_info_as_cred(ps->discsignr, &sinfo,
2235 : : ps->disc_pid, ps->cred, ps->secid);
2236 : : }
2237 : : }
2238 : 2 : }
2239 : :
2240 : 0 : static int usbdev_notify(struct notifier_block *self,
2241 : : unsigned long action, void *dev)
2242 : : {
2243 [ + + ]: 4 : switch (action) {
2244 : : case USB_DEVICE_ADD:
2245 : : break;
2246 : : case USB_DEVICE_REMOVE:
2247 : 2 : usbdev_remove(dev);
2248 : 2 : break;
2249 : : }
2250 : 0 : return NOTIFY_OK;
2251 : : }
2252 : :
2253 : : static struct notifier_block usbdev_nb = {
2254 : : .notifier_call = usbdev_notify,
2255 : : };
2256 : :
2257 : : static struct cdev usb_device_cdev;
2258 : :
2259 : 0 : int __init usb_devio_init(void)
2260 : : {
2261 : : int retval;
2262 : :
2263 : 0 : retval = register_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX,
2264 : : "usb_device");
2265 [ # # ]: 0 : if (retval) {
2266 : 0 : printk(KERN_ERR "Unable to register minors for usb_device\n");
2267 : 0 : goto out;
2268 : : }
2269 : 0 : cdev_init(&usb_device_cdev, &usbdev_file_operations);
2270 : 0 : retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
2271 [ # # ]: 0 : if (retval) {
2272 : 0 : printk(KERN_ERR "Unable to get usb_device major %d\n",
2273 : : USB_DEVICE_MAJOR);
2274 : : goto error_cdev;
2275 : : }
2276 : 0 : usb_register_notify(&usbdev_nb);
2277 : : out:
2278 : 0 : return retval;
2279 : :
2280 : : error_cdev:
2281 : 0 : unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
2282 : 0 : goto out;
2283 : : }
2284 : :
2285 : 0 : void usb_devio_cleanup(void)
2286 : : {
2287 : 0 : usb_unregister_notify(&usbdev_nb);
2288 : 0 : cdev_del(&usb_device_cdev);
2289 : 0 : unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
2290 : 0 : }
|
