VirtualBox

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

Last change on this file since 54785 was 52254, checked in by vboxsync, 10 years ago

Devices/USB: Several fixes and misc cleanups, the VM crash when detaching a USB device while transfering data should be fixed, likewise several assertions in debug builds should be fixed now. Removed a bit dead code in the linux backend (timeout handling which wasn't active)

  • 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 52254 2014-08-02 15:34:53Z vboxsync $ */
2/** @file
3 * Virtual USB - Read-ahead buffering for periodic endpoints.
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/*******************************************************************************
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 */
45typedef 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
76static 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 */
171static 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 */
280void 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 */
318int 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
392VUSBREADAHEAD 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
435void 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.

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