USBProxyDevice-linux.cpp@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 20 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.2 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: