USBProxyDevice-linux.cpp@ 37596

Last change on this file since 37596 was 37596, checked in by vboxsync, 13 years ago
*: RTFILE becomes a pointer, RTFileOpen++ expands it's flags paramter from uint32_t to uint64_t.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.0 KB

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

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

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

Download in other formats: