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