VirtualBox

source: vbox/trunk/src/VBox/Devices/USB/linux/USBProxyDevice-linux.cpp@ 47918

Last change on this file since 47918 was 46326, checked in by vboxsync, 12 years ago

RT_STR_TUPLE
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 66.0 KB
Line 
1/* $Id: USBProxyDevice-linux.cpp 46326 2013-05-30 12:16:53Z vboxsync $ */
2/** @file
3 * USB device proxy - the Linux backend.
4 */
5
6/*
7 * Copyright (C) 2006-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Defined Constants And Macros *
20*******************************************************************************/
21/** Define NO_PORT_RESET to skip the slow and broken linux port reset.
22 * Resetting will break PalmOne. */
23#define NO_PORT_RESET
24/** Define NO_LOGICAL_RECONNECT to skip the broken logical reconnect handling. */
25#define NO_LOGICAL_RECONNECT
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
32
33#include <iprt/stdint.h>
34#include <iprt/err.h>
35
36#include <sys/types.h>
37#include <sys/stat.h>
38#include <sys/vfs.h>
39#include <sys/ioctl.h>
40#include <sys/poll.h>
41#include <stdint.h>
42#include <stdio.h>
43#include <string.h>
44#include <stdlib.h>
45#include <limits.h>
46#include <unistd.h>
47#include <fcntl.h>
48#include <errno.h>
49#ifdef VBOX_WITH_LINUX_COMPILER_H
50# include <linux/compiler.h>
51#endif
52#include <linux/usbdevice_fs.h>
53/*
54 * Backlevel 2.4 headers doesn't have these two defines.
55 * They were added some time between 2.4.21 and 2.4.26, probably in 2.4.23.
56 */
57#ifndef USBDEVFS_DISCONNECT
58# define USBDEVFS_DISCONNECT _IO('U', 22)
59# define USBDEVFS_CONNECT _IO('U', 23)
60#endif
61
62#ifndef USBDEVFS_URB_SHORT_NOT_OK
63# define USBDEVFS_URB_SHORT_NOT_OK 0 /* rhel3 doesn't have this. darn! */
64#endif
65
66
67/* FedoraCore 4 does not have the bit defined by default. */
68#ifndef POLLWRNORM
69# define POLLWRNORM 0x0100
70#endif
71
72#ifndef RDESKTOP
73# include <VBox/vmm/pdm.h>
74#else
75# define RTCRITSECT void *
76static inline int rtcsNoop() { return VINF_SUCCESS; }
77# define RTCritSectInit(a) rtcsNoop()
78# define RTCritSectDelete(a) rtcsNoop()
79# define RTCritSectEnter(a) rtcsNoop()
80# define RTCritSectLeave(a) rtcsNoop()
81#endif
82#include <VBox/err.h>
83#include <VBox/log.h>
84#include <iprt/alloc.h>
85#include <iprt/assert.h>
86#include <iprt/asm.h>
87#include <iprt/ctype.h>
88#include <iprt/file.h>
89#include <iprt/linux/sysfs.h>
90#include <iprt/stream.h>
91#include <iprt/string.h>
92#if defined(NO_PORT_RESET) && !defined(NO_LOGICAL_RECONNECT)
93# include <iprt/thread.h>
94#endif
95#include <iprt/time.h>
96#include "../USBProxyDevice.h"
97
98/*******************************************************************************
99* Structures and Typedefs *
100*******************************************************************************/
101/**
102 * Wrapper around the linux urb request structure.
103 * This is required to track in-flight and landed URBs.
104 */
105typedef struct USBPROXYURBLNX
106{
107 /** The kernel URB data */
108 struct usbdevfs_urb KUrb;
109 /** Space filler for the isochronous packets. */
110 struct usbdevfs_iso_packet_desc aIsocPktsDonUseTheseUseTheOnesInKUrb[8];
111 /** The millisecond timestamp when this URB was submitted. */
112 uint64_t u64SubmitTS;
113 /** Pointer to the next linux URB. */
114 struct USBPROXYURBLNX *pNext;
115 /** Pointer to the previous linux URB. */
116 struct USBPROXYURBLNX *pPrev;
117 /** If we've split the VUSBURB up into multiple linux URBs, this is points to the head. */
118 struct USBPROXYURBLNX *pSplitHead;
119 /** The next linux URB if split up. */
120 struct USBPROXYURBLNX *pSplitNext;
121 /** Whether it has timed out and should be shot down on the next failing reap call. */
122 bool fTimedOut;
123 /** Indicates that this URB has been canceled by timeout and should return an CRC error. */
124 bool fCanceledByTimedOut;
125 /** Don't report these back. */
126 bool fCanceledBySubmit;
127 /** This split element is reaped. */
128 bool fSplitElementReaped;
129 /** Size to transfer in remaining fragments of a split URB */
130 uint32_t cbSplitRemaining;
131} USBPROXYURBLNX, *PUSBPROXYURBLNX;
132
133/**
134 * Data for the linux usb proxy backend.
135 */
136typedef struct USBPROXYDEVLNX
137{
138 /** The open file. */
139 RTFILE hFile;
140 /** Critical section protecting the two lists. */
141 RTCRITSECT CritSect;
142 /** The list of free linux URBs. Singly linked. */
143 PUSBPROXYURBLNX pFreeHead;
144 /** The list of active linux URBs. Doubly linked.
145 * We must maintain this so we can properly reap URBs of a detached device.
146 * Only the split head will appear in this list. */
147 PUSBPROXYURBLNX pInFlightHead;
148 /** The list of landed linux URBs. Doubly linked.
149 * Only the split head will appear in this list. */
150 PUSBPROXYURBLNX pTaxingHead;
151 /** The tail of the landed linux URBs. */
152 PUSBPROXYURBLNX pTaxingTail;
153 /** Are we using sysfs to find the active configuration? */
154 bool fUsingSysfs;
155 /** The device node/sysfs path of the device.
156 * Used to figure out the configuration after a reset. */
157 char szPath[1];
158} USBPROXYDEVLNX, *PUSBPROXYDEVLNX;
159
160
161/*******************************************************************************
162* Internal Functions *
163*******************************************************************************/
164static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries);
165static void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev);
166static void usbProxyLinuxSetConnected(PUSBPROXYDEV pProyxDev, int iIf, bool fConnect, bool fQuiet);
167static PUSBPROXYURBLNX usbProxyLinuxUrbAlloc(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pSplitHead);
168static void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
169static void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx);
170static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg);
171
172
173
174/**
175 * Wrapper for the ioctl call.
176 *
177 * This wrapper will repeat the call if we get an EINTR or EAGAIN. It can also
178 * handle ENODEV (detached device) errors.
179 *
180 * @returns whatever ioctl returns.
181 * @param pProxyDev The proxy device.
182 * @param iCmd The ioctl command / function.
183 * @param pvArg The ioctl argument / data.
184 * @param fHandleNoDev Whether to handle ENODEV.
185 * @param cTries The number of retries. Use UINT32_MAX for (kind of) indefinite retries.
186 * @internal
187 */
188static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries)
189{
190 int rc;
191 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
192 do
193 {
194 do
195 {
196 rc = ioctl(RTFileToNative(pDevLnx->hFile), iCmd, pvArg);
197 if (rc >= 0)
198 return rc;
199 } while (errno == EINTR);
200
201 if (errno == ENODEV && fHandleNoDev)
202 {
203 usbProxLinuxUrbUnplugged(pProxyDev);
204 Log(("usb-linux: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
205 errno = ENODEV;
206 break;
207 }
208 if (errno != EAGAIN)
209 break;
210 } while (cTries-- > 0);
211
212 return rc;
213}
214
215
216/**
217 * The device has been unplugged.
218 * Cancel all in-flight URBs and put them up for reaping.
219 */
220static void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev)
221{
222 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
223
224 /*
225 * Shoot down all flying URBs.
226 */
227 RTCritSectEnter(&pDevLnx->CritSect);
228 pProxyDev->fDetached = true;
229
230 PUSBPROXYURBLNX pUrbTaxing = NULL;
231 PUSBPROXYURBLNX pUrbLnx = pDevLnx->pInFlightHead;
232 pDevLnx->pInFlightHead = NULL;
233 while (pUrbLnx)
234 {
235 PUSBPROXYURBLNX pCur = pUrbLnx;
236 pUrbLnx = pUrbLnx->pNext;
237
238 ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_DISCARDURB, &pCur->KUrb); /* not sure if this is required.. */
239 if (!pCur->KUrb.status)
240 pCur->KUrb.status = -ENODEV;
241
242 /* insert into the taxing list. */
243 pCur->pPrev = NULL;
244 if ( !pCur->pSplitHead
245 || pCur == pCur->pSplitHead)
246 {
247 pCur->pNext = pUrbTaxing;
248 if (pUrbTaxing)
249 pUrbTaxing->pPrev = pCur;
250 pUrbTaxing = pCur;
251 }
252 else
253 pCur->pNext = NULL;
254 }
255
256 /* Append the URBs we shot down to the taxing queue. */
257 if (pUrbTaxing)
258 {
259 pUrbTaxing->pPrev = pDevLnx->pTaxingTail;
260 if (pUrbTaxing->pPrev)
261 pUrbTaxing->pPrev->pNext = pUrbTaxing;
262 else
263 pDevLnx->pTaxingTail = pDevLnx->pTaxingHead = pUrbTaxing;
264 }
265
266 RTCritSectLeave(&pDevLnx->CritSect);
267}
268
269
270/**
271 * Set the connect state seen by kernel drivers
272 * @internal
273 */
274static void usbProxyLinuxSetConnected(PUSBPROXYDEV pProxyDev, int iIf, bool fConnect, bool fQuiet)
275{
276 if ( iIf >= 32
277 || !(pProxyDev->fMaskedIfs & RT_BIT(iIf)))
278 {
279 struct usbdevfs_ioctl IoCtl;
280 if (!fQuiet)
281 LogFlow(("usbProxyLinuxSetConnected: pProxyDev=%s iIf=%#x fConnect=%s\n",
282 usbProxyGetName(pProxyDev), iIf, fConnect ? "true" : "false"));
283
284 IoCtl.ifno = iIf;
285 IoCtl.ioctl_code = fConnect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT;
286 IoCtl.data = NULL;
287 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_IOCTL, &IoCtl, true, UINT32_MAX)
288 && !fQuiet)
289 Log(("usbProxyLinuxSetConnected: failure, errno=%d. pProxyDev=%s\n",
290 errno, usbProxyGetName(pProxyDev)));
291 }
292}
293
294
295/**
296 * Allocates a linux URB request structure.
297 * @returns Pointer to an active URB request.
298 * @returns NULL on failure.
299 * @param pProxyDev The proxy device instance.
300 * @param pSplitHead The split list head if allocating for a split list.
301 */
302static PUSBPROXYURBLNX usbProxyLinuxUrbAlloc(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pSplitHead)
303{
304 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
305 PUSBPROXYURBLNX pUrbLnx;
306
307 RTCritSectEnter(&pDevLnx->CritSect);
308
309 /*
310 * Try remove a linux URB from the free list, if none there allocate a new one.
311 */
312 pUrbLnx = pDevLnx->pFreeHead;
313 if (pUrbLnx)
314 pDevLnx->pFreeHead = pUrbLnx->pNext;
315 else
316 {
317 RTCritSectLeave(&pDevLnx->CritSect);
318 pUrbLnx = (PUSBPROXYURBLNX)RTMemAlloc(sizeof(*pUrbLnx));
319 if (!pUrbLnx)
320 return NULL;
321 RTCritSectEnter(&pDevLnx->CritSect);
322 }
323 pUrbLnx->pSplitHead = pSplitHead;
324 pUrbLnx->pSplitNext = NULL;
325 pUrbLnx->fTimedOut = false;
326 pUrbLnx->fCanceledByTimedOut = false;
327 pUrbLnx->fCanceledBySubmit = false;
328 pUrbLnx->fSplitElementReaped = false;
329
330 /*
331 * Link it into the active list
332 */
333 if (!pSplitHead)
334 {
335 pUrbLnx->pPrev = NULL;
336 pUrbLnx->pNext = pDevLnx->pInFlightHead;
337 if (pUrbLnx->pNext)
338 pUrbLnx->pNext->pPrev = pUrbLnx;
339 pDevLnx->pInFlightHead = pUrbLnx;
340 }
341 else
342 pUrbLnx->pPrev = pUrbLnx->pNext = (PUSBPROXYURBLNX)0xdead;
343
344 RTCritSectLeave(&pDevLnx->CritSect);
345 return pUrbLnx;
346}
347
348
349/**
350 * Frees a linux URB request structure.
351 *
352 * @param pProxyDev The proxy device instance.
353 * @param pUrbLnx The linux URB to free.
354 */
355static void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
356{
357 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
358
359 RTCritSectEnter(&pDevLnx->CritSect);
360
361 /*
362 * Remove from the active list.
363 */
364 if ( !pUrbLnx->pSplitHead
365 || pUrbLnx->pSplitHead == pUrbLnx)
366 {
367 if (pUrbLnx->pNext)
368 pUrbLnx->pNext->pPrev = pUrbLnx->pPrev;
369 if (pUrbLnx->pPrev)
370 pUrbLnx->pPrev->pNext = pUrbLnx->pNext;
371 else
372 pDevLnx->pInFlightHead = pUrbLnx->pNext;
373 }
374 pUrbLnx->pSplitHead = pUrbLnx->pSplitNext = NULL;
375
376 /*
377 * Link it into the free list.
378 */
379 pUrbLnx->pPrev = NULL;
380 pUrbLnx->pNext = pDevLnx->pFreeHead;
381 pDevLnx->pFreeHead = pUrbLnx;
382
383 RTCritSectLeave(&pDevLnx->CritSect);
384}
385
386
387/**
388 * Frees split list of a linux URB request structure.
389 *
390 * @param pProxyDev The proxy device instance.
391 * @param pUrbLnx A linux URB to in the split list to be freed.
392 */
393static void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
394{
395 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
396
397 RTCritSectEnter(&pDevLnx->CritSect);
398
399 pUrbLnx = pUrbLnx->pSplitHead;
400 Assert(pUrbLnx);
401 while (pUrbLnx)
402 {
403 PUSBPROXYURBLNX pFree = pUrbLnx;
404 pUrbLnx = pUrbLnx->pSplitNext;
405 Assert(pFree->pSplitHead);
406 usbProxyLinuxUrbFree(pProxyDev, pFree);
407 }
408
409 RTCritSectLeave(&pDevLnx->CritSect);
410}
411
412
413/**
414 * This finds the device in the /proc/bus/usb/bus/addr file and finds
415 * the config with an asterix.
416 *
417 * @returns The Cfg#.
418 * @returns -1 if no active config.
419 * @param pszDevNode The path to the device. We infere the location of
420 * the devices file, which bus and device number we're
421 * looking for.
422 * @param iFirstCfg The first configuration. (optional)
423 * @internal
424 */
425static int usbProxyLinuxFindActiveConfigUsbfs(PUSBPROXYDEV pProxyDev, const char *pszDevNode, int *piFirstCfg)
426{
427 /*
428 * Set return defaults.
429 */
430 int iActiveCfg = -1;
431 if (piFirstCfg)
432 *piFirstCfg = 1;
433
434 /*
435 * Parse the usbfs device node path and turn it into a path to the "devices" file,
436 * picking up the device number and bus along the way.
437 */
438 size_t cchDevNode = strlen(pszDevNode);
439 char *pszDevices = (char *)RTMemDupEx(pszDevNode, cchDevNode, sizeof("devices"));
440 AssertReturn(pszDevices, iActiveCfg);
441
442 /* the device number */
443 char *psz = pszDevices + cchDevNode;
444 while (*psz != '/')
445 psz--;
446 Assert(pszDevices < psz);
447 uint32_t uDev;
448 int rc = RTStrToUInt32Ex(psz + 1, NULL, 10, &uDev);
449 if (RT_SUCCESS(rc))
450 {
451 /* the bus number */
452 *psz-- = '\0';
453 while (*psz != '/')
454 psz--;
455 Assert(pszDevices < psz);
456 uint32_t uBus;
457 rc = RTStrToUInt32Ex(psz + 1, NULL, 10, &uBus);
458 if (RT_SUCCESS(rc))
459 {
460 strcpy(psz + 1, "devices");
461
462 /*
463 * Open and scan the devices file.
464 * We're ASSUMING that each device starts off with a 'T:' line.
465 */
466 PRTSTREAM pFile;
467 rc = RTStrmOpen(pszDevices, "r", &pFile);
468 if (RT_SUCCESS(rc))
469 {
470 char szLine[1024];
471 while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
472 {
473 /* we're only interested in 'T:' lines. */
474 psz = RTStrStripL(szLine);
475 if (psz[0] != 'T' || psz[1] != ':')
476 continue;
477
478 /* Skip ahead to 'Bus' and compare */
479 psz = RTStrStripL(psz + 2); Assert(!strncmp(psz, RT_STR_TUPLE("Bus=")));
480 psz = RTStrStripL(psz + 4);
481 char *pszNext;
482 uint32_t u;
483 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
484 if (RT_FAILURE(rc))
485 continue;
486 if (u != uBus)
487 continue;
488
489 /* Skip ahead to 'Dev#' and compare */
490 psz = strstr(psz, "Dev#="); Assert(psz);
491 if (!psz)
492 continue;
493 psz = RTStrStripL(psz + 5);
494 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
495 if (RT_FAILURE(rc))
496 continue;
497 if (u != uDev)
498 continue;
499
500 /*
501 * Ok, we've found the device.
502 * Scan until we find a selected configuration, the next device, or EOF.
503 */
504 while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
505 {
506 psz = RTStrStripL(szLine);
507 if (psz[0] == 'T')
508 break;
509 if (psz[0] != 'C' || psz[1] != ':')
510 continue;
511 const bool fActive = psz[2] == '*';
512 if (!fActive && !piFirstCfg)
513 continue;
514
515 /* Get the 'Cfg#' value. */
516 psz = strstr(psz, "Cfg#="); Assert(psz);
517 if (psz)
518 {
519 psz = RTStrStripL(psz + 5);
520 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
521 if (RT_SUCCESS(rc))
522 {
523 if (piFirstCfg)
524 {
525 *piFirstCfg = u;
526 piFirstCfg = NULL;
527 }
528 if (fActive)
529 iActiveCfg = u;
530 }
531 }
532 if (fActive)
533 break;
534 }
535 break;
536 }
537 RTStrmClose(pFile);
538 }
539 }
540 }
541 RTMemFree(pszDevices);
542
543 return iActiveCfg;
544}
545
546
547/**
548 * This finds the active configuration from sysfs.
549 *
550 * @returns The Cfg#.
551 * @returns -1 if no active config.
552 * @param pszPath The sysfs path for the device.
553 * @param piFirstCfg The first configuration. (optional)
554 * @internal
555 */
556static int usbProxyLinuxFindActiveConfigSysfs(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
557{
558#ifdef VBOX_USB_WITH_SYSFS
559 if (piFirstCfg != NULL)
560 *piFirstCfg = pProxyDev->paCfgDescs != NULL
561 ? pProxyDev->paCfgDescs[0].Core.bConfigurationValue
562 : 1;
563 return RTLinuxSysFsReadIntFile(10, "%s/bConfigurationValue", pszPath); /* returns -1 on failure */
564#else /* !VBOX_USB_WITH_SYSFS */
565 return -1;
566#endif /* !VBOX_USB_WITH_SYSFS */
567}
568
569
570/**
571 * This finds the active configuration.
572 *
573 * @returns The Cfg#.
574 * @returns -1 if no active config.
575 * @param pszPath The sysfs path for the device, or the usbfs device
576 * node path.
577 * @param iFirstCfg The first configuration. (optional)
578 * @internal
579 */
580static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
581{
582 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
583 if (pDevLnx->fUsingSysfs)
584 return usbProxyLinuxFindActiveConfigSysfs(pProxyDev, pszPath, piFirstCfg);
585 return usbProxyLinuxFindActiveConfigUsbfs(pProxyDev, pszPath, piFirstCfg);
586}
587
588
589/**
590 * Extracts the Linux file descriptor associated with the kernel USB device.
591 * This is used by rdesktop-vrdp for polling for events.
592 * @returns the FD, or asserts and returns -1 on error
593 * @param pProxyDev The device instance
594 */
595RTDECL(int) USBProxyDeviceLinuxGetFD(PUSBPROXYDEV pProxyDev)
596{
597 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
598 AssertReturn(pDevLnx->hFile != NIL_RTFILE, -1);
599 return RTFileToNative(pDevLnx->hFile);
600}
601
602
603/**
604 * Opens the device file.
605 *
606 * @returns VBox status code.
607 * @param pProxyDev The device instance.
608 * @param pszAddress If we are using usbfs, this is the path to the
609 * device. If we are using sysfs, this is a string of
610 * the form "sysfs:<sysfs path>//device:<device node>".
611 * In the second case, the two paths are guaranteed
612 * not to contain the substring "//".
613 * @param pvBackend Backend specific pointer, unused for the linux backend.
614 */
615static int usbProxyLinuxOpen(PUSBPROXYDEV pProxyDev, const char *pszAddress, void *pvBackend)
616{
617 LogFlow(("usbProxyLinuxOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
618 const char *pszDevNode;
619 const char *pszPath;
620 size_t cchPath;
621 bool fUsingSysfs;
622
623 /*
624 * Are we using sysfs or usbfs?
625 */
626#ifdef VBOX_USB_WITH_SYSFS
627 fUsingSysfs = strncmp(pszAddress, RT_STR_TUPLE("sysfs:")) == 0;
628 if (fUsingSysfs)
629 {
630 pszDevNode = strstr(pszAddress, "//device:");
631 if (!pszDevNode)
632 {
633 LogRel(("usbProxyLinuxOpen: Invalid device address: '%s'\n", pszAddress));
634 pProxyDev->Backend.pv = NULL;
635 return VERR_INVALID_PARAMETER;
636 }
637
638 pszPath = pszAddress + sizeof("sysfs:") - 1;
639 cchPath = pszDevNode - pszPath;
640 pszDevNode += sizeof("//device:") - 1;
641 }
642 else
643#endif /* VBOX_USB_WITH_SYSFS */
644 {
645#ifndef VBOX_USB_WITH_SYSFS
646 fUsingSysfs = false;
647#endif
648 pszPath = pszDevNode = pszAddress;
649 cchPath = strlen(pszPath);
650 }
651
652 /*
653 * Try open the device node.
654 */
655 RTFILE hFile;
656 int rc = RTFileOpen(&hFile, pszDevNode, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
657 if (RT_SUCCESS(rc))
658 {
659 /*
660 * Allocate and initialize the linux backend data.
661 */
662 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)RTMemAllocZVar(sizeof(*pDevLnx) + cchPath);
663 if (pDevLnx)
664 {
665 pDevLnx->fUsingSysfs = fUsingSysfs;
666 memcpy(&pDevLnx->szPath[0], pszPath, cchPath);
667 pDevLnx->szPath[cchPath] = '\0';
668 pDevLnx->hFile = hFile;
669 rc = RTCritSectInit(&pDevLnx->CritSect);
670 if (RT_SUCCESS(rc))
671 {
672 pProxyDev->Backend.pv = pDevLnx;
673
674 LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%RTfile iActiveCfg=%d\n",
675 pProxyDev, pszAddress, pDevLnx->hFile, pProxyDev->iActiveCfg));
676
677 return VINF_SUCCESS;
678 }
679
680 RTMemFree(pDevLnx);
681 }
682 else
683 rc = VERR_NO_MEMORY;
684 RTFileClose(hFile);
685 }
686 else if (rc == VERR_ACCESS_DENIED)
687 rc = VERR_VUSB_USBFS_PERMISSION;
688
689 Log(("usbProxyLinuxOpen(%p, %s) failed, rc=%s!\n", pProxyDev, pszAddress,
690 RTErrGetShort(rc)));
691 pProxyDev->Backend.pv = NULL;
692
693 NOREF(pvBackend);
694 return rc;
695}
696
697
698/**
699 * Claims all the interfaces and figures out the
700 * current configuration.
701 *
702 * @returns VINF_SUCCESS.
703 * @param pProxyDev The proxy device.
704 */
705static int usbProxyLinuxInit(PUSBPROXYDEV pProxyDev)
706{
707 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
708
709 /*
710 * Brute force rulez.
711 * usbProxyLinuxSetConnected check for masked interfaces.
712 */
713 unsigned iIf;
714 for (iIf = 0; iIf < 256; iIf++)
715 usbProxyLinuxSetConnected(pProxyDev, iIf, false, true);
716
717 /*
718 * Determine the active configuration.
719 *
720 * If there isn't any active configuration, we will get EHOSTUNREACH (113) errors
721 * when trying to read the device descriptors in usbProxyDevCreate. So, we'll make
722 * the first one active (usually 1) then.
723 */
724 pProxyDev->cIgnoreSetConfigs = 1;
725 int iFirstCfg;
726 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, &iFirstCfg);
727 if (pProxyDev->iActiveCfg == -1)
728 {
729 usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iFirstCfg, false, UINT32_MAX);
730 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, NULL);
731 Log(("usbProxyLinuxInit: No active config! Tried to set %d: iActiveCfg=%d\n", iFirstCfg, pProxyDev->iActiveCfg));
732 }
733 else
734 Log(("usbProxyLinuxInit(%p): iActiveCfg=%d\n", pProxyDev, pProxyDev->iActiveCfg));
735 return VINF_SUCCESS;
736}
737
738
739/**
740 * Closes the proxy device.
741 */
742static void usbProxyLinuxClose(PUSBPROXYDEV pProxyDev)
743{
744 LogFlow(("usbProxyLinuxClose: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
745 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
746 Assert(pDevLnx);
747 if (!pDevLnx)
748 return;
749
750 /*
751 * Try put the device in a state which linux can cope with before we release it.
752 * Resetting it would be a nice start, although we must remember
753 * that it might have been disconnected...
754 *
755 * Don't reset if we're masking interfaces or if construction failed.
756 */
757 if (pProxyDev->fInited)
758 {
759 /* ASSUMES: thread == EMT */
760 if ( pProxyDev->fMaskedIfs
761 || !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
762 {
763 /* Connect drivers. */
764 unsigned iIf;
765 for (iIf = 0; iIf < 256; iIf++)
766 usbProxyLinuxSetConnected(pProxyDev, iIf, true, true);
767 LogRel(("USB: Successfully reset device pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
768 }
769 else if (errno != ENODEV)
770 LogRel(("USB: Reset failed, errno=%d, pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
771 else
772 Log(("USB: Reset failed, errno=%d (ENODEV), pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
773 }
774
775 /*
776 * Now we can free all the resources and close the device.
777 */
778 RTCritSectDelete(&pDevLnx->CritSect);
779
780 PUSBPROXYURBLNX pUrbLnx;
781 while ((pUrbLnx = pDevLnx->pInFlightHead) != NULL)
782 {
783 pDevLnx->pInFlightHead = pUrbLnx->pNext;
784 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX)
785 && errno != ENODEV
786 && errno != ENOENT)
787 AssertMsgFailed(("errno=%d\n", errno));
788 if (pUrbLnx->pSplitHead)
789 {
790 PUSBPROXYURBLNX pCur = pUrbLnx->pSplitNext;
791 while (pCur)
792 {
793 PUSBPROXYURBLNX pFree = pCur;
794 pCur = pFree->pSplitNext;
795 if ( !pFree->fSplitElementReaped
796 && usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pFree->KUrb, false, UINT32_MAX)
797 && errno != ENODEV
798 && errno != ENOENT)
799 AssertMsgFailed(("errno=%d\n", errno));
800 RTMemFree(pFree);
801 }
802 }
803 else
804 Assert(!pUrbLnx->pSplitNext);
805 RTMemFree(pUrbLnx);
806 }
807
808 while ((pUrbLnx = pDevLnx->pFreeHead) != NULL)
809 {
810 pDevLnx->pFreeHead = pUrbLnx->pNext;
811 RTMemFree(pUrbLnx);
812 }
813
814 RTFileClose(pDevLnx->hFile);
815 pDevLnx->hFile = NIL_RTFILE;
816
817 RTMemFree(pDevLnx);
818 pProxyDev->Backend.pv = NULL;
819 LogFlow(("usbProxyLinuxClose: returns\n"));
820}
821
822
823#if defined(NO_PORT_RESET) && !defined(NO_LOGICAL_RECONNECT)
824/**
825 * Look for the logically reconnected device.
826 * After 5 seconds we'll give up.
827 *
828 * @returns VBox status code.
829 * @thread Reset thread or EMT.
830 */
831static int usb_reset_logical_reconnect(PUSBPROXYDEV pDev)
832{
833 FILE * pFile;
834 uint64_t u64StartTS = RTTimeMilliTS();
835
836 Log2(("usb_reset_logical_reconnect: pDev=%p:{.bBus=%#x, .bDevNum=%#x, .idVendor=%#x, .idProduct=%#x, .bcdDevice=%#x, .u64SerialHash=%#llx .bDevNumParent=%#x .bPort=%#x .bLevel=%#x}\n",
837 pDev, pDev->Info.bBus, pDev->Info.bDevNum, pDev->Info.idVendor, pDev->Info.idProduct, pDev->Info.bcdDevice,
838 pDev->Info.u64SerialHash, pDev->Info.bDevNumParent, pDev->Info.bPort, pDev->Info.bLevel));
839
840 /* First, let hubd get a chance to logically reconnect the device. */
841 if (!RTThreadYield())
842 RTThreadSleep(1);
843
844 /*
845 * Search for the new device address.
846 */
847 pFile = get_devices_file();
848 if (!pFile)
849 return VERR_FILE_NOT_FOUND;
850
851 /*
852 * Loop until found or 5seconds have elapsed.
853 */
854 for (;;) {
855 struct pollfd pfd;
856 uint8_t tmp;
857 int rc;
858 char buf[512];
859 uint64_t u64Elapsed;
860 int got = 0;
861 struct usb_dev_entry id = {0};
862
863 /*
864 * Since this is kernel ABI we don't need to be too fussy about
865 * the parsing.
866 */
867 while (fgets(buf, sizeof(buf), pFile)) {
868 char *psz = strchr(buf, '\n');
869 if ( psz == NULL ) {
870 AssertMsgFailed(("usb_reset_logical_reconnect: Line to long!!\n"));
871 break;
872 }
873 *psz = '\0';
874
875 switch ( buf[0] ) {
876 case 'T': /* topology */
877 /* Check if we've got enough for a device. */
878 if (got >= 2) {
879 Log2(("usb_reset_logical_reconnect: {.bBus=%#x, .bDevNum=%#x, .idVendor=%#x, .idProduct=%#x, .bcdDevice=%#x, .u64SerialHash=%#llx, .bDevNumParent=%#x, .bPort=%#x, .bLevel=%#x}\n",
880 id.bBus, id.bDevNum, id.idVendor, id.idProduct, id.bcdDevice, id.u64SerialHash, id.bDevNumParent, id.bPort, id.bLevel));
881 if ( id.bDevNumParent == pDev->Info.bDevNumParent
882 && id.idVendor == pDev->Info.idVendor
883 && id.idProduct == pDev->Info.idProduct
884 && id.bcdDevice == pDev->Info.bcdDevice
885 && id.u64SerialHash == pDev->Info.u64SerialHash
886 && id.bBus == pDev->Info.bBus
887 && id.bPort == pDev->Info.bPort
888 && id.bLevel == pDev->Info.bLevel) {
889 goto l_found;
890 }
891 }
892
893 /* restart */
894 got = 0;
895 memset(&id, 0, sizeof(id));
896
897 /*T: Bus=04 Lev=02 Prnt=02 Port=00 Cnt=01 Dev#= 3 Spd=1.5 MxCh= 0*/
898 Log2(("usb_reset_logical_reconnect: %s\n", buf));
899 buf[10] = '\0';
900 if ( !get_u8(buf + 8, &id.bBus) )
901 break;
902 buf[49] = '\0';
903 psz = buf + 46;
904 while ( *psz == ' ' )
905 psz++;
906 if ( !get_u8(psz, &id.bDevNum) )
907 break;
908
909 buf[17] = '\0';
910 if ( !get_u8(buf + 15, &id.bLevel) )
911 break;
912 buf[25] = '\0';
913 if ( !get_u8(buf + 23, &id.bDevNumParent) )
914 break;
915 buf[33] = '\0';
916 if ( !get_u8(buf + 31, &id.bPort) )
917 break;
918 got++;
919 break;
920
921 case 'P': /* product */
922 Log2(("usb_reset_logical_reconnect: %s\n", buf));
923 buf[15] = '\0';
924 if ( !get_x16(buf + 11, &id.idVendor) )
925 break;
926 buf[27] = '\0';
927 if ( !get_x16(buf + 23, &id.idProduct) )
928 break;
929 buf[34] = '\0';
930 if ( buf[32] == ' ' )
931 buf[32] = '0';
932 id.bcdDevice = 0;
933 if ( !get_x8(buf + 32, &tmp) )
934 break;
935 id.bcdDevice = tmp << 8;
936 if ( !get_x8(buf + 35, &tmp) )
937 break;
938 id.bcdDevice |= tmp;
939 got++;
940 break;
941
942 case 'S': /* String descriptor */
943 /* Skip past "S:" and then the whitespace */
944 for(psz = buf + 2; *psz != '\0'; psz++)
945 if ( !RT_C_IS_SPACE(*psz) )
946 break;
947
948 /* If it is a serial number string, skip past
949 * "SerialNumber="
950 */
951 if (strncmp(psz, RT_STR_TUPLE("SerialNumber=")))
952 break;
953
954 Log2(("usb_reset_logical_reconnect: %s\n", buf));
955 psz += sizeof("SerialNumber=") - 1;
956
957 usb_serial_hash(psz, &id.u64SerialHash);
958 break;
959 }
960 }
961
962 /*
963 * Check last.
964 */
965 if ( got >= 2
966 && id.bDevNumParent == pDev->Info.bDevNumParent
967 && id.idVendor == pDev->Info.idVendor
968 && id.idProduct == pDev->Info.idProduct
969 && id.bcdDevice == pDev->Info.bcdDevice
970 && id.u64SerialHash == pDev->Info.u64SerialHash
971 && id.bBus == pDev->Info.bBus
972 && id.bPort == pDev->Info.bPort
973 && id.bLevel == pDev->Info.bLevel) {
974 l_found:
975 /* close the existing file descriptor. */
976 RTFileClose(pDevLnx->File);
977 pDevLnx->File = NIL_RTFILE;
978
979 /* open stuff at the new address. */
980 pDev->Info = id;
981 if (usbProxyLinuxOpen(pDev, &id))
982 return VINF_SUCCESS;
983 break;
984 }
985
986 /*
987 * Wait for a while and then check the file again.
988 */
989 u64Elapsed = RTTimeMilliTS() - u64StartTS;
990 if (u64Elapsed >= 5000/*ms*/)
991 break; /* done */
992
993 pfd.fd = fileno(pFile);
994 pfd.events = POLLIN;
995 rc = poll(&pfd, 1, 5000 - u64Elapsed);
996 if (rc < 0) {
997 AssertMsg(errno == EINTR, ("errno=%d\n", errno));
998 RTThreadSleep(32); /* paranoia: don't eat cpu on failure */
999 }
1000
1001 rewind(pFile);
1002 } /* for loop */
1003
1004 return VERR_GENERAL_FAILURE;
1005}
1006#endif /* !NO_PORT_RESET && !NO_LOGICAL_RECONNECT */
1007
1008
1009/**
1010 * Reset a device.
1011 *
1012 * @returns VBox status code.
1013 * @param pDev The device to reset.
1014 */
1015static int usbProxyLinuxReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
1016{
1017#ifdef NO_PORT_RESET
1018 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
1019
1020 /*
1021 * Specific device resets are NOPs.
1022 * Root hub resets that affects all devices are executed.
1023 *
1024 * The reasoning is that when a root hub reset is done, the guest shouldn't
1025 * will have to re enumerate the devices after doing this kind of reset.
1026 * So, it doesn't really matter if a device is 'logically disconnected'.
1027 */
1028 if ( !fResetOnLinux
1029 || pProxyDev->fMaskedIfs)
1030 LogFlow(("usbProxyLinuxReset: pProxyDev=%s - NO_PORT_RESET\n", usbProxyGetName(pProxyDev)));
1031 else
1032 {
1033 LogFlow(("usbProxyLinuxReset: pProxyDev=%s - Real Reset!\n", usbProxyGetName(pProxyDev)));
1034 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
1035 {
1036 int rc = errno;
1037 Log(("usb-linux: Reset failed, rc=%s errno=%d.\n",
1038 RTErrGetShort(RTErrConvertFromErrno(rc)), rc));
1039 pProxyDev->iActiveCfg = -1;
1040 return RTErrConvertFromErrno(rc);
1041 }
1042
1043 /* find the active config - damn annoying. */
1044 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->szPath, NULL);
1045 LogFlow(("usbProxyLinuxReset: returns successfully iActiveCfg=%d\n", pProxyDev->iActiveCfg));
1046 }
1047 pProxyDev->cIgnoreSetConfigs = 2;
1048
1049#else /* !NO_PORT_RESET */
1050
1051 /*
1052 * This is the alternative, we will always reset when asked to do so.
1053 *
1054 * The problem we're facing here is that on reset failure linux will do
1055 * a 'logical reconnect' on the device. This will invalidate the current
1056 * handle and we'll have to reopen the device. This is problematic to say
1057 * the least, especially since it happens pretty often.
1058 */
1059 LogFlow(("usbProxyLinuxReset: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
1060# ifndef NO_LOGICAL_RECONNECT
1061 ASMAtomicIncU32(&g_cResetActive);
1062# endif
1063
1064 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
1065 {
1066 int rc = errno;
1067# ifndef NO_LOGICAL_RECONNECT
1068 if (rc == ENODEV)
1069 {
1070 /*
1071 * This usually happens because of a 'logical disconnection'.
1072 * So, we're in for a real treat from our excellent OS now...
1073 */
1074 rc2 = usb_reset_logical_reconnect(pProxyDev);
1075 if (RT_FAILURE(rc2))
1076 usbProxLinuxUrbUnplugged(pProxyDev);
1077 if (RT_SUCCESS(rc2))
1078 {
1079 ASMAtomicDecU32(&g_cResetActive);
1080 LogFlow(("usbProxyLinuxReset: returns success (after recovering disconnected device!)\n"));
1081 return VINF_SUCCESS;
1082 }
1083 }
1084 ASMAtomicDecU32(&g_cResetActive);
1085# endif /* NO_LOGICAL_RECONNECT */
1086
1087 Log(("usb-linux: Reset failed, rc=%s errno=%d.\n",
1088 RTErrGetShort(RTErrConvertFromErrno(rc)), rc));
1089 pProxyDev->iActiveCfg = -1;
1090 return RTErrConvertFromErrno(rc);
1091 }
1092
1093# ifndef NO_LOGICAL_RECONNECT
1094 ASMAtomicDecU32(&g_cResetActive);
1095# endif
1096
1097 pProxyDev->cIgnoreSetConfigs = 2;
1098 LogFlow(("usbProxyLinuxReset: returns success\n"));
1099#endif /* !NO_PORT_RESET */
1100 return VINF_SUCCESS;
1101}
1102
1103
1104/**
1105 * SET_CONFIGURATION.
1106 *
1107 * The caller makes sure that it's not called first time after open or reset
1108 * with the active interface.
1109 *
1110 * @returns success indicator.
1111 * @param pProxyDev The device instance data.
1112 * @param iCfg The configuration to set.
1113 */
1114static int usbProxyLinuxSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
1115{
1116 LogFlow(("usbProxyLinuxSetConfig: pProxyDev=%s cfg=%#x\n",
1117 usbProxyGetName(pProxyDev), iCfg));
1118
1119 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iCfg, true, UINT32_MAX))
1120 {
1121 Log(("usb-linux: Set configuration. errno=%d\n", errno));
1122 return false;
1123 }
1124 return true;
1125}
1126
1127
1128/**
1129 * Claims an interface.
1130 * @returns success indicator.
1131 */
1132static int usbProxyLinuxClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
1133{
1134 LogFlow(("usbProxyLinuxClaimInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
1135 usbProxyLinuxSetConnected(pProxyDev, iIf, false, false);
1136
1137 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLAIMINTERFACE, &iIf, true, UINT32_MAX))
1138 {
1139 Log(("usb-linux: Claim interface. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1140 return false;
1141 }
1142 return true;
1143}
1144
1145
1146/**
1147 * Releases an interface.
1148 * @returns success indicator.
1149 */
1150static int usbProxyLinuxReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
1151{
1152 LogFlow(("usbProxyLinuxReleaseInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
1153
1154 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RELEASEINTERFACE, &iIf, true, UINT32_MAX))
1155 {
1156 Log(("usb-linux: Release interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1157 return false;
1158 }
1159 return true;
1160}
1161
1162
1163/**
1164 * SET_INTERFACE.
1165 *
1166 * @returns success indicator.
1167 */
1168static int usbProxyLinuxSetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
1169{
1170 struct usbdevfs_setinterface SetIf;
1171 LogFlow(("usbProxyLinuxSetInterface: pProxyDev=%p iIf=%#x iAlt=%#x\n", pProxyDev, iIf, iAlt));
1172
1173 SetIf.interface = iIf;
1174 SetIf.altsetting = iAlt;
1175 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETINTERFACE, &SetIf, true, UINT32_MAX))
1176 {
1177 Log(("usb-linux: Set interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1178 return false;
1179 }
1180 return true;
1181}
1182
1183
1184/**
1185 * Clears the halted endpoint 'EndPt'.
1186 */
1187static bool usbProxyLinuxClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
1188{
1189 LogFlow(("usbProxyLinuxClearHaltedEp: pProxyDev=%s EndPt=%u\n", usbProxyGetName(pProxyDev), EndPt));
1190
1191 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLEAR_HALT, &EndPt, true, UINT32_MAX))
1192 {
1193 /*
1194 * Unfortunately this doesn't work on control pipes.
1195 * Windows doing this on the default endpoint and possibly other pipes too,
1196 * so we'll feign success for ENOENT errors.
1197 */
1198 if (errno == ENOENT)
1199 {
1200 Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d - IGNORED\n",
1201 errno, usbProxyGetName(pProxyDev), EndPt));
1202 return true;
1203 }
1204 Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d\n",
1205 errno, usbProxyGetName(pProxyDev), EndPt));
1206 return false;
1207 }
1208 return true;
1209}
1210
1211
1212/**
1213 * Setup packet byte-swapping routines.
1214 */
1215static void usbProxyLinuxUrbSwapSetup(PVUSBSETUP pSetup)
1216{
1217 pSetup->wValue = RT_H2LE_U16(pSetup->wValue);
1218 pSetup->wIndex = RT_H2LE_U16(pSetup->wIndex);
1219 pSetup->wLength = RT_H2LE_U16(pSetup->wLength);
1220}
1221
1222
1223/**
1224 * Clean up after a failed URB submit.
1225 */
1226static void usbProxyLinuxCleanupFailedSubmit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
1227{
1228 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1229 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1230
1231 /* discard and reap later (walking with pUrbLnx). */
1232 if (pUrbLnx != pCur)
1233 {
1234 for (;;)
1235 {
1236 pUrbLnx->fCanceledBySubmit = true;
1237 pUrbLnx->KUrb.usercontext = NULL;
1238 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX))
1239 {
1240 if (errno == ENODEV)
1241 *pfUnplugged = true;
1242 else if (errno == ENOENT)
1243 pUrbLnx->fSplitElementReaped = true;
1244 else
1245 LogRel(("USB: Failed to discard %p! errno=%d (pUrb=%p)\n", pUrbLnx->KUrb.usercontext, errno, pUrb)); /* serious! */
1246 }
1247 if (pUrbLnx->pSplitNext == pCur)
1248 {
1249 pUrbLnx->pSplitNext = NULL;
1250 break;
1251 }
1252 pUrbLnx = pUrbLnx->pSplitNext; Assert(pUrbLnx);
1253 }
1254 }
1255
1256 /* free the unsubmitted ones. */
1257 while (pCur)
1258 {
1259 PUSBPROXYURBLNX pFree = pCur;
1260 pCur = pCur->pSplitNext;
1261 usbProxyLinuxUrbFree(pProxyDev, pFree);
1262 }
1263
1264 /* send unplug event if we failed with ENODEV originally. */
1265 if (*pfUnplugged)
1266 usbProxLinuxUrbUnplugged(pProxyDev);
1267}
1268
1269/**
1270 * Submit one URB through the usbfs IOCTL interface, with
1271 * retries
1272 *
1273 * @returns true / false.
1274 */
1275static bool usbProxyLinuxSubmitURB(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
1276{
1277 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
1278 unsigned cTries = 0;
1279
1280 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_SUBMITURB, &pCur->KUrb))
1281 {
1282 if (errno == EINTR)
1283 continue;
1284 if (errno == ENODEV)
1285 {
1286 Log(("usbProxyLinuxSubmitURB: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
1287 *pfUnplugged = true;
1288 return false;
1289 }
1290
1291 Log(("usb-linux: Submit URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
1292 pUrb, errno, pCur->KUrb.type, pCur->KUrb.endpoint, pCur->KUrb.buffer_length, cTries));
1293 if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
1294 {
1295 pCur->u64SubmitTS = RTTimeMilliTS();
1296 continue;
1297 }
1298 return false;
1299 }
1300 return true;
1301}
1302
1303/** The split size. 16K in known Linux kernel versions. */
1304#define SPLIT_SIZE 0x4000
1305
1306/**
1307 * Create a URB fragment of up to SPLIT_SIZE size and hook it
1308 * into the list of fragments.
1309 *
1310 * @returns pointer to newly allocated URB fragment or NULL.
1311 */
1312static PUSBPROXYURBLNX usbProxyLinuxSplitURBFragment(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pHead, PUSBPROXYURBLNX pCur)
1313{
1314 PUSBPROXYURBLNX pNew;
1315 uint32_t cbLeft = pCur->cbSplitRemaining;
1316 uint8_t *pb = (uint8_t *)pCur->KUrb.buffer;
1317
1318 Assert(cbLeft != 0);
1319 pNew = pCur->pSplitNext = usbProxyLinuxUrbAlloc(pProxyDev, pHead);
1320 if (!pNew)
1321 {
1322 usbProxyLinuxUrbFreeSplitList(pProxyDev, pHead);
1323 return NULL;
1324 }
1325 Assert(pHead->pNext != pNew); Assert(pHead->pPrev != pNew); Assert(pNew->pNext == pNew->pPrev);
1326 Assert(pNew->pSplitHead == pHead);
1327 Assert(pNew->pSplitNext == NULL);
1328
1329 pNew->KUrb = pHead->KUrb;
1330 pNew->KUrb.buffer = pb + pCur->KUrb.buffer_length;
1331 pNew->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
1332 pNew->KUrb.actual_length = 0;
1333
1334 cbLeft -= pNew->KUrb.buffer_length;
1335 Assert(cbLeft < INT32_MAX);
1336 pNew->cbSplitRemaining = cbLeft;
1337 return pNew;
1338}
1339
1340/**
1341 * Try splitting up a VUSB URB into smaller URBs which the
1342 * linux kernel (usbfs) can deal with.
1343 *
1344 * NB: For ShortOK reads things get a little tricky - we don't
1345 * know how much data is going to arrive and not all the
1346 * fragment URBs might be filled. We can only safely set up one
1347 * URB at a time -> worse performance but correct behaviour.
1348 *
1349 * @returns true / false.
1350 * @param pProxyDev The proxy device.
1351 * @param pUrbLnx The linux URB which was rejected because of being too big.
1352 * @param pUrb The VUSB URB.
1353 */
1354static int usbProxyLinuxUrbQueueSplit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PVUSBURB pUrb)
1355{
1356 /*
1357 * Split it up into SPLIT_SIZE sized blocks.
1358 */
1359 const unsigned cKUrbs = (pUrb->cbData + SPLIT_SIZE - 1) / SPLIT_SIZE;
1360 LogFlow(("usbProxyLinuxUrbQueueSplit: pUrb=%p cKUrbs=%d cbData=%d\n", pUrb, cKUrbs, pUrb->cbData));
1361
1362 uint32_t cbLeft = pUrb->cbData;
1363 uint8_t *pb = &pUrb->abData[0];
1364
1365 /* the first one (already allocated) */
1366 switch (pUrb->enmType)
1367 {
1368 default: /* shut up gcc */
1369 case VUSBXFERTYPE_BULK: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK; break;
1370 case VUSBXFERTYPE_INTR: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT; break;
1371 case VUSBXFERTYPE_MSG: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL; break;
1372 case VUSBXFERTYPE_ISOC:
1373 AssertMsgFailed(("We can't split isochronous URBs!\n"));
1374 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1375 return false;
1376 }
1377 pUrbLnx->KUrb.endpoint = pUrb->EndPt;
1378 if (pUrb->enmDir == VUSBDIRECTION_IN)
1379 pUrbLnx->KUrb.endpoint |= 0x80;
1380 pUrbLnx->KUrb.status = 0;
1381 pUrbLnx->KUrb.flags = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0; /* ISO_ASAP too? */
1382 pUrbLnx->KUrb.buffer = pb;
1383 pUrbLnx->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
1384 pUrbLnx->KUrb.actual_length = 0;
1385 pUrbLnx->KUrb.start_frame = 0;
1386 pUrbLnx->KUrb.number_of_packets = 0;
1387 pUrbLnx->KUrb.error_count = 0;
1388 pUrbLnx->KUrb.signr = 0;
1389 pUrbLnx->KUrb.usercontext = pUrb;
1390 pUrbLnx->pSplitHead = pUrbLnx;
1391 pUrbLnx->pSplitNext = NULL;
1392
1393 PUSBPROXYURBLNX pCur = pUrbLnx;
1394
1395 cbLeft -= pUrbLnx->KUrb.buffer_length;
1396 pUrbLnx->cbSplitRemaining = cbLeft;
1397
1398 bool fSucceeded = false;
1399 bool fUnplugged = false;
1400 if (pUrb->enmDir == VUSBDIRECTION_IN && !pUrb->fShortNotOk)
1401 {
1402 /* Subsequent fragments will be queued only after the previous fragment is reaped
1403 * and only if necessary.
1404 */
1405 fSucceeded = true;
1406 Log(("usb-linux: Large ShortOK read, only queuing first fragment.\n"));
1407 Assert(pUrbLnx->cbSplitRemaining > 0 && pUrbLnx->cbSplitRemaining < 256 * _1K);
1408 fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pUrbLnx, pUrb, &fUnplugged);
1409 }
1410 else
1411 {
1412 /* the rest. */
1413 unsigned i;
1414 for (i = 1; i < cKUrbs; i++)
1415 {
1416 pCur = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx, pCur);
1417 if (!pCur)
1418 {
1419 return false;
1420 }
1421 }
1422 Assert(pCur->cbSplitRemaining == 0);
1423
1424 /* Submit the blocks. */
1425 pCur = pUrbLnx;
1426 for (i = 0; i < cKUrbs; i++, pCur = pCur->pSplitNext)
1427 {
1428 fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pCur, pUrb, &fUnplugged);
1429 if (!fSucceeded)
1430 break;
1431 }
1432 }
1433
1434 if (fSucceeded)
1435 {
1436 pUrb->Dev.pvPrivate = pUrbLnx;
1437 LogFlow(("usbProxyLinuxUrbQueueSplit: ok\n"));
1438 return true;
1439 }
1440
1441 usbProxyLinuxCleanupFailedSubmit(pProxyDev, pUrbLnx, pCur, pUrb, &fUnplugged);
1442 return false;
1443}
1444
1445
1446/**
1447 * @copydoc USBPROXYBACK::pfnUrbQueue
1448 */
1449static int usbProxyLinuxUrbQueue(PVUSBURB pUrb)
1450{
1451 unsigned cTries;
1452#ifndef RDESKTOP
1453 PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
1454#else
1455 PUSBPROXYDEV pProxyDev = usbProxyFromVusbDev(pUrb->pDev);
1456#endif
1457 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
1458 LogFlow(("usbProxyLinuxUrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
1459 usbProxyGetName(pProxyDev), pUrb, pUrb->EndPt, pUrb->cbData));
1460
1461 /*
1462 * Allocate a linux urb.
1463 */
1464 PUSBPROXYURBLNX pUrbLnx = usbProxyLinuxUrbAlloc(pProxyDev, NULL);
1465 if (!pUrbLnx)
1466 return false;
1467
1468 pUrbLnx->KUrb.endpoint = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
1469 pUrbLnx->KUrb.status = 0;
1470 pUrbLnx->KUrb.flags = pUrb->fShortNotOk ? USBDEVFS_URB_SHORT_NOT_OK : 0;
1471 pUrbLnx->KUrb.buffer = pUrb->abData;
1472 pUrbLnx->KUrb.buffer_length = pUrb->cbData;
1473 pUrbLnx->KUrb.actual_length = 0;
1474 pUrbLnx->KUrb.start_frame = 0;
1475 pUrbLnx->KUrb.number_of_packets = 0;
1476 pUrbLnx->KUrb.error_count = 0;
1477 pUrbLnx->KUrb.signr = 0;
1478 pUrbLnx->KUrb.usercontext = pUrb;
1479
1480 switch (pUrb->enmType)
1481 {
1482 case VUSBXFERTYPE_MSG:
1483 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL;
1484 if (pUrb->cbData < sizeof(VUSBSETUP))
1485 {
1486 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1487 return false;
1488 }
1489 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1490 LogFlow(("usbProxyLinuxUrbQueue: message\n"));
1491 break;
1492 case VUSBXFERTYPE_BULK:
1493 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK;
1494 break;
1495 case VUSBXFERTYPE_ISOC:
1496 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_ISO;
1497 pUrbLnx->KUrb.flags |= USBDEVFS_URB_ISO_ASAP;
1498 pUrbLnx->KUrb.number_of_packets = pUrb->cIsocPkts;
1499 unsigned i;
1500 for (i = 0; i < pUrb->cIsocPkts; i++)
1501 {
1502 pUrbLnx->KUrb.iso_frame_desc[i].length = pUrb->aIsocPkts[i].cb;
1503 pUrbLnx->KUrb.iso_frame_desc[i].actual_length = 0;
1504 pUrbLnx->KUrb.iso_frame_desc[i].status = 0x7fff;
1505 }
1506 break;
1507 case VUSBXFERTYPE_INTR:
1508 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT;
1509 break;
1510 default:
1511 goto l_err;
1512 }
1513
1514 /*
1515 * Submit it.
1516 */
1517 cTries = 0;
1518 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_SUBMITURB, &pUrbLnx->KUrb))
1519 {
1520 if (errno == EINTR)
1521 continue;
1522 if (errno == ENODEV)
1523 {
1524 Log(("usbProxyLinuxUrbQueue: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
1525 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1526 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1527 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1528
1529 usbProxLinuxUrbUnplugged(pProxyDev);
1530 return false;
1531 }
1532
1533 /*
1534 * usbfs has or used to have a low buffer limit (16KB) in order to prevent
1535 * processes wasting kmalloc'ed memory. It will return EINVAL if break that
1536 * limit, and we'll have to split the VUSB URB up into multiple linux URBs.
1537 *
1538 * Since this is a limit which is subject to change, we cannot check for it
1539 * before submitting the URB. We just have to try and fail.
1540 */
1541 if ( errno == EINVAL
1542 && pUrb->cbData >= 8*_1K)
1543 return usbProxyLinuxUrbQueueSplit(pProxyDev, pUrbLnx, pUrb);
1544
1545 Log(("usb-linux: Queue URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
1546 pUrb, errno, pUrbLnx->KUrb.type, pUrbLnx->KUrb.endpoint, pUrbLnx->KUrb.buffer_length, cTries));
1547 if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
1548 continue;
1549l_err:
1550 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1551 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1552 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1553 return false;
1554 }
1555 pUrbLnx->u64SubmitTS = RTTimeMilliTS();
1556
1557 LogFlow(("usbProxyLinuxUrbQueue: ok\n"));
1558 pUrb->Dev.pvPrivate = pUrbLnx;
1559 return true;
1560}
1561
1562
1563/**
1564 * Check if any or the in-flight URBs are taking too long and should be cancelled.
1565 *
1566 * Cancelling is done in three turns, first a URB is marked for timeout if it's
1567 * exceeding a certain time limit. Then the next time it's encountered it is actually
1568 * cancelled. The idea now is that it's supposed to be reaped and returned in the next
1569 * round of calls.
1570 *
1571 * @param pProxyDev The proxy device.
1572 * @param pDevLnx The linux backend data.
1573 *
1574 * @todo Make the HCI do proper timeout handling! Current timeout is 3 min and 20 seconds
1575 * as not to break bloomberg which queues IN packages with 3 min timeouts.
1576 */
1577static void vusbProxyLinuxUrbDoTimeouts(PUSBPROXYDEV pProxyDev, PUSBPROXYDEVLNX pDevLnx)
1578{
1579 RTCritSectEnter(&pDevLnx->CritSect);
1580 uint64_t u64MilliTS = RTTimeMilliTS();
1581 PUSBPROXYURBLNX pCur;
1582 for (pCur = pDevLnx->pInFlightHead;
1583 pCur;
1584 pCur = pCur->pNext)
1585 {
1586 if (pCur->fTimedOut)
1587 {
1588 if (pCur->pSplitHead)
1589 {
1590 /* split */
1591 Assert(pCur == pCur->pSplitHead);
1592 unsigned cFailures = 0;
1593 PUSBPROXYURBLNX pCur2;
1594 for (pCur2 = pCur; pCur2; pCur2 = pCur2->pSplitNext)
1595 {
1596 if (pCur2->fSplitElementReaped)
1597 continue;
1598
1599 if ( !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pCur2->KUrb, true, UINT32_MAX)
1600 || errno == ENOENT)
1601 pCur2->fCanceledByTimedOut = true;
1602 else if (errno != ENODEV)
1603 Log(("vusbProxyLinuxUrbDoTimeouts: pUrb=%p failed errno=%d (!!split!!)\n", pCur2->KUrb.usercontext, errno));
1604 else
1605 goto l_leave; /* ENODEV means break and everything cancelled elsewhere. */
1606 }
1607 LogRel(("USB: Cancelled URB (%p) after %llums!! (cFailures=%d)\n",
1608 pCur->KUrb.usercontext, (long long unsigned) u64MilliTS - pCur->u64SubmitTS, cFailures));
1609 }
1610 else
1611 {
1612 /* unsplit */
1613 if ( !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pCur->KUrb, true, UINT32_MAX)
1614 || errno == -ENOENT)
1615 {
1616 pCur->fCanceledByTimedOut = true;
1617 LogRel(("USB: Cancelled URB (%p) after %llums!!\n", pCur->KUrb.usercontext, (long long unsigned) u64MilliTS - pCur->u64SubmitTS));
1618 }
1619 else if (errno != ENODEV)
1620 LogFlow(("vusbProxyLinuxUrbDoTimeouts: pUrb=%p failed errno=%d\n", pCur->KUrb.usercontext, errno));
1621 else
1622 goto l_leave; /* ENODEV means break and everything cancelled elsewhere. */
1623 }
1624 }
1625#if 0
1626 /* Disabled for the time being as some USB devices have URBs pending for an unknown amount of time.
1627 * One example is the OmniKey CardMan 3821. */
1628 else if (u64MilliTS - pCur->u64SubmitTS >= 200*1000 /* 200 sec (180 sec has been observed with XP) */)
1629 pCur->fTimedOut = true;
1630#endif
1631 }
1632
1633l_leave:
1634 RTCritSectLeave(&pDevLnx->CritSect);
1635}
1636
1637
1638/**
1639 * Translate the linux status to a VUSB status.
1640 *
1641 * @remarks see cc_to_error in ohci.h, uhci_map_status in uhci-q.c,
1642 * sitd_complete+itd_complete in ehci-sched.c, and qtd_copy_status in
1643 * ehci-q.c.
1644 */
1645static VUSBSTATUS vusbProxyLinuxStatusToVUsbStatus(int iStatus)
1646{
1647 switch (iStatus)
1648 {
1649 /** @todo VUSBSTATUS_NOT_ACCESSED */
1650 case -EXDEV: /* iso transfer, partial result. */
1651 case 0:
1652 return VUSBSTATUS_OK;
1653
1654 case -EILSEQ:
1655 return VUSBSTATUS_CRC;
1656
1657 case -EREMOTEIO: /* ehci and ohci uses this for underflow error. */
1658 return VUSBSTATUS_DATA_UNDERRUN;
1659 case -EOVERFLOW:
1660 return VUSBSTATUS_DATA_OVERRUN;
1661
1662 case -ETIME:
1663 case -ENODEV:
1664 return VUSBSTATUS_DNR;
1665
1666 //case -ECOMM:
1667 // return VUSBSTATUS_BUFFER_OVERRUN;
1668 //case -ENOSR:
1669 // return VUSBSTATUS_BUFFER_UNDERRUN;
1670
1671 //case -EPROTO:
1672 // return VUSBSTATUS_BIT_STUFFING;
1673
1674 case -EPIPE:
1675 Log(("vusbProxyLinuxStatusToVUsbStatus: STALL/EPIPE!!\n"));
1676 return VUSBSTATUS_STALL;
1677
1678 case -ESHUTDOWN:
1679 Log(("vusbProxyLinuxStatusToVUsbStatus: SHUTDOWN!!\n"));
1680 return VUSBSTATUS_STALL;
1681
1682 default:
1683 Log(("vusbProxyLinuxStatusToVUsbStatus: status %d!!\n", iStatus));
1684 return VUSBSTATUS_STALL;
1685 }
1686}
1687
1688
1689/**
1690 * Get and translates the linux status to a VUSB status.
1691 */
1692static VUSBSTATUS vusbProxyLinuxUrbGetStatus(PUSBPROXYURBLNX pUrbLnx)
1693{
1694 if ( pUrbLnx->fCanceledByTimedOut
1695 && pUrbLnx->KUrb.status == 0)
1696 return VUSBSTATUS_CRC;
1697 return vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.status);
1698}
1699
1700
1701/**
1702 * Reap URBs in-flight on a device.
1703 *
1704 * @returns Pointer to a completed URB.
1705 * @returns NULL if no URB was completed.
1706 * @param pProxyDev The device.
1707 * @param cMillies Number of milliseconds to wait. Use 0 to not wait at all.
1708 */
1709static PVUSBURB usbProxyLinuxUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
1710{
1711 PUSBPROXYURBLNX pUrbLnx = NULL;
1712 PUSBPROXYDEVLNX pDevLnx = (PUSBPROXYDEVLNX)pProxyDev->Backend.pv;
1713
1714 /*
1715 * Any URBs pending delivery?
1716 */
1717 if (pDevLnx->pTaxingHead)
1718 {
1719 RTCritSectEnter(&pDevLnx->CritSect);
1720 pUrbLnx = pDevLnx->pTaxingHead;
1721 if (pUrbLnx)
1722 {
1723 /* unlink from the pending delivery list */
1724 if (pUrbLnx->pNext)
1725 {
1726 pUrbLnx->pNext->pPrev = NULL;
1727 pDevLnx->pTaxingHead = pUrbLnx->pNext;
1728 }
1729 else
1730 pDevLnx->pTaxingHead = pDevLnx->pTaxingTail = NULL;
1731
1732 /* temporarily into the active list, so free works right. */
1733 pUrbLnx->pPrev = NULL;
1734 pUrbLnx->pNext = pDevLnx->pInFlightHead;
1735 if (pUrbLnx->pNext)
1736 pUrbLnx->pNext->pPrev = pUrbLnx;
1737 pDevLnx->pInFlightHead = pUrbLnx;
1738 }
1739 RTCritSectLeave(&pDevLnx->CritSect);
1740 }
1741 if (!pUrbLnx)
1742 {
1743 /*
1744 * Don't block if nothing is in the air.
1745 */
1746 if (!pDevLnx->pInFlightHead)
1747 return NULL;
1748
1749 /*
1750 * Block for requested period.
1751 *
1752 * It seems to me that the path of poll() is shorter and
1753 * involves less semaphores than ioctl() on usbfs. So, we'll
1754 * do a poll regardless of whether cMillies == 0 or not.
1755 */
1756 if (cMillies)
1757 {
1758
1759 for (;;)
1760 {
1761 struct pollfd pfd;
1762 pfd.fd = RTFileToNative(pDevLnx->hFile);
1763 pfd.events = POLLOUT | POLLWRNORM /* completed async */
1764 | POLLERR | POLLHUP /* disconnected */;
1765 pfd.revents = 0;
1766 int rc = poll(&pfd, 1, cMillies);
1767 Log(("usbProxyLinuxUrbReap: poll rc = %d\n", rc));
1768 if (rc >= 1)
1769 break;
1770 if (rc >= 0 /*|| errno == ETIMEOUT*/)
1771 {
1772 vusbProxyLinuxUrbDoTimeouts(pProxyDev, pDevLnx);
1773 return NULL;
1774 }
1775 if (errno != EAGAIN)
1776 {
1777 Log(("usb-linux: Reap URB - poll -> %d errno=%d pProxyDev=%s\n", rc, errno, usbProxyGetName(pProxyDev)));
1778 return NULL;
1779 }
1780 Log(("usbProxyLinuxUrbReap: poll again - weird!!!\n"));
1781 }
1782 }
1783
1784 /*
1785 * Reap URBs, non-blocking.
1786 */
1787 for (;;)
1788 {
1789 struct usbdevfs_urb *pKUrb;
1790 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_REAPURBNDELAY, &pKUrb))
1791 if (errno != EINTR)
1792 {
1793 if (errno == ENODEV)
1794 usbProxLinuxUrbUnplugged(pProxyDev);
1795 else if (errno == EAGAIN)
1796 vusbProxyLinuxUrbDoTimeouts(pProxyDev, pDevLnx);
1797 else
1798 Log(("usb-linux: Reap URB. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1799 return NULL;
1800 }
1801 pUrbLnx = (PUSBPROXYURBLNX)pKUrb;
1802
1803 /* split list: Is the entire split list done yet? */
1804 if (pUrbLnx->pSplitHead)
1805 {
1806 pUrbLnx->fSplitElementReaped = true;
1807
1808 /* for variable size URBs, we may need to queue more if the just-reaped URB was completely filled */
1809 if (pUrbLnx->cbSplitRemaining && (pKUrb->actual_length == pKUrb->buffer_length) && !pUrbLnx->pSplitNext)
1810 {
1811 bool fUnplugged = false;
1812 bool fSucceeded;
1813
1814 Assert(pUrbLnx->pSplitHead);
1815 Assert((pKUrb->endpoint & 0x80) && (!pKUrb->flags & USBDEVFS_URB_SHORT_NOT_OK));
1816 PUSBPROXYURBLNX pNew = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx->pSplitHead, pUrbLnx);
1817 if (!pNew)
1818 {
1819 Log(("usb-linux: Allocating URB fragment failed. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1820 return NULL;
1821 }
1822 PVUSBURB pUrb = (PVUSBURB)pUrbLnx->KUrb.usercontext;
1823 fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pNew, pUrb, &fUnplugged);
1824 if (fUnplugged)
1825 usbProxLinuxUrbUnplugged(pProxyDev);
1826 if (!fSucceeded)
1827 return NULL;
1828 continue; /* try reaping another URB */
1829 }
1830 PUSBPROXYURBLNX pCur;
1831 for (pCur = pUrbLnx->pSplitHead; pCur; pCur = pCur->pSplitNext)
1832 if (!pCur->fSplitElementReaped)
1833 {
1834 pUrbLnx = NULL;
1835 break;
1836 }
1837 if (!pUrbLnx)
1838 continue;
1839 pUrbLnx = pUrbLnx->pSplitHead;
1840 }
1841 break;
1842 }
1843 }
1844
1845 /*
1846 * Ok, we got one!
1847 */
1848 PVUSBURB pUrb = (PVUSBURB)pUrbLnx->KUrb.usercontext;
1849 if ( pUrb
1850 && !pUrbLnx->fCanceledBySubmit)
1851 {
1852 if (pUrbLnx->pSplitHead)
1853 {
1854 /* split - find the end byte and the first error status. */
1855 Assert(pUrbLnx == pUrbLnx->pSplitHead);
1856 uint8_t *pbEnd = &pUrb->abData[0];
1857 pUrb->enmStatus = VUSBSTATUS_OK;
1858 PUSBPROXYURBLNX pCur;
1859 for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
1860 {
1861 if (pCur->KUrb.actual_length)
1862 pbEnd = (uint8_t *)pCur->KUrb.buffer + pCur->KUrb.actual_length;
1863 if (pUrb->enmStatus == VUSBSTATUS_OK)
1864 pUrb->enmStatus = vusbProxyLinuxUrbGetStatus(pCur);
1865 }
1866 pUrb->cbData = pbEnd - &pUrb->abData[0];
1867 usbProxyLinuxUrbFreeSplitList(pProxyDev, pUrbLnx);
1868 }
1869 else
1870 {
1871 /* unsplit. */
1872 pUrb->enmStatus = vusbProxyLinuxUrbGetStatus(pUrbLnx);
1873 pUrb->cbData = pUrbLnx->KUrb.actual_length;
1874 if (pUrb->enmType == VUSBXFERTYPE_ISOC)
1875 {
1876 unsigned i, off;
1877 for (i = 0, off = 0; i < pUrb->cIsocPkts; i++)
1878 {
1879 pUrb->aIsocPkts[i].enmStatus = vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.iso_frame_desc[i].status);
1880 Assert(pUrb->aIsocPkts[i].off == off);
1881 pUrb->aIsocPkts[i].cb = pUrbLnx->KUrb.iso_frame_desc[i].actual_length;
1882 off += pUrbLnx->KUrb.iso_frame_desc[i].length;
1883 }
1884 }
1885 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1886 }
1887 pUrb->Dev.pvPrivate = NULL;
1888
1889 /* some adjustments for message transfers. */
1890 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1891 {
1892 pUrb->cbData += sizeof(VUSBSETUP);
1893 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1894 }
1895 }
1896 else
1897 {
1898 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1899 pUrb = NULL;
1900 }
1901
1902 LogFlow(("usbProxyLinuxUrbReap: pProxyDev=%s returns %p\n", usbProxyGetName(pProxyDev), pUrb));
1903 return pUrb;
1904}
1905
1906
1907/**
1908 * Cancels the URB.
1909 * The URB requires reaping, so we don't change its state.
1910 */
1911static void usbProxyLinuxUrbCancel(PVUSBURB pUrb)
1912{
1913#ifndef RDESKTOP
1914 PUSBPROXYDEV pProxyDev = PDMINS_2_DATA(pUrb->pUsbIns, PUSBPROXYDEV);
1915#else
1916 PUSBPROXYDEV pProxyDev = usbProxyFromVusbDev(pUrb->pDev);
1917#endif
1918 PUSBPROXYURBLNX pUrbLnx = (PUSBPROXYURBLNX)pUrb->Dev.pvPrivate;
1919 if (pUrbLnx->pSplitHead)
1920 {
1921 /* split */
1922 Assert(pUrbLnx == pUrbLnx->pSplitHead);
1923 PUSBPROXYURBLNX pCur;
1924 for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
1925 {
1926 if (pCur->fSplitElementReaped)
1927 continue;
1928 if ( !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pCur->KUrb, true, UINT32_MAX)
1929 || errno == ENOENT)
1930 continue;
1931 if (errno == ENODEV)
1932 break;
1933 Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!! (split)\n",
1934 pUrb, errno, usbProxyGetName(pProxyDev)));
1935 }
1936 }
1937 else
1938 {
1939 /* unsplit */
1940 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, true, UINT32_MAX)
1941 && errno != ENODEV /* deal with elsewhere. */
1942 && errno != ENOENT)
1943 Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!!\n",
1944 pUrb, errno, usbProxyGetName(pProxyDev)));
1945 }
1946}
1947
1948
1949/**
1950 * The Linux USB Proxy Backend.
1951 */
1952const USBPROXYBACK g_USBProxyDeviceHost =
1953{
1954 "host",
1955 usbProxyLinuxOpen,
1956 usbProxyLinuxInit,
1957 usbProxyLinuxClose,
1958 usbProxyLinuxReset,
1959 usbProxyLinuxSetConfig,
1960 usbProxyLinuxClaimInterface,
1961 usbProxyLinuxReleaseInterface,
1962 usbProxyLinuxSetInterface,
1963 usbProxyLinuxClearHaltedEp,
1964 usbProxyLinuxUrbQueue,
1965 usbProxyLinuxUrbCancel,
1966 usbProxyLinuxUrbReap,
1967 0
1968};
1969
1970
1971/*
1972 * Local Variables:
1973 * mode: c
1974 * c-file-style: "bsd"
1975 * c-basic-offset: 4
1976 * tab-width: 4
1977 * indent-tabs-mode: s
1978 * End:
1979 */
1980
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette