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