VirtualBox

source: vbox/trunk/src/VBox/RDP/client/vrdp/USBProxyDevice-linux.c@ 26112

Last change on this file since 26112 was 26112, checked in by vboxsync, 15 years ago

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