VUSBReadAhead.cpp@ 56292

Last change on this file since 56292 was 56292, checked in by vboxsync, 9 years ago
Devices: Updated (C) year.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 15.8 KB

Line
1	/* $Id: VUSBReadAhead.cpp 56292 2015-06-09 14:20:46Z vboxsync $ */
2	/** @file
3	* Virtual USB - Read-ahead buffering for periodic endpoints.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DRV_VUSB
23	#include <VBox/vmm/pdm.h>
24	#include <VBox/vmm/vmapi.h>
25	#include <VBox/err.h>
26	#include <VBox/log.h>
27	#include <iprt/alloc.h>
28	#include <iprt/time.h>
29	#include <iprt/thread.h>
30	#include <iprt/semaphore.h>
31	#include <iprt/string.h>
32	#include <iprt/assert.h>
33	#include <iprt/asm.h>
34	#include <iprt/critsect.h>
35	#include "VUSBInternal.h"
36
37
38	/*******************************************************************************
39	* Structures and Typedefs *
40	*******************************************************************************/
41
42	/**
43	* VUSB Readahead instance data.
44	*/
45	typedef struct VUSBREADAHEADINT
46	{
47	/** Pointer to the device which the thread is for. */
48	PVUSBDEV pDev;
49	/** Pointer to the pipe which the thread is servicing. */
50	PVUSBPIPE pPipe;
51	/** A flag indicating a high-speed (vs. low/full-speed) endpoint. */
52	bool fHighSpeed;
53	/** A flag telling the thread to terminate. */
54	volatile bool fTerminate;
55	/** Maximum number of URBs to submit. */
56	uint32_t cUrbsMax;
57	/** The periodic read-ahead buffer thread. */
58	RTTHREAD hReadAheadThread;
59	/** Pointer to the first buffered URB. */
60	PVUSBURB pBuffUrbHead;
61	/** Pointer to the last buffered URB. */
62	PVUSBURB pBuffUrbTail;
63	/** Count of URBs in read-ahead buffer. */
64	uint32_t cBuffered;
65	/** Count of URBs submitted for read-ahead but not yet reaped. */
66	uint32_t cSubmitted;
67	/** Critical section to serialize access the buffered URB list. */
68	RTCRITSECT CritSectBuffUrbList;
69	} VUSBREADAHEADINT, *PVUSBREADAHEADINT;
70
71
72	/*******************************************************************************
73	* Implementation *
74	*******************************************************************************/
75
76	static PVUSBURB vusbDevNewIsocUrb(PVUSBDEV pDev, unsigned uEndPt, unsigned uInterval, unsigned uPktSize)
77	{
78	PVUSBURB pUrb;
79	unsigned cPackets = 0;
80	uint32_t cbTotal = 0;
81	unsigned uNextIndex = 0;
82
83	Assert(pDev);
84	Assert(uEndPt);
85	Assert(uInterval);
86	Assert(uPktSize);
87
88	/* Calculate the amount of data needed, taking the endpoint's bInterval into account */
89	for (unsigned i = 0; i < 8; ++i)
90	{
91	if (i == uNextIndex)
92	{
93	cbTotal += uPktSize;
94	cPackets++;
95	uNextIndex += uInterval;
96	}
97	}
98	Assert(cbTotal <= 24576);
99
100	// @todo: What do we do if cPackets is 0?
101
102	/*
103	* Allocate and initialize the URB.
104	*/
105	Assert(pDev->u8Address != VUSB_INVALID_ADDRESS);
106
107	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
108	if (!pRh)
109	/* can happen during disconnect */
110	return NULL;
111
112	pUrb = vusbRhNewUrb(pRh, pDev->u8Address, cbTotal, 1);
113	if (!pUrb)
114	/* not much we can do here... */
115	return NULL;
116
117	pUrb->enmType = VUSBXFERTYPE_ISOC;
118	pUrb->EndPt = uEndPt;
119	pUrb->enmDir = VUSBDIRECTION_IN;
120	pUrb->fShortNotOk = false;
121	pUrb->enmStatus = VUSBSTATUS_OK;
122	pUrb->Hci.EdAddr = 0;
123	pUrb->Hci.fUnlinked = false;
124	// @todo: fill in the rest? The Hci member is not relevant
125	#ifdef LOG_ENABLED
126	static unsigned s_iSerial = 0;
127	s_iSerial = (s_iSerial + 1) % 10000;
128	RTStrAPrintf(&pUrb->pszDesc, "URB %p prab<%04d", pUrb, s_iSerial); // prab = Periodic Read-Ahead Buffer
129	#endif
130
131	/* Set up the individual packets, again with bInterval in mind */
132	pUrb->cIsocPkts = 8;
133	unsigned off = 0;
134	uNextIndex = 0;
135	for (unsigned i = 0; i < 8; i++)
136	{
137	pUrb->aIsocPkts[i].enmStatus = VUSBSTATUS_NOT_ACCESSED;
138	pUrb->aIsocPkts[i].off = off;
139	if (i == uNextIndex) // skip unused packets
140	{
141	pUrb->aIsocPkts[i].cb = uPktSize;
142	off += uPktSize;
143	uNextIndex += uInterval;
144	}
145	else
146	pUrb->aIsocPkts[i].cb = 0;
147	}
148	Assert(off == cbTotal);
149	return pUrb;
150	}
151
152	/**
153	* Thread function for performing read-ahead buffering of periodic input.
154	*
155	* This thread keeps a buffer (queue) filled with data read from a periodic
156	* input endpoint.
157	*
158	* The problem: In the EHCI emulation, there is a very short period between the
159	* time when the guest can schedule a request and the time when it expects the results.
160	* This leads to many dropped URBs because by the time we get the data from the host,
161	* the guest already gave up and moved on.
162	*
163	* The solution: For periodic transfers, we know the worst-case bandwidth. We can
164	* read ahead and buffer a few milliseconds worth of data. That way data is available
165	* by the time the guest asks for it and we can deliver it immediately.
166	*
167	* @returns success indicator.
168	* @param Thread This thread.
169	* @param pvUser Pointer to a VUSBREADAHEADARGS structure.
170	*/
171	static DECLCALLBACK(int) vusbDevReadAheadThread(RTTHREAD Thread, void *pvUser)
172	{
173	PVUSBREADAHEADINT pThis = (PVUSBREADAHEADINT)pvUser;
174	PVUSBPIPE pPipe;
175	PCVUSBDESCENDPOINT pDesc;
176	PVUSBURB pUrb;
177	int rc = VINF_SUCCESS;
178	unsigned max_pkt_size, mult, interval;
179
180	LogFlow(("vusb: periodic read-ahead buffer thread started\n"));
181	Assert(pThis);
182	Assert(pThis->pPipe && pThis->pDev);
183
184	pPipe = pThis->pPipe;
185	pDesc = &pPipe->in->Core;
186	Assert(pDesc);
187
188	Assert(!pThis->cSubmitted && !pThis->cBuffered);
189
190	/* Figure out the maximum bandwidth we might need */
191	if (pThis->fHighSpeed)
192	{
193	/* High-speed endpoint */
194	Assert((pDesc->wMaxPacketSize & 0x1fff) == pDesc->wMaxPacketSize);
195	Assert(pDesc->bInterval <= 16);
196	interval = pDesc->bInterval ? 1 << (pDesc->bInterval - 1) : 1;
197	max_pkt_size = pDesc->wMaxPacketSize & 0x7ff;
198	mult = ((pDesc->wMaxPacketSize & 0x1800) >> 11) + 1;
199	}
200	else
201	{
202	/* Full- or low-speed endpoint */
203	Assert((pDesc->wMaxPacketSize & 0x7ff) == pDesc->wMaxPacketSize);
204	interval = pDesc->bInterval;
205	max_pkt_size = pDesc->wMaxPacketSize;
206	mult = 1;
207	}
208	Log(("vusb: interval=%u, max pkt size=%u, multiplier=%u\n", interval, max_pkt_size, mult));
209
210	/*
211	* Submit new URBs in a loop unless the buffer is too full (paused VM etc.). Note that we only
212	* queue the URBs here, they are reaped on a different thread.
213	*/
214	while (!pThis->fTerminate)
215	{
216	while (pThis->cSubmitted < pThis->cUrbsMax && pThis->cBuffered < pThis->cUrbsMax)
217	{
218	pUrb = vusbDevNewIsocUrb(pThis->pDev, pDesc->bEndpointAddress & 0xF, interval, max_pkt_size * mult);
219	if (!pUrb) {
220	/* Happens if device was unplugged. */
221	Log(("vusb: read-ahead thread failed to allocate new URB; exiting\n"));
222	vusbReadAheadStop(pThis);
223	break;
224	}
225
226	Assert(pUrb->enmState == VUSBURBSTATE_ALLOCATED);
227
228	// @todo: at the moment we abuse the Hci.pNext member (which is otherwise entirely unused!)
229	pUrb->Hci.pNext = (PVUSBURB)pvUser;
230
231	pUrb->enmState = VUSBURBSTATE_IN_FLIGHT;
232	rc = vusbUrbQueueAsyncRh(pUrb);
233	if (RT_FAILURE(rc))
234	{
235	/* Happens if device was unplugged. */
236	Log(("vusb: read-ahead thread failed to queue URB with %Rrc; exiting\n", rc));
237	pThis->cUrbsMax = pThis->cSubmitted;
238	pUrb->VUsb.pfnFree(pUrb);
239	break;
240	}
241	else
242	ASMAtomicIncU32(&pThis->cSubmitted);
243	}
244	RTThreadSleep(1);
245	}
246	LogFlow(("vusb: periodic read-ahead buffer thread exiting\n"));
247
248	/* wait until there are no more submitted packets */
249	while (pThis->cSubmitted > 0)
250	{
251	Log2(("vusbDevReadAheadThread: still %u packets submitted, waiting before terminating...\n", pThis->cSubmitted));
252	RTThreadSleep(1);
253	}
254
255	RTCritSectEnter(&pThis->CritSectBuffUrbList);
256	/*
257	* Free all still buffered URBs because another endpoint with a different packet size
258	* and complete different data formats might be served later.
259	*/
260	while (pThis->pBuffUrbHead)
261	{
262	PVUSBURB pBufferedUrb = pThis->pBuffUrbHead;
263
264	pThis->pBuffUrbHead = pBufferedUrb->Hci.pNext;
265	pBufferedUrb->VUsb.pfnFree(pBufferedUrb);
266	}
267
268	RTCritSectLeave(&pThis->CritSectBuffUrbList);
269	RTCritSectDelete(&pThis->CritSectBuffUrbList);
270	RTMemTmpFree(pThis);
271
272	return rc;
273	}
274
275	/**
276	* Completes a read-ahead URB. This function does not free the URB but puts
277	* it on a queue instead. The URB is only freed when the guest asks for the data
278	* (by reading on the buffered pipe) or when the pipe/device is torn down.
279	*/
280	void vusbUrbCompletionReadAhead(PVUSBURB pUrb)
281	{
282	Assert(pUrb);
283	Assert(pUrb->Hci.pNext);
284	PVUSBREADAHEADINT pThis = (PVUSBREADAHEADINT)pUrb->Hci.pNext;
285	PVUSBPIPE pPipe = pThis->pPipe;
286	Assert(pPipe);
287
288	RTCritSectEnter(&pThis->CritSectBuffUrbList);
289	pUrb->Hci.pNext = NULL; // @todo: use a more suitable field
290	if (pThis->pBuffUrbHead == NULL)
291	{
292	// The queue is empty, this is easy
293	Assert(!pThis->pBuffUrbTail);
294	pThis->pBuffUrbTail = pThis->pBuffUrbHead = pUrb;
295	}
296	else
297	{
298	// Some URBs are queued already
299	Assert(pThis->pBuffUrbTail);
300	Assert(!pThis->pBuffUrbTail->Hci.pNext);
301	pThis->pBuffUrbTail = pThis->pBuffUrbTail->Hci.pNext = pUrb;
302	}
303	ASMAtomicDecU32(&pThis->cSubmitted);
304	++pThis->cBuffered;
305	RTCritSectLeave(&pThis->CritSectBuffUrbList);
306	}
307
308	/**
309	* Process a submit of an input URB on a pipe with read-ahead buffering. Instead
310	* of passing the URB to the proxy, we use previously read data stored in the
311	* read-ahead buffer, immediately complete the input URB and free the buffered URB.
312	*
313	* @param pUrb The URB submitted by HC
314	* @param hReadAhead The read-ahead buffering instance
315	*
316	* @return int Status code
317	*/
318	int vusbUrbSubmitBufferedRead(PVUSBURB pUrb, VUSBREADAHEAD hReadAhead)
319	{
320	PVUSBREADAHEADINT pThis = hReadAhead;
321	PVUSBURB pBufferedUrb;
322	Assert(pUrb && pThis);
323
324	RTCritSectEnter(&pThis->CritSectBuffUrbList);
325	pBufferedUrb = pThis->pBuffUrbHead;
326	if (pBufferedUrb)
327	{
328	unsigned cbTotal;
329
330	// There's a URB available in the read-ahead buffer; use it
331	pThis->pBuffUrbHead = pBufferedUrb->Hci.pNext;
332	if (pThis->pBuffUrbHead == NULL)
333	pThis->pBuffUrbTail = NULL;
334
335	--pThis->cBuffered;
336	RTCritSectLeave(&pThis->CritSectBuffUrbList);
337
338	// Make sure the buffered URB is what we expect
339	Assert(pUrb->enmType == pBufferedUrb->enmType);
340	Assert(pUrb->EndPt == pBufferedUrb->EndPt);
341	Assert(pUrb->enmDir == pBufferedUrb->enmDir);
342
343	pUrb->enmState = VUSBURBSTATE_REAPED;
344	pUrb->enmStatus = pBufferedUrb->enmStatus;
345	cbTotal = 0;
346	// Copy status and data received from the device
347	for (unsigned i = 0; i < pUrb->cIsocPkts; ++i)
348	{
349	unsigned off, len;
350
351	off = pBufferedUrb->aIsocPkts[i].off;
352	len = pBufferedUrb->aIsocPkts[i].cb;
353	pUrb->aIsocPkts[i].cb = len;
354	pUrb->aIsocPkts[i].off = off;
355	pUrb->aIsocPkts[i].enmStatus = pBufferedUrb->aIsocPkts[i].enmStatus;
356	cbTotal += len;
357	Assert(pUrb->VUsb.cbDataAllocated >= cbTotal);
358	memcpy(&pUrb->abData[off], &pBufferedUrb->abData[off], len);
359	}
360	// Give back the data to the HC right away and then free the buffered URB
361	vusbUrbCompletionRh(pUrb);
362	// This assertion is wrong as the URB could be re-allocated in the meantime by the EMT (race)
363	// Assert(pUrb->enmState == VUSBURBSTATE_FREE);
364	Assert(pBufferedUrb->enmState == VUSBURBSTATE_REAPED);
365	LogFlow(("%s: vusbUrbSubmitBufferedRead: Freeing buffered URB\n", pBufferedUrb->pszDesc));
366	pBufferedUrb->VUsb.pfnFree(pBufferedUrb);
367	// This assertion is wrong as the URB could be re-allocated in the meantime by the EMT (race)
368	// Assert(pBufferedUrb->enmState == VUSBURBSTATE_FREE);
369	}
370	else
371	{
372	RTCritSectLeave(&pThis->CritSectBuffUrbList);
373	// No URB on hand. Either we exhausted the buffer (shouldn't happen!) or the guest simply
374	// asked for data too soon. Pretend that the device didn't deliver any data.
375	pUrb->enmState = VUSBURBSTATE_REAPED;
376	pUrb->enmStatus = VUSBSTATUS_DATA_UNDERRUN;
377	for (unsigned i = 0; i < pUrb->cIsocPkts; ++i)
378	{
379	pUrb->aIsocPkts[i].cb = 0;
380	pUrb->aIsocPkts[i].enmStatus = VUSBSTATUS_NOT_ACCESSED;
381	}
382	vusbUrbCompletionRh(pUrb);
383	// This assertion is wrong as the URB could be re-allocated in the meantime by the EMT (race)
384	// Assert(pUrb->enmState == VUSBURBSTATE_FREE);
385	LogFlow(("vusbUrbSubmitBufferedRead: No buffered URB available!\n"));
386	}
387	return VINF_SUCCESS;
388	}
389
390	/* Read-ahead start/stop functions, used primarily to keep the PVUSBREADAHEADARGS struct private to this module. */
391
392	VUSBREADAHEAD vusbReadAheadStart(PVUSBDEV pDev, PVUSBPIPE pPipe)
393	{
394	int rc;
395	PVUSBREADAHEADINT pThis = (PVUSBREADAHEADINT)RTMemTmpAlloc(sizeof(VUSBREADAHEADINT));
396
397	if (pThis)
398	{
399	PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
400	pThis->pDev = pDev;
401	pThis->pPipe = pPipe;
402	pThis->fTerminate = false;
403	pThis->fHighSpeed = pRh && ((pRh->fHcVersions & VUSB_STDVER_20) != 0);
404	pThis->cUrbsMax = 120;
405	pThis->pBuffUrbHead = NULL;
406	pThis->pBuffUrbTail = NULL;
407	pThis->cBuffered = 0;
408	pThis->cSubmitted = 0;
409	rc = RTCritSectInit(&pThis->CritSectBuffUrbList);
410	if (RT_SUCCESS(rc))
411	{
412	if (pThis->fHighSpeed)
413	rc = RTThreadCreate(&pThis->hReadAheadThread, vusbDevReadAheadThread, pThis, 0, RTTHREADTYPE_IO, 0 /* fFlags */, "USBISOC");
414	else
415	rc = VERR_VUSB_DEVICE_NOT_ATTACHED; // No buffering for low/full-speed devices at the moment, needs testing.
416	if (RT_SUCCESS(rc))
417	{
418	Log(("vusb: created isochronous read-ahead thread\n"));
419	return pThis;
420	}
421	else
422	Log(("vusb: isochronous read-ahead thread creation failed, rc=%d\n", rc));
423
424	rc = RTCritSectDelete(&pThis->CritSectBuffUrbList);
425	AssertRC(rc);
426	}
427
428	RTMemTmpFree(pThis);
429	}
430
431	/* If thread creation failed for any reason, simply fall back to standard processing. */
432	return NULL;
433	}
434
435	void vusbReadAheadStop(VUSBREADAHEAD hReadAhead)
436	{
437	PVUSBREADAHEADINT pThis = hReadAhead;
438	Log(("vusb: terminating read-ahead thread for endpoint\n"));
439	ASMAtomicXchgBool(&pThis->fTerminate, true);
440	}
441
442	/*
443	* Local Variables:
444	* mode: c
445	* c-file-style: "bsd"
446	* c-basic-offset: 4
447	* tab-width: 4
448	* indent-tabs-mode: s
449	* End:
450	*/
451

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

source: vbox/trunk/src/VBox/Devices/USB/VUSBReadAhead.cpp@ 56292

Download in other formats: