VirtualBox

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

Last change on this file since 96407 was 96407, checked in by vboxsync, 3 years ago

scm copyright and license note update
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 57.0 KB
Line 
1/* $Id: USBProxyDevice-linux.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2/** @file
3 * USB device proxy - the Linux backend.
4 */
5
6/*
7 * Copyright (C) 2006-2022 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Defined Constants And Macros *
31*********************************************************************************************************************************/
32
33
34/*********************************************************************************************************************************
35* Header Files *
36*********************************************************************************************************************************/
37#define LOG_GROUP LOG_GROUP_DRV_USBPROXY
38
39#include <iprt/stdint.h>
40#include <iprt/err.h>
41#include <iprt/pipe.h>
42
43#include <sys/types.h>
44#include <sys/stat.h>
45#include <sys/vfs.h>
46#include <sys/ioctl.h>
47#include <sys/poll.h>
48#include <stdint.h>
49#include <stdio.h>
50#include <string.h>
51#include <stdlib.h>
52#include <limits.h>
53#include <unistd.h>
54#include <fcntl.h>
55#include <errno.h>
56#ifdef VBOX_WITH_LINUX_COMPILER_H
57# include <linux/compiler.h>
58#endif
59#include <linux/usbdevice_fs.h>
60
61#ifndef RDESKTOP
62# include <VBox/vmm/pdm.h>
63#else
64# define RTCRITSECT void *
65static inline int rtcsNoop() { return VINF_SUCCESS; }
66static inline bool rtcsTrue() { return true; }
67# define RTCritSectInit(a) rtcsNoop()
68# define RTCritSectDelete(a) rtcsNoop()
69# define RTCritSectEnter(a) rtcsNoop()
70# define RTCritSectLeave(a) rtcsNoop()
71# define RTCritSectIsOwner(a) rtcsTrue()
72#endif
73#include <VBox/err.h>
74#include <VBox/log.h>
75#include <iprt/alloc.h>
76#include <iprt/assert.h>
77#include <iprt/asm.h>
78#include <iprt/ctype.h>
79#include <iprt/file.h>
80#include <iprt/linux/sysfs.h>
81#include <iprt/stream.h>
82#include <iprt/string.h>
83#include <iprt/list.h>
84#include <iprt/time.h>
85#include "../USBProxyDevice.h"
86
87
88/*********************************************************************************************************************************
89* Structures and Typedefs *
90*********************************************************************************************************************************/
91/**
92 * Wrapper around the linux urb request structure.
93 * This is required to track in-flight and landed URBs.
94 */
95typedef struct USBPROXYURBLNX
96{
97 /** The kernel URB data. */
98#if RT_GNUC_PREREQ(6, 0)
99 /* gcc 6.2 complains about the [] member of KUrb */
100# pragma GCC diagnostic push
101# pragma GCC diagnostic ignored "-Wpedantic"
102#endif
103 struct usbdevfs_urb KUrb;
104#if RT_GNUC_PREREQ(6, 0)
105# pragma GCC diagnostic pop
106#endif
107 /** Space filler for the isochronous packets. */
108 struct usbdevfs_iso_packet_desc aIsocPktsDonUseTheseUseTheOnesInKUrb[8];
109 /** Node to link the URB in of the existing lists. */
110 RTLISTNODE NodeList;
111 /** If we've split the VUSBURB up into multiple linux URBs, this is points to the head. */
112 struct USBPROXYURBLNX *pSplitHead;
113 /** The next linux URB if split up. */
114 struct USBPROXYURBLNX *pSplitNext;
115 /** Don't report these back. */
116 bool fCanceledBySubmit;
117 /** This split element is reaped. */
118 bool fSplitElementReaped;
119 /** This URB was discarded. */
120 bool fDiscarded;
121 /** Size to transfer in remaining fragments of a split URB */
122 uint32_t cbSplitRemaining;
123} USBPROXYURBLNX, *PUSBPROXYURBLNX;
124
125/**
126 * Data for the linux usb proxy backend.
127 */
128typedef struct USBPROXYDEVLNX
129{
130 /** The open file. */
131 RTFILE hFile;
132 /** Critical section protecting the lists. */
133 RTCRITSECT CritSect;
134 /** The list of free linux URBs (USBPROXYURBLNX). */
135 RTLISTANCHOR ListFree;
136 /** The list of active linux URBs.
137 * We must maintain this so we can properly reap URBs of a detached device.
138 * Only the split head will appear in this list. (USBPROXYURBLNX) */
139 RTLISTANCHOR ListInFlight;
140 /** Are we using sysfs to find the active configuration? */
141 bool fUsingSysfs;
142 /** Pipe handle for waking up - writing end. */
143 RTPIPE hPipeWakeupW;
144 /** Pipe handle for waking up - reading end. */
145 RTPIPE hPipeWakeupR;
146 /** The device node/sysfs path of the device.
147 * Used to figure out the configuration after a reset. */
148 char *pszPath;
149 /** Mask of claimed interfaces. */
150 uint32_t fClaimedIfsMask;
151} USBPROXYDEVLNX, *PUSBPROXYDEVLNX;
152
153
154/*********************************************************************************************************************************
155* Internal Functions *
156*********************************************************************************************************************************/
157static void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev);
158static DECLCALLBACK(int) usbProxyLinuxClaimInterface(PUSBPROXYDEV pProxyDev, int iIf);
159static DECLCALLBACK(int) usbProxyLinuxReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf);
160
161
162/**
163 * Wrapper for the ioctl call.
164 *
165 * This wrapper will repeat the call if we get an EINTR or EAGAIN. It can also
166 * handle ENODEV (detached device) errors.
167 *
168 * @returns whatever ioctl returns.
169 * @param pProxyDev The proxy device.
170 * @param iCmd The ioctl command / function.
171 * @param pvArg The ioctl argument / data.
172 * @param fHandleNoDev Whether to handle ENODEV.
173 * @param cTries The number of retries. Use UINT32_MAX for (kind of) indefinite retries.
174 * @internal
175 */
176static int usbProxyLinuxDoIoCtl(PUSBPROXYDEV pProxyDev, unsigned long iCmd, void *pvArg, bool fHandleNoDev, uint32_t cTries)
177{
178 int rc;
179 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
180 do
181 {
182 do
183 {
184 rc = ioctl(RTFileToNative(pDevLnx->hFile), iCmd, pvArg);
185 if (rc >= 0)
186 return rc;
187 } while (errno == EINTR);
188
189 if (errno == ENODEV && fHandleNoDev)
190 {
191 usbProxLinuxUrbUnplugged(pProxyDev);
192 Log(("usb-linux: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
193 errno = ENODEV;
194 break;
195 }
196 if (errno != EAGAIN)
197 break;
198 } while (cTries-- > 0);
199
200 return rc;
201}
202
203
204/**
205 * The device has been unplugged.
206 * Cancel all in-flight URBs and put them up for reaping.
207 */
208static void usbProxLinuxUrbUnplugged(PUSBPROXYDEV pProxyDev)
209{
210 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
211
212 /*
213 * Shoot down all flying URBs.
214 */
215 RTCritSectEnter(&pDevLnx->CritSect);
216 pProxyDev->fDetached = true;
217
218 PUSBPROXYURBLNX pUrbLnx;
219 PUSBPROXYURBLNX pUrbLnxNext;
220 RTListForEachSafe(&pDevLnx->ListInFlight, pUrbLnx, pUrbLnxNext, USBPROXYURBLNX, NodeList)
221 {
222 if (!pUrbLnx->fDiscarded)
223 {
224 pUrbLnx->fDiscarded = true;
225 /* Cancel the URB. It will be reaped normally. */
226 ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_DISCARDURB, &pUrbLnx->KUrb);
227 if (!pUrbLnx->KUrb.status)
228 pUrbLnx->KUrb.status = -ENODEV;
229 }
230 }
231
232 RTCritSectLeave(&pDevLnx->CritSect);
233}
234
235
236/**
237 * Set the connect state seen by kernel drivers
238 * @internal
239 */
240static void usbProxyLinuxSetConnected(PUSBPROXYDEV pProxyDev, int iIf, bool fConnect, bool fQuiet)
241{
242 if ( iIf >= 32
243 || !(pProxyDev->fMaskedIfs & RT_BIT(iIf)))
244 {
245 struct usbdevfs_ioctl IoCtl;
246 if (!fQuiet)
247 LogFlow(("usbProxyLinuxSetConnected: pProxyDev=%s iIf=%#x fConnect=%s\n",
248 usbProxyGetName(pProxyDev), iIf, fConnect ? "true" : "false"));
249
250 IoCtl.ifno = iIf;
251 IoCtl.ioctl_code = fConnect ? USBDEVFS_CONNECT : USBDEVFS_DISCONNECT;
252 IoCtl.data = NULL;
253 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_IOCTL, &IoCtl, true, UINT32_MAX)
254 && !fQuiet)
255 Log(("usbProxyLinuxSetConnected: failure, errno=%d. pProxyDev=%s\n",
256 errno, usbProxyGetName(pProxyDev)));
257 }
258}
259
260
261/**
262 * Links the given URB into the in flight list.
263 *
264 * @returns nothing.
265 * @param pDevLnx The proxy device instance - Linux specific data.
266 * @param pUrbLnx The URB to link into the in flight list.
267 */
268static void usbProxyLinuxUrbLinkInFlight(PUSBPROXYDEVLNX pDevLnx, PUSBPROXYURBLNX pUrbLnx)
269{
270 LogFlowFunc(("pDevLnx=%p pUrbLnx=%p\n", pDevLnx, pUrbLnx));
271 Assert(RTCritSectIsOwner(&pDevLnx->CritSect));
272 Assert(!pUrbLnx->pSplitHead || pUrbLnx->pSplitHead == pUrbLnx);
273 RTListAppend(&pDevLnx->ListInFlight, &pUrbLnx->NodeList);
274}
275
276/**
277 * Unlinks the given URB from the in flight list.
278 * @returns nothing.
279 * @param pDevLnx The proxy device instance - Linux specific data.
280 * @param pUrbLnx The URB to link into the in flight list.
281 */
282static void usbProxyLinuxUrbUnlinkInFlight(PUSBPROXYDEVLNX pDevLnx, PUSBPROXYURBLNX pUrbLnx)
283{
284 LogFlowFunc(("pDevLnx=%p pUrbLnx=%p\n", pDevLnx, pUrbLnx));
285 RTCritSectEnter(&pDevLnx->CritSect);
286
287 /*
288 * Remove from the active list.
289 */
290 Assert(!pUrbLnx->pSplitHead || pUrbLnx->pSplitHead == pUrbLnx);
291
292 RTListNodeRemove(&pUrbLnx->NodeList);
293
294 RTCritSectLeave(&pDevLnx->CritSect);
295}
296
297/**
298 * Allocates a linux URB request structure.
299 * @returns Pointer to an active URB request.
300 * @returns NULL on failure.
301 * @param pProxyDev The proxy device instance.
302 * @param pSplitHead The split list head if allocating for a split list.
303 */
304static PUSBPROXYURBLNX usbProxyLinuxUrbAlloc(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pSplitHead)
305{
306 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
307 PUSBPROXYURBLNX pUrbLnx;
308
309 LogFlowFunc(("pProxyDev=%p pSplitHead=%p\n", pProxyDev, pSplitHead));
310
311 RTCritSectEnter(&pDevLnx->CritSect);
312
313 /*
314 * Try remove a linux URB from the free list, if none there allocate a new one.
315 */
316 pUrbLnx = RTListGetFirst(&pDevLnx->ListFree, USBPROXYURBLNX, NodeList);
317 if (pUrbLnx)
318 {
319 RTListNodeRemove(&pUrbLnx->NodeList);
320 RTCritSectLeave(&pDevLnx->CritSect);
321 }
322 else
323 {
324 RTCritSectLeave(&pDevLnx->CritSect);
325 pUrbLnx = (PUSBPROXYURBLNX)RTMemAlloc(sizeof(*pUrbLnx));
326 if (!pUrbLnx)
327 return NULL;
328 }
329
330 pUrbLnx->pSplitHead = pSplitHead;
331 pUrbLnx->pSplitNext = NULL;
332 pUrbLnx->fCanceledBySubmit = false;
333 pUrbLnx->fSplitElementReaped = false;
334 pUrbLnx->fDiscarded = false;
335 LogFlowFunc(("returns pUrbLnx=%p\n", pUrbLnx));
336 return pUrbLnx;
337}
338
339
340/**
341 * Frees a linux URB request structure.
342 *
343 * @param pProxyDev The proxy device instance.
344 * @param pUrbLnx The linux URB to free.
345 */
346static void usbProxyLinuxUrbFree(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
347{
348 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
349
350 LogFlowFunc(("pProxyDev=%p pUrbLnx=%p\n", pProxyDev, pUrbLnx));
351
352 /*
353 * Link it into the free list.
354 */
355 RTCritSectEnter(&pDevLnx->CritSect);
356 RTListAppend(&pDevLnx->ListFree, &pUrbLnx->NodeList);
357 RTCritSectLeave(&pDevLnx->CritSect);
358}
359
360
361/**
362 * Frees split list of a linux URB request structure.
363 *
364 * @param pProxyDev The proxy device instance.
365 * @param pUrbLnx A linux URB to in the split list to be freed.
366 */
367static void usbProxyLinuxUrbFreeSplitList(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx)
368{
369 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
370
371 LogFlowFunc(("pProxyDev=%p pUrbLnx=%p\n", pProxyDev, pUrbLnx));
372
373 RTCritSectEnter(&pDevLnx->CritSect);
374
375 pUrbLnx = pUrbLnx->pSplitHead;
376 Assert(pUrbLnx);
377 while (pUrbLnx)
378 {
379 PUSBPROXYURBLNX pFree = pUrbLnx;
380 pUrbLnx = pUrbLnx->pSplitNext;
381 Assert(pFree->pSplitHead);
382 pFree->pSplitHead = pFree->pSplitNext = NULL;
383 usbProxyLinuxUrbFree(pProxyDev, pFree);
384 }
385
386 RTCritSectLeave(&pDevLnx->CritSect);
387}
388
389
390/**
391 * This finds the device in the /proc/bus/usb/bus/addr file and finds
392 * the config with an asterix.
393 *
394 * @returns The Cfg#.
395 * @returns -1 if no active config.
396 * @param pProxyDev The proxy device instance.
397 * @param pszDevNode The path to the device. We infere the location of
398 * the devices file, which bus and device number we're
399 * looking for.
400 * @param piFirstCfg The first configuration. (optional)
401 * @internal
402 */
403static int usbProxyLinuxFindActiveConfigUsbfs(PUSBPROXYDEV pProxyDev, const char *pszDevNode, int *piFirstCfg)
404{
405 RT_NOREF(pProxyDev);
406
407 /*
408 * Set return defaults.
409 */
410 int iActiveCfg = -1;
411 if (piFirstCfg)
412 *piFirstCfg = 1;
413
414 /*
415 * Parse the usbfs device node path and turn it into a path to the "devices" file,
416 * picking up the device number and bus along the way.
417 */
418 size_t cchDevNode = strlen(pszDevNode);
419 char *pszDevices = (char *)RTMemDupEx(pszDevNode, cchDevNode, sizeof("devices"));
420 AssertReturn(pszDevices, iActiveCfg);
421
422 /* the device number */
423 char *psz = pszDevices + cchDevNode;
424 while (*psz != '/')
425 psz--;
426 Assert(pszDevices < psz);
427 uint32_t uDev;
428 int rc = RTStrToUInt32Ex(psz + 1, NULL, 10, &uDev);
429 if (RT_SUCCESS(rc))
430 {
431 /* the bus number */
432 *psz-- = '\0';
433 while (*psz != '/')
434 psz--;
435 Assert(pszDevices < psz);
436 uint32_t uBus;
437 rc = RTStrToUInt32Ex(psz + 1, NULL, 10, &uBus);
438 if (RT_SUCCESS(rc))
439 {
440 strcpy(psz + 1, "devices");
441
442 /*
443 * Open and scan the devices file.
444 * We're ASSUMING that each device starts off with a 'T:' line.
445 */
446 PRTSTREAM pFile;
447 rc = RTStrmOpen(pszDevices, "r", &pFile);
448 if (RT_SUCCESS(rc))
449 {
450 char szLine[1024];
451 while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
452 {
453 /* we're only interested in 'T:' lines. */
454 psz = RTStrStripL(szLine);
455 if (psz[0] != 'T' || psz[1] != ':')
456 continue;
457
458 /* Skip ahead to 'Bus' and compare */
459 psz = RTStrStripL(psz + 2); Assert(!strncmp(psz, RT_STR_TUPLE("Bus=")));
460 psz = RTStrStripL(psz + 4);
461 char *pszNext;
462 uint32_t u;
463 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
464 if (RT_FAILURE(rc))
465 continue;
466 if (u != uBus)
467 continue;
468
469 /* Skip ahead to 'Dev#' and compare */
470 psz = strstr(psz, "Dev#="); Assert(psz);
471 if (!psz)
472 continue;
473 psz = RTStrStripL(psz + 5);
474 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
475 if (RT_FAILURE(rc))
476 continue;
477 if (u != uDev)
478 continue;
479
480 /*
481 * Ok, we've found the device.
482 * Scan until we find a selected configuration, the next device, or EOF.
483 */
484 while (RT_SUCCESS(RTStrmGetLine(pFile, szLine, sizeof(szLine))))
485 {
486 psz = RTStrStripL(szLine);
487 if (psz[0] == 'T')
488 break;
489 if (psz[0] != 'C' || psz[1] != ':')
490 continue;
491 const bool fActive = psz[2] == '*';
492 if (!fActive && !piFirstCfg)
493 continue;
494
495 /* Get the 'Cfg#' value. */
496 psz = strstr(psz, "Cfg#="); Assert(psz);
497 if (psz)
498 {
499 psz = RTStrStripL(psz + 5);
500 rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u); AssertRC(rc);
501 if (RT_SUCCESS(rc))
502 {
503 if (piFirstCfg)
504 {
505 *piFirstCfg = u;
506 piFirstCfg = NULL;
507 }
508 if (fActive)
509 iActiveCfg = u;
510 }
511 }
512 if (fActive)
513 break;
514 }
515 break;
516 }
517 RTStrmClose(pFile);
518 }
519 }
520 }
521 RTMemFree(pszDevices);
522
523 return iActiveCfg;
524}
525
526
527/**
528 * This finds the active configuration from sysfs.
529 *
530 * @returns The Cfg#.
531 * @returns -1 if no active config.
532 * @param pProxyDev The proxy device instance.
533 * @param pszPath The sysfs path for the device.
534 * @param piFirstCfg The first configuration. (optional)
535 * @internal
536 */
537static int usbProxyLinuxFindActiveConfigSysfs(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
538{
539#ifdef VBOX_USB_WITH_SYSFS
540 if (piFirstCfg != NULL)
541 *piFirstCfg = pProxyDev->paCfgDescs != NULL
542 ? pProxyDev->paCfgDescs[0].Core.bConfigurationValue
543 : 1;
544 int64_t bCfg = 0;
545 int rc = RTLinuxSysFsReadIntFile(10, &bCfg, "%s/bConfigurationValue", pszPath);
546 if (RT_FAILURE(rc))
547 bCfg = -1;
548 return (int)bCfg;
549#else /* !VBOX_USB_WITH_SYSFS */
550 return -1;
551#endif /* !VBOX_USB_WITH_SYSFS */
552}
553
554
555/**
556 * This finds the active configuration.
557 *
558 * @returns The Cfg#.
559 * @returns -1 if no active config.
560 * @param pProxyDev The proxy device instance.
561 * @param pszPath The sysfs path for the device, or the usbfs device
562 * node path.
563 * @param piFirstCfg The first configuration. (optional)
564 * @internal
565 */
566static int usbProxyLinuxFindActiveConfig(PUSBPROXYDEV pProxyDev, const char *pszPath, int *piFirstCfg)
567{
568 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
569 if (pDevLnx->fUsingSysfs)
570 return usbProxyLinuxFindActiveConfigSysfs(pProxyDev, pszPath, piFirstCfg);
571 return usbProxyLinuxFindActiveConfigUsbfs(pProxyDev, pszPath, piFirstCfg);
572}
573
574
575/**
576 * Extracts the Linux file descriptor associated with the kernel USB device.
577 * This is used by rdesktop-vrdp for polling for events.
578 * @returns the FD, or asserts and returns -1 on error
579 * @param pProxyDev The device instance
580 */
581RTDECL(int) USBProxyDeviceLinuxGetFD(PUSBPROXYDEV pProxyDev)
582{
583 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
584 AssertReturn(pDevLnx->hFile != NIL_RTFILE, -1);
585 return RTFileToNative(pDevLnx->hFile);
586}
587
588
589/**
590 * Opens the device file.
591 *
592 * @returns VBox status code.
593 * @param pProxyDev The device instance.
594 * @param pszAddress If we are using usbfs, this is the path to the
595 * device. If we are using sysfs, this is a string of
596 * the form "sysfs:<sysfs path>//device:<device node>".
597 * In the second case, the two paths are guaranteed
598 * not to contain the substring "//".
599 */
600static DECLCALLBACK(int) usbProxyLinuxOpen(PUSBPROXYDEV pProxyDev, const char *pszAddress)
601{
602 LogFlow(("usbProxyLinuxOpen: pProxyDev=%p pszAddress=%s\n", pProxyDev, pszAddress));
603 const char *pszDevNode;
604 const char *pszPath;
605 size_t cchPath;
606 bool fUsingSysfs;
607
608 /*
609 * Are we using sysfs or usbfs?
610 */
611#ifdef VBOX_USB_WITH_SYSFS
612 fUsingSysfs = strncmp(pszAddress, RT_STR_TUPLE("sysfs:")) == 0;
613 if (fUsingSysfs)
614 {
615 pszDevNode = strstr(pszAddress, "//device:");
616 if (!pszDevNode)
617 {
618 LogRel(("usbProxyLinuxOpen: Invalid device address: '%s'\n", pszAddress));
619 return VERR_INVALID_PARAMETER;
620 }
621
622 pszPath = pszAddress + sizeof("sysfs:") - 1;
623 cchPath = pszDevNode - pszPath;
624 pszDevNode += sizeof("//device:") - 1;
625 }
626 else
627#endif /* VBOX_USB_WITH_SYSFS */
628 {
629#ifndef VBOX_USB_WITH_SYSFS
630 fUsingSysfs = false;
631#endif
632 pszPath = pszDevNode = pszAddress;
633 cchPath = strlen(pszPath);
634 }
635
636 /*
637 * Try open the device node.
638 */
639 RTFILE hFile;
640 int rc = RTFileOpen(&hFile, pszDevNode, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
641 if (RT_SUCCESS(rc))
642 {
643 /*
644 * Initialize the linux backend data.
645 */
646 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
647
648 RTListInit(&pDevLnx->ListFree);
649 RTListInit(&pDevLnx->ListInFlight);
650 pDevLnx->pszPath = RTStrDupN(pszPath, cchPath);
651 if (pDevLnx->pszPath)
652 {
653 rc = RTPipeCreate(&pDevLnx->hPipeWakeupR, &pDevLnx->hPipeWakeupW, 0);
654 if (RT_SUCCESS(rc))
655 {
656 pDevLnx->fUsingSysfs = fUsingSysfs;
657 pDevLnx->hFile = hFile;
658 pDevLnx->fClaimedIfsMask = 0;
659 rc = RTCritSectInit(&pDevLnx->CritSect);
660 if (RT_SUCCESS(rc))
661 {
662 LogFlow(("usbProxyLinuxOpen(%p, %s): returns successfully File=%RTfile iActiveCfg=%d\n",
663 pProxyDev, pszAddress, pDevLnx->hFile, pProxyDev->iActiveCfg));
664
665 return VINF_SUCCESS;
666 }
667 RTPipeClose(pDevLnx->hPipeWakeupR);
668 RTPipeClose(pDevLnx->hPipeWakeupW);
669 }
670 }
671 else
672 rc = VERR_NO_MEMORY;
673
674 RTFileClose(hFile);
675 }
676 else if (rc == VERR_ACCESS_DENIED)
677 rc = VERR_VUSB_USBFS_PERMISSION;
678
679 Log(("usbProxyLinuxOpen(%p, %s) failed, rc=%Rrc!\n", pProxyDev, pszAddress, rc));
680 return rc;
681}
682
683
684/**
685 * Claims all the interfaces and figures out the
686 * current configuration.
687 *
688 * @returns VINF_SUCCESS.
689 * @param pProxyDev The proxy device.
690 */
691static DECLCALLBACK(int) usbProxyLinuxInit(PUSBPROXYDEV pProxyDev)
692{
693 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
694
695 /*
696 * Brute force rulez.
697 * usbProxyLinuxSetConnected check for masked interfaces.
698 */
699 unsigned iIf;
700 for (iIf = 0; iIf < 256; iIf++)
701 usbProxyLinuxSetConnected(pProxyDev, iIf, false, true);
702
703 /*
704 * Determine the active configuration.
705 *
706 * If there isn't any active configuration, we will get EHOSTUNREACH (113) errors
707 * when trying to read the device descriptors in usbProxyDevCreate. So, we'll make
708 * the first one active (usually 1) then.
709 */
710 pProxyDev->cIgnoreSetConfigs = 1;
711 int iFirstCfg;
712 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, &iFirstCfg);
713 if (pProxyDev->iActiveCfg == -1)
714 {
715 usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iFirstCfg, false, UINT32_MAX);
716 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, NULL);
717 Log(("usbProxyLinuxInit: No active config! Tried to set %d: iActiveCfg=%d\n", iFirstCfg, pProxyDev->iActiveCfg));
718 }
719 else
720 Log(("usbProxyLinuxInit(%p): iActiveCfg=%d\n", pProxyDev, pProxyDev->iActiveCfg));
721 return VINF_SUCCESS;
722}
723
724
725/**
726 * Closes the proxy device.
727 */
728static DECLCALLBACK(void) usbProxyLinuxClose(PUSBPROXYDEV pProxyDev)
729{
730 LogFlow(("usbProxyLinuxClose: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
731 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
732 AssertPtrReturnVoid(pDevLnx);
733
734 /*
735 * Try put the device in a state which linux can cope with before we release it.
736 * Resetting it would be a nice start, although we must remember
737 * that it might have been disconnected...
738 *
739 * Don't reset if we're masking interfaces or if construction failed.
740 */
741 if (pProxyDev->fInited)
742 {
743 /* ASSUMES: thread == EMT */
744 if ( pProxyDev->fMaskedIfs
745 || !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
746 {
747 /* Connect drivers. */
748 unsigned iIf;
749 for (iIf = 0; iIf < 256; iIf++)
750 usbProxyLinuxSetConnected(pProxyDev, iIf, true, true);
751 Log(("USB: Successfully reset device pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
752 }
753 else if (errno != ENODEV)
754 LogRel(("USB: Reset failed, errno=%d, pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
755 else /* This will happen if device was detached. */
756 Log(("USB: Reset failed, errno=%d (ENODEV), pProxyDev=%s.\n", errno, usbProxyGetName(pProxyDev)));
757 }
758
759 /*
760 * Now we can free all the resources and close the device.
761 */
762 RTCritSectDelete(&pDevLnx->CritSect);
763
764 PUSBPROXYURBLNX pUrbLnx;
765 PUSBPROXYURBLNX pUrbLnxNext;
766 RTListForEachSafe(&pDevLnx->ListInFlight, pUrbLnx, pUrbLnxNext, USBPROXYURBLNX, NodeList)
767 {
768 RTListNodeRemove(&pUrbLnx->NodeList);
769
770 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX)
771 && errno != ENODEV
772 && errno != ENOENT)
773 AssertMsgFailed(("errno=%d\n", errno));
774
775 if (pUrbLnx->pSplitHead)
776 {
777 PUSBPROXYURBLNX pCur = pUrbLnx->pSplitNext;
778 while (pCur)
779 {
780 PUSBPROXYURBLNX pFree = pCur;
781 pCur = pFree->pSplitNext;
782 if ( !pFree->fSplitElementReaped
783 && usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pFree->KUrb, false, UINT32_MAX)
784 && errno != ENODEV
785 && errno != ENOENT)
786 AssertMsgFailed(("errno=%d\n", errno));
787 RTMemFree(pFree);
788 }
789 }
790 else
791 Assert(!pUrbLnx->pSplitNext);
792 RTMemFree(pUrbLnx);
793 }
794
795 RTListForEachSafe(&pDevLnx->ListFree, pUrbLnx, pUrbLnxNext, USBPROXYURBLNX, NodeList)
796 {
797 RTListNodeRemove(&pUrbLnx->NodeList);
798 RTMemFree(pUrbLnx);
799 }
800
801 RTFileClose(pDevLnx->hFile);
802 pDevLnx->hFile = NIL_RTFILE;
803
804 RTPipeClose(pDevLnx->hPipeWakeupR);
805 RTPipeClose(pDevLnx->hPipeWakeupW);
806
807 RTStrFree(pDevLnx->pszPath);
808
809 LogFlow(("usbProxyLinuxClose: returns\n"));
810}
811
812
813/** @interface_method_impl{USBPROXYBACK,pfnReset} */
814static DECLCALLBACK(int) usbProxyLinuxReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
815{
816 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
817 RT_NOREF(fResetOnLinux);
818 Assert(!pProxyDev->fMaskedIfs);
819 LogFlow(("usbProxyLinuxReset: pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
820
821 uint32_t fActiveIfsMask = pDevLnx->fClaimedIfsMask;
822 unsigned i;
823
824 /*
825 * Before reset, release claimed interfaces. This less than obvious move
826 * prevents Linux from rebinding in-kernel drivers to the device after reset.
827 */
828 for (i = 0; i < (sizeof(fActiveIfsMask) * 8); ++i)
829 {
830 if (fActiveIfsMask & RT_BIT(i))
831 {
832 usbProxyLinuxReleaseInterface(pProxyDev, i);
833 }
834 }
835
836 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RESET, NULL, false, 10))
837 {
838 int rc = errno;
839 LogRel(("usb-linux: Reset failed, rc=%Rrc errno=%d.\n", RTErrConvertFromErrno(rc), rc));
840 pProxyDev->iActiveCfg = -1;
841 return RTErrConvertFromErrno(rc);
842 }
843
844 /*
845 * Now reclaim previously claimed interfaces. If that doesn't work, let's hope
846 * the guest/VUSB can recover from that. Can happen if reset changes configuration.
847 */
848 for (i = 0; i < (sizeof(fActiveIfsMask) * 8); ++i)
849 {
850 if (fActiveIfsMask & RT_BIT(i))
851 {
852 usbProxyLinuxClaimInterface(pProxyDev, i);
853 }
854 }
855
856 /* find the active config - damn annoying. */
857 pProxyDev->iActiveCfg = usbProxyLinuxFindActiveConfig(pProxyDev, pDevLnx->pszPath, NULL);
858 LogFlow(("usbProxyLinuxReset: returns successfully iActiveCfg=%d\n", pProxyDev->iActiveCfg));
859
860 pProxyDev->cIgnoreSetConfigs = 2;
861 return VINF_SUCCESS;
862}
863
864
865/**
866 * SET_CONFIGURATION.
867 *
868 * The caller makes sure that it's not called first time after open or reset
869 * with the active interface.
870 *
871 * @returns success indicator.
872 * @param pProxyDev The device instance data.
873 * @param iCfg The configuration to set.
874 */
875static DECLCALLBACK(int) usbProxyLinuxSetConfig(PUSBPROXYDEV pProxyDev, int iCfg)
876{
877 LogFlow(("usbProxyLinuxSetConfig: pProxyDev=%s cfg=%#x\n",
878 usbProxyGetName(pProxyDev), iCfg));
879
880 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETCONFIGURATION, &iCfg, true, UINT32_MAX))
881 {
882 Log(("usb-linux: Set configuration. errno=%d\n", errno));
883 return RTErrConvertFromErrno(errno);
884 }
885 return VINF_SUCCESS;
886}
887
888
889/**
890 * Claims an interface.
891 * @returns success indicator.
892 */
893static DECLCALLBACK(int) usbProxyLinuxClaimInterface(PUSBPROXYDEV pProxyDev, int iIf)
894{
895 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
896
897 LogFlow(("usbProxyLinuxClaimInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
898 usbProxyLinuxSetConnected(pProxyDev, iIf, false, false);
899
900 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLAIMINTERFACE, &iIf, true, UINT32_MAX))
901 {
902 pDevLnx->fClaimedIfsMask &= ~RT_BIT(iIf);
903 LogRel(("usb-linux: Claim interface. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
904 return RTErrConvertFromErrno(errno);
905 }
906 pDevLnx->fClaimedIfsMask |= RT_BIT(iIf);
907 return VINF_SUCCESS;
908}
909
910
911/**
912 * Releases an interface.
913 * @returns success indicator.
914 */
915static DECLCALLBACK(int) usbProxyLinuxReleaseInterface(PUSBPROXYDEV pProxyDev, int iIf)
916{
917 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
918
919 LogFlow(("usbProxyLinuxReleaseInterface: pProxyDev=%s ifnum=%#x\n", usbProxyGetName(pProxyDev), iIf));
920
921 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_RELEASEINTERFACE, &iIf, true, UINT32_MAX))
922 {
923 LogRel(("usb-linux: Release interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
924 return RTErrConvertFromErrno(errno);
925 }
926 pDevLnx->fClaimedIfsMask &= ~RT_BIT(iIf);
927 return VINF_SUCCESS;
928}
929
930
931/**
932 * SET_INTERFACE.
933 *
934 * @returns success indicator.
935 */
936static DECLCALLBACK(int) usbProxyLinuxSetInterface(PUSBPROXYDEV pProxyDev, int iIf, int iAlt)
937{
938 struct usbdevfs_setinterface SetIf;
939 LogFlow(("usbProxyLinuxSetInterface: pProxyDev=%p iIf=%#x iAlt=%#x\n", pProxyDev, iIf, iAlt));
940
941 SetIf.interface = iIf;
942 SetIf.altsetting = iAlt;
943 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_SETINTERFACE, &SetIf, true, UINT32_MAX))
944 {
945 Log(("usb-linux: Set interface, errno=%d. pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
946 return RTErrConvertFromErrno(errno);
947 }
948 return VINF_SUCCESS;
949}
950
951
952/**
953 * Clears the halted endpoint 'EndPt'.
954 */
955static DECLCALLBACK(int) usbProxyLinuxClearHaltedEp(PUSBPROXYDEV pProxyDev, unsigned int EndPt)
956{
957 LogFlow(("usbProxyLinuxClearHaltedEp: pProxyDev=%s EndPt=%u\n", usbProxyGetName(pProxyDev), EndPt));
958
959 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_CLEAR_HALT, &EndPt, true, UINT32_MAX))
960 {
961 /*
962 * Unfortunately this doesn't work on control pipes.
963 * Windows doing this on the default endpoint and possibly other pipes too,
964 * so we'll feign success for ENOENT errors.
965 */
966 if (errno == ENOENT)
967 {
968 Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d - IGNORED\n",
969 errno, usbProxyGetName(pProxyDev), EndPt));
970 return VINF_SUCCESS;
971 }
972 Log(("usb-linux: clear_halted_ep failed errno=%d. pProxyDev=%s ep=%d\n",
973 errno, usbProxyGetName(pProxyDev), EndPt));
974 return RTErrConvertFromErrno(errno);
975 }
976 return VINF_SUCCESS;
977}
978
979
980/**
981 * Setup packet byte-swapping routines.
982 */
983static void usbProxyLinuxUrbSwapSetup(PVUSBSETUP pSetup)
984{
985 pSetup->wValue = RT_H2LE_U16(pSetup->wValue);
986 pSetup->wIndex = RT_H2LE_U16(pSetup->wIndex);
987 pSetup->wLength = RT_H2LE_U16(pSetup->wLength);
988}
989
990
991/**
992 * Clean up after a failed URB submit.
993 */
994static void usbProxyLinuxCleanupFailedSubmit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
995{
996 if (pUrb->enmType == VUSBXFERTYPE_MSG)
997 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
998
999 /* discard and reap later (walking with pUrbLnx). */
1000 if (pUrbLnx != pCur)
1001 {
1002 for (;;)
1003 {
1004 pUrbLnx->fCanceledBySubmit = true;
1005 pUrbLnx->KUrb.usercontext = NULL;
1006 if (usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, false, UINT32_MAX))
1007 {
1008 if (errno == ENODEV)
1009 *pfUnplugged = true;
1010 else if (errno == ENOENT)
1011 pUrbLnx->fSplitElementReaped = true;
1012 else
1013 LogRel(("USB: Failed to discard %p! errno=%d (pUrb=%p)\n", pUrbLnx->KUrb.usercontext, errno, pUrb)); /* serious! */
1014 }
1015 if (pUrbLnx->pSplitNext == pCur)
1016 {
1017 pUrbLnx->pSplitNext = NULL;
1018 break;
1019 }
1020 pUrbLnx = pUrbLnx->pSplitNext; Assert(pUrbLnx);
1021 }
1022 }
1023
1024 /* free the unsubmitted ones. */
1025 while (pCur)
1026 {
1027 PUSBPROXYURBLNX pFree = pCur;
1028 pCur = pCur->pSplitNext;
1029 usbProxyLinuxUrbFree(pProxyDev, pFree);
1030 }
1031
1032 /* send unplug event if we failed with ENODEV originally. */
1033 if (*pfUnplugged)
1034 usbProxLinuxUrbUnplugged(pProxyDev);
1035}
1036
1037/**
1038 * Submit one URB through the usbfs IOCTL interface, with
1039 * retries
1040 *
1041 * @returns VBox status code.
1042 */
1043static int usbProxyLinuxSubmitURB(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pCur, PVUSBURB pUrb, bool *pfUnplugged)
1044{
1045 RT_NOREF(pUrb);
1046 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
1047 unsigned cTries = 0;
1048
1049 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_SUBMITURB, &pCur->KUrb))
1050 {
1051 if (errno == EINTR)
1052 continue;
1053 if (errno == ENODEV)
1054 {
1055 Log(("usbProxyLinuxSubmitURB: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
1056 *pfUnplugged = true;
1057 return RTErrConvertFromErrno(errno);
1058 }
1059
1060 Log(("usb-linux: Submit URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
1061 pUrb, errno, pCur->KUrb.type, pCur->KUrb.endpoint, pCur->KUrb.buffer_length, cTries));
1062 if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
1063 continue;
1064
1065 return RTErrConvertFromErrno(errno);
1066 }
1067 return VINF_SUCCESS;
1068}
1069
1070/** The split size. 16K in known Linux kernel versions. */
1071#define SPLIT_SIZE 0x4000
1072
1073/**
1074 * Create a URB fragment of up to SPLIT_SIZE size and hook it
1075 * into the list of fragments.
1076 *
1077 * @returns pointer to newly allocated URB fragment or NULL.
1078 */
1079static PUSBPROXYURBLNX usbProxyLinuxSplitURBFragment(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pHead, PUSBPROXYURBLNX pCur)
1080{
1081 PUSBPROXYURBLNX pNew;
1082 uint32_t cbLeft = pCur->cbSplitRemaining;
1083 uint8_t *pb = (uint8_t *)pCur->KUrb.buffer;
1084
1085 LogFlowFunc(("pProxyDev=%p pHead=%p pCur=%p\n", pProxyDev, pHead, pCur));
1086
1087 Assert(cbLeft != 0);
1088 pNew = pCur->pSplitNext = usbProxyLinuxUrbAlloc(pProxyDev, pHead);
1089 if (!pNew)
1090 {
1091 usbProxyLinuxUrbFreeSplitList(pProxyDev, pHead);
1092 return NULL;
1093 }
1094 Assert(pNew->pSplitHead == pHead);
1095 Assert(pNew->pSplitNext == NULL);
1096
1097 pNew->KUrb = pHead->KUrb;
1098 pNew->KUrb.buffer = pb + pCur->KUrb.buffer_length;
1099 pNew->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
1100 pNew->KUrb.actual_length = 0;
1101
1102 cbLeft -= pNew->KUrb.buffer_length;
1103 Assert(cbLeft < INT32_MAX);
1104 pNew->cbSplitRemaining = cbLeft;
1105 LogFlowFunc(("returns pNew=%p\n", pNew));
1106 return pNew;
1107}
1108
1109/**
1110 * Try splitting up a VUSB URB into smaller URBs which the
1111 * linux kernel (usbfs) can deal with.
1112 *
1113 * NB: For ShortOK reads things get a little tricky - we don't
1114 * know how much data is going to arrive and not all the
1115 * fragment URBs might be filled. We can only safely set up one
1116 * URB at a time -> worse performance but correct behaviour.
1117 *
1118 * @returns VBox status code.
1119 * @param pProxyDev The proxy device.
1120 * @param pUrbLnx The linux URB which was rejected because of being too big.
1121 * @param pUrb The VUSB URB.
1122 */
1123static int usbProxyLinuxUrbQueueSplit(PUSBPROXYDEV pProxyDev, PUSBPROXYURBLNX pUrbLnx, PVUSBURB pUrb)
1124{
1125 /*
1126 * Split it up into SPLIT_SIZE sized blocks.
1127 */
1128 const unsigned cKUrbs = (pUrb->cbData + SPLIT_SIZE - 1) / SPLIT_SIZE;
1129 LogFlow(("usbProxyLinuxUrbQueueSplit: pUrb=%p cKUrbs=%d cbData=%d\n", pUrb, cKUrbs, pUrb->cbData));
1130
1131 uint32_t cbLeft = pUrb->cbData;
1132 uint8_t *pb = &pUrb->abData[0];
1133
1134 /* the first one (already allocated) */
1135 switch (pUrb->enmType)
1136 {
1137 default: /* shut up gcc */
1138 case VUSBXFERTYPE_BULK: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK; break;
1139 case VUSBXFERTYPE_INTR: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT; break;
1140 case VUSBXFERTYPE_MSG: pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL; break;
1141 case VUSBXFERTYPE_ISOC:
1142 AssertMsgFailed(("We can't split isochronous URBs!\n"));
1143 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1144 return VERR_INVALID_PARAMETER; /** @todo Better status code. */
1145 }
1146 pUrbLnx->KUrb.endpoint = pUrb->EndPt;
1147 if (pUrb->enmDir == VUSBDIRECTION_IN)
1148 pUrbLnx->KUrb.endpoint |= 0x80;
1149 pUrbLnx->KUrb.flags = 0;
1150 if (pUrb->enmDir == VUSBDIRECTION_IN && pUrb->fShortNotOk)
1151 pUrbLnx->KUrb.flags |= USBDEVFS_URB_SHORT_NOT_OK;
1152 pUrbLnx->KUrb.status = 0;
1153 pUrbLnx->KUrb.buffer = pb;
1154 pUrbLnx->KUrb.buffer_length = RT_MIN(cbLeft, SPLIT_SIZE);
1155 pUrbLnx->KUrb.actual_length = 0;
1156 pUrbLnx->KUrb.start_frame = 0;
1157 pUrbLnx->KUrb.number_of_packets = 0;
1158 pUrbLnx->KUrb.error_count = 0;
1159 pUrbLnx->KUrb.signr = 0;
1160 pUrbLnx->KUrb.usercontext = pUrb;
1161 pUrbLnx->pSplitHead = pUrbLnx;
1162 pUrbLnx->pSplitNext = NULL;
1163
1164 PUSBPROXYURBLNX pCur = pUrbLnx;
1165
1166 cbLeft -= pUrbLnx->KUrb.buffer_length;
1167 pUrbLnx->cbSplitRemaining = cbLeft;
1168
1169 int rc = VINF_SUCCESS;
1170 bool fUnplugged = false;
1171 if (pUrb->enmDir == VUSBDIRECTION_IN && !pUrb->fShortNotOk)
1172 {
1173 /* Subsequent fragments will be queued only after the previous fragment is reaped
1174 * and only if necessary.
1175 */
1176 Log(("usb-linux: Large ShortOK read, only queuing first fragment.\n"));
1177 Assert(pUrbLnx->cbSplitRemaining > 0 && pUrbLnx->cbSplitRemaining < 256 * _1K);
1178 rc = usbProxyLinuxSubmitURB(pProxyDev, pUrbLnx, pUrb, &fUnplugged);
1179 }
1180 else
1181 {
1182 /* the rest. */
1183 unsigned i;
1184 for (i = 1; i < cKUrbs; i++)
1185 {
1186 pCur = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx, pCur);
1187 if (!pCur)
1188 return VERR_NO_MEMORY;
1189 }
1190 Assert(pCur->cbSplitRemaining == 0);
1191
1192 /* Submit the blocks. */
1193 pCur = pUrbLnx;
1194 for (i = 0; i < cKUrbs; i++, pCur = pCur->pSplitNext)
1195 {
1196 rc = usbProxyLinuxSubmitURB(pProxyDev, pCur, pUrb, &fUnplugged);
1197 if (RT_FAILURE(rc))
1198 break;
1199 }
1200 }
1201
1202 if (RT_SUCCESS(rc))
1203 {
1204 pUrb->Dev.pvPrivate = pUrbLnx;
1205 usbProxyLinuxUrbLinkInFlight(USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX), pUrbLnx);
1206 LogFlow(("usbProxyLinuxUrbQueueSplit: ok\n"));
1207 return VINF_SUCCESS;
1208 }
1209
1210 usbProxyLinuxCleanupFailedSubmit(pProxyDev, pUrbLnx, pCur, pUrb, &fUnplugged);
1211 return rc;
1212}
1213
1214
1215/**
1216 * @interface_method_impl{USBPROXYBACK,pfnUrbQueue}
1217 */
1218static DECLCALLBACK(int) usbProxyLinuxUrbQueue(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
1219{
1220 int rc = VINF_SUCCESS;
1221 unsigned cTries;
1222 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
1223 LogFlow(("usbProxyLinuxUrbQueue: pProxyDev=%s pUrb=%p EndPt=%d cbData=%d\n",
1224 usbProxyGetName(pProxyDev), pUrb, pUrb->EndPt, pUrb->cbData));
1225
1226 /*
1227 * Allocate a linux urb.
1228 */
1229 PUSBPROXYURBLNX pUrbLnx = usbProxyLinuxUrbAlloc(pProxyDev, NULL);
1230 if (!pUrbLnx)
1231 return VERR_NO_MEMORY;
1232
1233 pUrbLnx->KUrb.endpoint = pUrb->EndPt | (pUrb->enmDir == VUSBDIRECTION_IN ? 0x80 : 0);
1234 pUrbLnx->KUrb.status = 0;
1235 pUrbLnx->KUrb.flags = 0;
1236 if (pUrb->enmDir == VUSBDIRECTION_IN && pUrb->fShortNotOk)
1237 pUrbLnx->KUrb.flags |= USBDEVFS_URB_SHORT_NOT_OK;
1238 pUrbLnx->KUrb.buffer = pUrb->abData;
1239 pUrbLnx->KUrb.buffer_length = pUrb->cbData;
1240 pUrbLnx->KUrb.actual_length = 0;
1241 pUrbLnx->KUrb.start_frame = 0;
1242 pUrbLnx->KUrb.number_of_packets = 0;
1243 pUrbLnx->KUrb.error_count = 0;
1244 pUrbLnx->KUrb.signr = 0;
1245 pUrbLnx->KUrb.usercontext = pUrb;
1246
1247 switch (pUrb->enmType)
1248 {
1249 case VUSBXFERTYPE_MSG:
1250 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_CONTROL;
1251 if (pUrb->cbData < sizeof(VUSBSETUP))
1252 {
1253 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1254 return VERR_BUFFER_UNDERFLOW;
1255 }
1256 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1257 LogFlow(("usbProxyLinuxUrbQueue: message\n"));
1258 break;
1259 case VUSBXFERTYPE_BULK:
1260 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_BULK;
1261 break;
1262 case VUSBXFERTYPE_ISOC:
1263 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_ISO;
1264 pUrbLnx->KUrb.flags |= USBDEVFS_URB_ISO_ASAP;
1265 pUrbLnx->KUrb.number_of_packets = pUrb->cIsocPkts;
1266 unsigned i;
1267 for (i = 0; i < pUrb->cIsocPkts; i++)
1268 {
1269#if RT_GNUC_PREREQ(4, 6)
1270# pragma GCC diagnostic push
1271# pragma GCC diagnostic ignored "-Warray-bounds"
1272#endif
1273 pUrbLnx->KUrb.iso_frame_desc[i].length = pUrb->aIsocPkts[i].cb;
1274 pUrbLnx->KUrb.iso_frame_desc[i].actual_length = 0;
1275 pUrbLnx->KUrb.iso_frame_desc[i].status = 0x7fff;
1276#if RT_GNUC_PREREQ(4, 6)
1277# pragma GCC diagnostic pop
1278#endif
1279 }
1280 break;
1281 case VUSBXFERTYPE_INTR:
1282 pUrbLnx->KUrb.type = USBDEVFS_URB_TYPE_INTERRUPT;
1283 break;
1284 default:
1285 rc = VERR_INVALID_PARAMETER; /** @todo better status code. */
1286 }
1287
1288 /*
1289 * We have to serialize access by using the critial section here because this
1290 * thread might be suspended after submitting the URB but before linking it into
1291 * the in flight list. This would get us in trouble when reaping the URB on another
1292 * thread while it isn't in the in flight list.
1293 *
1294 * Linking the URB into the list before submitting it like it was done in the past is not
1295 * possible either because submitting the URB might fail here because the device gets
1296 * detached. The reaper thread gets this event too and might race this thread before we
1297 * can unlink the URB from the active list and the common code might end up freeing
1298 * the common URB structure twice.
1299 */
1300 RTCritSectEnter(&pDevLnx->CritSect);
1301 /*
1302 * Submit it.
1303 */
1304 cTries = 0;
1305 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_SUBMITURB, &pUrbLnx->KUrb))
1306 {
1307 if (errno == EINTR)
1308 continue;
1309 if (errno == ENODEV)
1310 {
1311 rc = RTErrConvertFromErrno(errno);
1312 Log(("usbProxyLinuxUrbQueue: ENODEV -> unplugged. pProxyDev=%s\n", usbProxyGetName(pProxyDev)));
1313 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1314 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1315
1316 RTCritSectLeave(&pDevLnx->CritSect);
1317 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1318 usbProxLinuxUrbUnplugged(pProxyDev);
1319 return rc;
1320 }
1321
1322 /*
1323 * usbfs has or used to have a low buffer limit (16KB) in order to prevent
1324 * processes wasting kmalloc'ed memory. It will return EINVAL if break that
1325 * limit, and we'll have to split the VUSB URB up into multiple linux URBs.
1326 *
1327 * Since this is a limit which is subject to change, we cannot check for it
1328 * before submitting the URB. We just have to try and fail.
1329 */
1330 if ( errno == EINVAL
1331 && pUrb->cbData >= 8*_1K)
1332 {
1333 rc = usbProxyLinuxUrbQueueSplit(pProxyDev, pUrbLnx, pUrb);
1334 RTCritSectLeave(&pDevLnx->CritSect);
1335 return rc;
1336 }
1337
1338 Log(("usb-linux: Queue URB %p -> %d!!! type=%d ep=%#x buffer_length=%#x cTries=%d\n",
1339 pUrb, errno, pUrbLnx->KUrb.type, pUrbLnx->KUrb.endpoint, pUrbLnx->KUrb.buffer_length, cTries));
1340 if (errno != EBUSY && ++cTries < 3) /* this doesn't work for the floppy :/ */
1341 continue;
1342
1343 RTCritSectLeave(&pDevLnx->CritSect);
1344 rc = RTErrConvertFromErrno(errno);
1345 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1346 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1347 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1348 return rc;
1349 }
1350
1351 usbProxyLinuxUrbLinkInFlight(pDevLnx, pUrbLnx);
1352 RTCritSectLeave(&pDevLnx->CritSect);
1353
1354 LogFlow(("usbProxyLinuxUrbQueue: ok\n"));
1355 pUrb->Dev.pvPrivate = pUrbLnx;
1356 return rc;
1357}
1358
1359
1360/**
1361 * Translate the linux status to a VUSB status.
1362 *
1363 * @remarks see cc_to_error in ohci.h, uhci_map_status in uhci-q.c,
1364 * sitd_complete+itd_complete in ehci-sched.c, and qtd_copy_status in
1365 * ehci-q.c.
1366 */
1367static VUSBSTATUS vusbProxyLinuxStatusToVUsbStatus(int iStatus)
1368{
1369 switch (iStatus)
1370 {
1371 /** @todo VUSBSTATUS_NOT_ACCESSED */
1372 case -EXDEV: /* iso transfer, partial result. */
1373 case 0:
1374 return VUSBSTATUS_OK;
1375
1376 case -EILSEQ:
1377 return VUSBSTATUS_CRC;
1378
1379 case -EREMOTEIO: /* ehci and ohci uses this for underflow error. */
1380 return VUSBSTATUS_DATA_UNDERRUN;
1381 case -EOVERFLOW:
1382 return VUSBSTATUS_DATA_OVERRUN;
1383
1384 case -ETIME:
1385 case -ENODEV:
1386 return VUSBSTATUS_DNR;
1387
1388 //case -ECOMM:
1389 // return VUSBSTATUS_BUFFER_OVERRUN;
1390 //case -ENOSR:
1391 // return VUSBSTATUS_BUFFER_UNDERRUN;
1392
1393 case -EPROTO:
1394 Log(("vusbProxyLinuxStatusToVUsbStatus: DNR/EPPROTO!!\n"));
1395 return VUSBSTATUS_DNR;
1396
1397 case -EPIPE:
1398 Log(("vusbProxyLinuxStatusToVUsbStatus: STALL/EPIPE!!\n"));
1399 return VUSBSTATUS_STALL;
1400
1401 case -ESHUTDOWN:
1402 Log(("vusbProxyLinuxStatusToVUsbStatus: SHUTDOWN!!\n"));
1403 return VUSBSTATUS_STALL;
1404
1405 case -ENOENT:
1406 Log(("vusbProxyLinuxStatusToVUsbStatus: ENOENT!!\n"));
1407 return VUSBSTATUS_STALL;
1408
1409 default:
1410 Log(("vusbProxyLinuxStatusToVUsbStatus: status %d!!\n", iStatus));
1411 return VUSBSTATUS_STALL;
1412 }
1413}
1414
1415
1416/**
1417 * Get and translates the linux status to a VUSB status.
1418 */
1419static VUSBSTATUS vusbProxyLinuxUrbGetStatus(PUSBPROXYURBLNX pUrbLnx)
1420{
1421 return vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.status);
1422}
1423
1424
1425/**
1426 * Reap URBs in-flight on a device.
1427 *
1428 * @returns Pointer to a completed URB.
1429 * @returns NULL if no URB was completed.
1430 * @param pProxyDev The device.
1431 * @param cMillies Number of milliseconds to wait. Use 0 to not wait at all.
1432 */
1433static DECLCALLBACK(PVUSBURB) usbProxyLinuxUrbReap(PUSBPROXYDEV pProxyDev, RTMSINTERVAL cMillies)
1434{
1435 PUSBPROXYURBLNX pUrbLnx = NULL;
1436 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
1437
1438 /*
1439 * Block for requested period.
1440 *
1441 * It seems to me that the path of poll() is shorter and
1442 * involves less semaphores than ioctl() on usbfs. So, we'll
1443 * do a poll regardless of whether cMillies == 0 or not.
1444 */
1445 if (cMillies)
1446 {
1447 int cMilliesWait = cMillies == RT_INDEFINITE_WAIT ? -1 : cMillies;
1448
1449 for (;;)
1450 {
1451 struct pollfd pfd[2];
1452 pfd[0].fd = RTFileToNative(pDevLnx->hFile);
1453 pfd[0].events = POLLOUT | POLLWRNORM /* completed async */
1454 | POLLERR | POLLHUP /* disconnected */;
1455 pfd[0].revents = 0;
1456
1457 pfd[1].fd = RTPipeToNative(pDevLnx->hPipeWakeupR);
1458 pfd[1].events = POLLIN | POLLHUP;
1459 pfd[1].revents = 0;
1460
1461 int rc = poll(&pfd[0], 2, cMilliesWait);
1462 Log(("usbProxyLinuxUrbReap: poll rc = %d\n", rc));
1463 if (rc >= 1)
1464 {
1465 /* If the pipe caused the return drain it. */
1466 if (pfd[1].revents & POLLIN)
1467 {
1468 uint8_t bRead;
1469 size_t cbIgnored = 0;
1470 RTPipeRead(pDevLnx->hPipeWakeupR, &bRead, 1, &cbIgnored);
1471 }
1472 break;
1473 }
1474 if (rc >= 0)
1475 return NULL;
1476
1477 if (errno != EAGAIN)
1478 {
1479 Log(("usb-linux: Reap URB - poll -> %d errno=%d pProxyDev=%s\n", rc, errno, usbProxyGetName(pProxyDev)));
1480 return NULL;
1481 }
1482 Log(("usbProxyLinuxUrbReap: poll again - weird!!!\n"));
1483 }
1484 }
1485
1486 /*
1487 * Reap URBs, non-blocking.
1488 */
1489 for (;;)
1490 {
1491 struct usbdevfs_urb *pKUrb;
1492 while (ioctl(RTFileToNative(pDevLnx->hFile), USBDEVFS_REAPURBNDELAY, &pKUrb))
1493 if (errno != EINTR)
1494 {
1495 if (errno == ENODEV)
1496 usbProxLinuxUrbUnplugged(pProxyDev);
1497 else
1498 Log(("usb-linux: Reap URB. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1499 return NULL;
1500 }
1501 pUrbLnx = (PUSBPROXYURBLNX)pKUrb;
1502
1503 /* split list: Is the entire split list done yet? */
1504 if (pUrbLnx->pSplitHead)
1505 {
1506 pUrbLnx->fSplitElementReaped = true;
1507
1508 /* for variable size URBs, we may need to queue more if the just-reaped URB was completely filled */
1509 if (pUrbLnx->cbSplitRemaining && (pKUrb->actual_length == pKUrb->buffer_length) && !pUrbLnx->pSplitNext)
1510 {
1511 bool fUnplugged = false;
1512 bool fSucceeded;
1513
1514 Assert(pUrbLnx->pSplitHead);
1515 Assert((pKUrb->endpoint & 0x80) && !(pKUrb->flags & USBDEVFS_URB_SHORT_NOT_OK));
1516 PUSBPROXYURBLNX pNew = usbProxyLinuxSplitURBFragment(pProxyDev, pUrbLnx->pSplitHead, pUrbLnx);
1517 if (!pNew)
1518 {
1519 Log(("usb-linux: Allocating URB fragment failed. errno=%d pProxyDev=%s\n", errno, usbProxyGetName(pProxyDev)));
1520 return NULL;
1521 }
1522 PVUSBURB pUrb = (PVUSBURB)pUrbLnx->KUrb.usercontext;
1523 fSucceeded = usbProxyLinuxSubmitURB(pProxyDev, pNew, pUrb, &fUnplugged);
1524 if (fUnplugged)
1525 usbProxLinuxUrbUnplugged(pProxyDev);
1526 if (!fSucceeded)
1527 return NULL;
1528 continue; /* try reaping another URB */
1529 }
1530 PUSBPROXYURBLNX pCur;
1531 for (pCur = pUrbLnx->pSplitHead; pCur; pCur = pCur->pSplitNext)
1532 if (!pCur->fSplitElementReaped)
1533 {
1534 pUrbLnx = NULL;
1535 break;
1536 }
1537 if (!pUrbLnx)
1538 continue;
1539 pUrbLnx = pUrbLnx->pSplitHead;
1540 }
1541 break;
1542 }
1543
1544 /*
1545 * Ok, we got one!
1546 */
1547 PVUSBURB pUrb = (PVUSBURB)pUrbLnx->KUrb.usercontext;
1548 if ( pUrb
1549 && !pUrbLnx->fCanceledBySubmit)
1550 {
1551 if (pUrbLnx->pSplitHead)
1552 {
1553 /* split - find the end byte and the first error status. */
1554 Assert(pUrbLnx == pUrbLnx->pSplitHead);
1555 uint8_t *pbEnd = &pUrb->abData[0];
1556 pUrb->enmStatus = VUSBSTATUS_OK;
1557 PUSBPROXYURBLNX pCur;
1558 for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
1559 {
1560 if (pCur->KUrb.actual_length)
1561 pbEnd = (uint8_t *)pCur->KUrb.buffer + pCur->KUrb.actual_length;
1562 if (pUrb->enmStatus == VUSBSTATUS_OK)
1563 pUrb->enmStatus = vusbProxyLinuxUrbGetStatus(pCur);
1564 }
1565 pUrb->cbData = pbEnd - &pUrb->abData[0];
1566 usbProxyLinuxUrbUnlinkInFlight(pDevLnx, pUrbLnx);
1567 usbProxyLinuxUrbFreeSplitList(pProxyDev, pUrbLnx);
1568 }
1569 else
1570 {
1571 /* unsplit. */
1572 pUrb->enmStatus = vusbProxyLinuxUrbGetStatus(pUrbLnx);
1573 pUrb->cbData = pUrbLnx->KUrb.actual_length;
1574 if (pUrb->enmType == VUSBXFERTYPE_ISOC)
1575 {
1576 unsigned i, off;
1577 for (i = 0, off = 0; i < pUrb->cIsocPkts; i++)
1578 {
1579#if RT_GNUC_PREREQ(4, 6)
1580# pragma GCC diagnostic push
1581# pragma GCC diagnostic ignored "-Warray-bounds"
1582#endif
1583 pUrb->aIsocPkts[i].enmStatus = vusbProxyLinuxStatusToVUsbStatus(pUrbLnx->KUrb.iso_frame_desc[i].status);
1584 Assert(pUrb->aIsocPkts[i].off == off);
1585 pUrb->aIsocPkts[i].cb = pUrbLnx->KUrb.iso_frame_desc[i].actual_length;
1586 off += pUrbLnx->KUrb.iso_frame_desc[i].length;
1587#if RT_GNUC_PREREQ(4, 6)
1588# pragma GCC diagnostic pop
1589#endif
1590 }
1591 }
1592 usbProxyLinuxUrbUnlinkInFlight(pDevLnx, pUrbLnx);
1593 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1594 }
1595 pUrb->Dev.pvPrivate = NULL;
1596
1597 /* some adjustments for message transfers. */
1598 if (pUrb->enmType == VUSBXFERTYPE_MSG)
1599 {
1600 pUrb->cbData += sizeof(VUSBSETUP);
1601 usbProxyLinuxUrbSwapSetup((PVUSBSETUP)pUrb->abData);
1602 }
1603 }
1604 else
1605 {
1606 usbProxyLinuxUrbUnlinkInFlight(pDevLnx, pUrbLnx);
1607 usbProxyLinuxUrbFree(pProxyDev, pUrbLnx);
1608 pUrb = NULL;
1609 }
1610
1611 LogFlow(("usbProxyLinuxUrbReap: pProxyDev=%s returns %p\n", usbProxyGetName(pProxyDev), pUrb));
1612 return pUrb;
1613}
1614
1615
1616/**
1617 * Cancels the URB.
1618 * The URB requires reaping, so we don't change its state.
1619 */
1620static DECLCALLBACK(int) usbProxyLinuxUrbCancel(PUSBPROXYDEV pProxyDev, PVUSBURB pUrb)
1621{
1622 int rc = VINF_SUCCESS;
1623 PUSBPROXYURBLNX pUrbLnx = (PUSBPROXYURBLNX)pUrb->Dev.pvPrivate;
1624 if (pUrbLnx->pSplitHead)
1625 {
1626 /* split */
1627 Assert(pUrbLnx == pUrbLnx->pSplitHead);
1628 PUSBPROXYURBLNX pCur;
1629 for (pCur = pUrbLnx; pCur; pCur = pCur->pSplitNext)
1630 {
1631 if (pCur->fSplitElementReaped)
1632 continue;
1633 if ( !usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pCur->KUrb, true, UINT32_MAX)
1634 || errno == ENOENT)
1635 continue;
1636 if (errno == ENODEV)
1637 break;
1638 /** @todo Think about how to handle errors wrt. to the status code. */
1639 Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!! (split)\n",
1640 pUrb, errno, usbProxyGetName(pProxyDev)));
1641 }
1642 }
1643 else
1644 {
1645 /* unsplit */
1646 if ( usbProxyLinuxDoIoCtl(pProxyDev, USBDEVFS_DISCARDURB, &pUrbLnx->KUrb, true, UINT32_MAX)
1647 && errno != ENODEV /* deal with elsewhere. */
1648 && errno != ENOENT)
1649 {
1650 Log(("usb-linux: Discard URB %p failed, errno=%d. pProxyDev=%s!!!\n",
1651 pUrb, errno, usbProxyGetName(pProxyDev)));
1652 rc = RTErrConvertFromErrno(errno);
1653 }
1654 }
1655
1656 return rc;
1657}
1658
1659
1660static DECLCALLBACK(int) usbProxyLinuxWakeup(PUSBPROXYDEV pProxyDev)
1661{
1662 PUSBPROXYDEVLNX pDevLnx = USBPROXYDEV_2_DATA(pProxyDev, PUSBPROXYDEVLNX);
1663 size_t cbIgnored;
1664
1665 LogFlowFunc(("pProxyDev=%p\n", pProxyDev));
1666
1667 return RTPipeWrite(pDevLnx->hPipeWakeupW, "", 1, &cbIgnored);
1668}
1669
1670/**
1671 * The Linux USB Proxy Backend.
1672 */
1673const USBPROXYBACK g_USBProxyDeviceHost =
1674{
1675 /* pszName */
1676 "host",
1677 /* cbBackend */
1678 sizeof(USBPROXYDEVLNX),
1679 usbProxyLinuxOpen,
1680 usbProxyLinuxInit,
1681 usbProxyLinuxClose,
1682 usbProxyLinuxReset,
1683 usbProxyLinuxSetConfig,
1684 usbProxyLinuxClaimInterface,
1685 usbProxyLinuxReleaseInterface,
1686 usbProxyLinuxSetInterface,
1687 usbProxyLinuxClearHaltedEp,
1688 usbProxyLinuxUrbQueue,
1689 usbProxyLinuxUrbCancel,
1690 usbProxyLinuxUrbReap,
1691 usbProxyLinuxWakeup,
1692 0
1693};
1694
1695
1696/*
1697 * Local Variables:
1698 * mode: c
1699 * c-file-style: "bsd"
1700 * c-basic-offset: 4
1701 * End:
1702 */
1703
Note: See TracBrowser for help on using the repository browser.

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