UsbMsd.cpp@ 32484

Last change on this file since 32484 was 28800, checked in by vboxsync, 14 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.0 KB

Line
1	/* $Id: UsbMsd.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* UsbMSD - USB Mass Stoage Device Emulation.
4	*/
5
6	/*
7	* Copyright (C) 2007-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	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_USB_MSD
22	#include <VBox/pdmusb.h>
23	#include <VBox/log.h>
24	#include <VBox/err.h>
25	#include <VBox/scsi.h>
26	#include <iprt/assert.h>
27	#include <iprt/critsect.h>
28	#include <iprt/mem.h>
29	#include <iprt/semaphore.h>
30	#include <iprt/string.h>
31	#include <iprt/uuid.h>
32	#include "../Builtins.h"
33
34
35	/*******************************************************************************
36	* Defined Constants And Macros *
37	*******************************************************************************/
38	/** @name USB MSD string IDs
39	* @{ */
40	#define USBMSD_STR_ID_MANUFACTURER 1
41	#define USBMSD_STR_ID_PRODUCT 2
42	/** @} */
43
44
45	/*******************************************************************************
46	* Structures and Typedefs *
47	*******************************************************************************/
48	/**
49	* USB Command block wrapper (MSD/SCSI).
50	*/
51	#pragma pack(1)
52	typedef struct USBCBW
53	{
54	uint32_t dCBWSignature;
55	#define USBCBW_SIGNATURE UINT32_C(0x43425355)
56	uint32_t dCBWTag;
57	uint32_t dCBWDataTransferLength;
58	uint8_t bmCBWFlags;
59	#define USBCBW_DIR_MASK RT_BIT(7)
60	#define USBCBW_DIR_OUT 0
61	#define USBCBW_DIR_IN RT_BIT(7)
62	uint8_t bCBWLun;
63	uint8_t bCBWCBLength;
64	uint8_t CBWCB[16];
65	} USBCBW;
66	#pragma pack()
67	AssertCompileSize(USBCBW, 31);
68	/** Pointer to a Command Block Wrapper. */
69	typedef USBCBW *PUSBCBW;
70	/** Pointer to a const Command Block Wrapper. */
71	typedef const USBCBW *PCUSBCBW;
72
73	/**
74	* USB Command Status Wrapper (MSD/SCSI).
75	*/
76	#pragma pack(1)
77	typedef struct USBCSW
78	{
79	uint32_t dCSWSignature;
80	#define USBCSW_SIGNATURE UINT32_C(0x53425355)
81	uint32_t dCSWTag;
82	uint32_t dCSWDataResidue;
83	#define USBCSW_STATUS_OK UINT8_C(0)
84	#define USBCSW_STATUS_FAILED UINT8_C(1)
85	#define USBCSW_STATUS_PHASE_ERROR UINT8_C(2)
86	uint8_t bCSWStatus;
87	} USBCSW;
88	#pragma pack()
89	AssertCompileSize(USBCSW, 13);
90	/** Pointer to a Command Status Wrapper. */
91	typedef USBCSW *PUSBCSW;
92	/** Pointer to a const Command Status Wrapper. */
93	typedef const USBCSW *PCUSBCSW;
94
95
96	/**
97	* The USB MSD request state.
98	*/
99	typedef enum USBMSDREQSTATE
100	{
101	/** Invalid status. */
102	USBMSDREQSTATE_INVALID = 0,
103	/** Ready to receive a new SCSI command. */
104	USBMSDREQSTATE_READY,
105	/** Waiting for the host to supply data. */
106	USBMSDREQSTATE_DATA_FROM_HOST,
107	/** The SCSI request is being executed by the driver. */
108	USBMSDREQSTATE_EXECUTING,
109	/** Have (more) data for the host. */
110	USBMSDREQSTATE_DATA_TO_HOST,
111	/** Waiting to supply status information to the host. */
112	USBMSDREQSTATE_STATUS,
113	/** Destroy the request upon completion.
114	* This is set when the SCSI request doesn't complete before for the device or
115	* mass storage reset operation times out. USBMSD::pReq will be set to NULL
116	* and the only reference to this request will be with DrvSCSI. */
117	USBMSDREQSTATE_DESTROY_ON_COMPLETION,
118	/** The end of the valid states. */
119	USBMSDREQSTATE_END
120	} USBMSDREQSTATE;
121
122
123	/**
124	* A pending USB MSD request.
125	*/
126	typedef struct USBMSDREQ
127	{
128	/** The state of the request. */
129	USBMSDREQSTATE enmState;
130	/** The size of the data buffer. */
131	size_t cbBuf;
132	/** Pointer to the data buffer. */
133	uint8_t *pbBuf;
134	/** Current buffer offset. */
135	uint32_t offBuf;
136	/** The current Cbw when we're in the pending state. */
137	USBCBW Cbw;
138	/** The current SCSI request. */
139	PDMSCSIREQUEST ScsiReq;
140	/** The scatter-gather segment used by ScsiReq for describing pbBuf. */
141	RTSGSEG ScsiReqSeg;
142	/** The sense buffer for the current SCSI request. */
143	uint8_t ScsiReqSense[64];
144	/** The status of a completed SCSI request. */
145	int iScsiReqStatus;
146	/** Set if the request structure must be destroyed when the SCSI driver
147	* completes it. This is used to deal with requests that runs while the
148	* device is being reset. */
149	bool fDestoryOnCompletion;
150	/** Pointer to the USB device instance owning it. */
151	PPDMUSBINS pUsbIns;
152	} USBMSDREQ;
153	/** Pointer to a USB MSD request. */
154	typedef USBMSDREQ *PUSBMSDREQ;
155
156
157	/**
158	* Endpoint status data.
159	*/
160	typedef struct USBMSDEP
161	{
162	bool fHalted;
163	} USBMSDEP;
164	/** Pointer to the endpoint status. */
165	typedef USBMSDEP *PUSBMSDEP;
166
167
168	/**
169	* A URB queue.
170	*/
171	typedef struct USBMSDURBQUEUE
172	{
173	/** The head pointer. */
174	PVUSBURB pHead;
175	/** Where to insert the next entry. */
176	PVUSBURB *ppTail;
177	} USBMSDURBQUEUE;
178	/** Pointer to a URB queue. */
179	typedef USBMSDURBQUEUE *PUSBMSDURBQUEUE;
180	/** Pointer to a const URB queue. */
181	typedef USBMSDURBQUEUE const *PCUSBMSDURBQUEUE;
182
183
184	/**
185	* The USB MSD instance data.
186	*/
187	typedef struct USBMSD
188	{
189	/** Pointer back to the PDM USB Device instance structure. */
190	PPDMUSBINS pUsbIns;
191	/** Critical section protecting the device state. */
192	RTCRITSECT CritSect;
193
194	/** The current configuration.
195	* (0 - default, 1 - the only, i.e configured.) */
196	uint8_t bConfigurationValue;
197	#if 0
198	/** The state of the MSD (state machine).*/
199	USBMSDSTATE enmState;
200	#endif
201	/** Endpoint 0 is the default control pipe, 1 is the host->dev bulk pipe and 2
202	* is the dev->host one. */
203	USBMSDEP aEps[3];
204	/** The current request. */
205	PUSBMSDREQ pReq;
206
207	/** Pending to-host queue.
208	* The URBs waiting here are pending the completion of the current request and
209	* data or status to become available.
210	*/
211	USBMSDURBQUEUE ToHostQueue;
212
213	/** Done queue
214	* The URBs stashed here are waiting to be reaped. */
215	USBMSDURBQUEUE DoneQueue;
216	/** Signalled when adding an URB to the done queue and fHaveDoneQueueWaiter
217	* is set. */
218	RTSEMEVENT hEvtDoneQueue;
219	/** Someone is waiting on the done queue. */
220	bool fHaveDoneQueueWaiter;
221
222	/** Whether to signal the reset semaphore when the current request completes. */
223	bool fSignalResetSem;
224	/** Semaphore usbMsdUsbReset waits on when a request is executing at reset
225	* time. Only signalled when fSignalResetSem is set. */
226	RTSEMEVENTMULTI hEvtReset;
227	/** The reset URB.
228	* This is waiting for SCSI requestion completion before finishing the reset. */
229	PVUSBURB pResetUrb;
230
231	/**
232	* LUN\#0 data.
233	*/
234	struct
235	{
236	/** The base interface for LUN\#0. */
237	PDMIBASE IBase;
238	/** The SCSI port interface for LUN\#0 */
239	PDMISCSIPORT IScsiPort;
240
241	/** The base interface for the SCSI driver connected to LUN\#0. */
242	PPDMIBASE pIBase;
243	/** The SCSI connector interface for the SCSI driver connected to LUN\#0. */
244	PPDMISCSICONNECTOR pIScsiConnector;
245	} Lun0;
246
247	} USBMSD;
248	/** Pointer to the USB MSD instance data. */
249	typedef USBMSD *PUSBMSD;
250
251
252	/*******************************************************************************
253	* Global Variables *
254	*******************************************************************************/
255	static const PDMUSBDESCCACHESTRING g_aUsbMsdStrings_en_US[] =
256	{
257	{ USBMSD_STR_ID_MANUFACTURER, "VirtualBox" },
258	{ USBMSD_STR_ID_PRODUCT, "VirtualBox MSD" },
259	};
260
261	static const PDMUSBDESCCACHELANG g_aUsbMsdLanguages[] =
262	{
263	{ 0x0409, RT_ELEMENTS(g_aUsbMsdStrings_en_US), g_aUsbMsdStrings_en_US }
264	};
265
266	static const VUSBDESCENDPOINTEX g_aUsbMsdEndpointDescs[2] =
267	{
268	{
269	{
270	/* .bLength = */ sizeof(VUSBDESCENDPOINT),
271	/* .bDescriptorType = */ VUSB_DT_ENDPOINT,
272	/* .bEndpointAddress = / 0x81 / ep=1, in */,
273	/* .bmAttributes = / 2 / bulk */,
274	/* .wMaxPacketSize = / 0x200 / or 64? */,
275	/* .bInterval = */ 0xff,
276	},
277	/* .pvMore = */ NULL,
278	/* .pvClass = */ NULL,
279	/* .cbClass = */ 0
280	},
281	{
282	{
283	/* .bLength = */ sizeof(VUSBDESCENDPOINT),
284	/* .bDescriptorType = */ VUSB_DT_ENDPOINT,
285	/* .bEndpointAddress = / 0x02 / ep=2, out */,
286	/* .bmAttributes = / 2 / bulk */,
287	/* .wMaxPacketSize = / 0x200 / or 64? */,
288	/* .bInterval = */ 0xff,
289	},
290	/* .pvMore = */ NULL,
291	/* .pvClass = */ NULL,
292	/* .cbClass = */ 0
293	}
294	};
295
296	static const VUSBDESCINTERFACEEX g_UsbMsdInterfaceDesc =
297	{
298	{
299	/* .bLength = */ sizeof(VUSBDESCINTERFACE),
300	/* .bDescriptorType = */ VUSB_DT_INTERFACE,
301	/* .bInterfaceNumber = */ 0,
302	/* .bAlternateSetting = */ 0,
303	/* .bNumEndpoints = */ 2,
304	/* .bInterfaceClass = / 8 / Mass Storage */,
305	/* .bInterfaceSubClass = / 6 / SCSI transparent command set */,
306	/* .bInterfaceProtocol = / 0x50 / Bulk-Only Transport */,
307	/* .iInterface = */ 0
308	},
309	/* .pvMore = */ NULL,
310	/* .pvClass = */ NULL,
311	/* .cbClass = */ 0,
312	&g_aUsbMsdEndpointDescs[0]
313	};
314
315	static const VUSBINTERFACE g_aUsbMsdInterfaces[2] =
316	{
317	{ &g_UsbMsdInterfaceDesc, /* .cSettings = */ 1 },
318	};
319
320	static const VUSBDESCCONFIGEX g_UsbMsdConfigDesc =
321	{
322	{
323	/* .bLength = */ sizeof(VUSBDESCCONFIG),
324	/* .bDescriptorType = */ VUSB_DT_CONFIG,
325	/* .wTotalLength = / 0 / recalculated on read */,
326	/* .bNumInterfaces = */ RT_ELEMENTS(g_aUsbMsdInterfaces),
327	/* .bConfigurationValue =*/ 1,
328	/* .iConfiguration = */ 0,
329	/* .bmAttributes = */ RT_BIT(7),
330	/* .MaxPower = / 50 / 100mA */
331	},
332	NULL,
333	&g_aUsbMsdInterfaces[0]
334	};
335
336	static const VUSBDESCDEVICE g_UsbMsdDeviceDesc =
337	{
338	/* .bLength = */ sizeof(g_UsbMsdDeviceDesc),
339	/* .bDescriptorType = */ VUSB_DT_DEVICE,
340	/* .bcdUsb = */ 0x200,
341	/* .bDeviceClass = / 0 / Class specified in the interface desc. */,
342	/* .bDeviceSubClass = / 0 / Subclass specified in the interface desc. */,
343	/* .bDeviceProtocol = / 0x50 / Protocol specified in the interface desc. */,
344	/* .bMaxPacketSize0 = */ 64,
345	/* .idVendor = */ 0x4200,
346	/* .idProduct = */ 0x0042,
347	/* .bcdDevice = */ 0x0100,
348	/* .iManufacturer = */ USBMSD_STR_ID_MANUFACTURER,
349	/* .iProduct = */ USBMSD_STR_ID_PRODUCT,
350	/* .iSerialNumber = */ 0,
351	/* .bNumConfigurations = */ 1
352	};
353
354	static const PDMUSBDESCCACHE g_UsbMsdDescCache =
355	{
356	/* .pDevice = */ &g_UsbMsdDeviceDesc,
357	/* .paConfigs = */ &g_UsbMsdConfigDesc,
358	/* .paLanguages = */ g_aUsbMsdLanguages,
359	/* .cLanguages = */ RT_ELEMENTS(g_aUsbMsdLanguages),
360	/* .fUseCachedDescriptors = */ true,
361	/* .fUseCachedStringsDescriptors = */ true
362	};
363
364
365	/*******************************************************************************
366	* Internal Functions *
367	*******************************************************************************/
368	static int usbMsdHandleBulkDevToHost(PUSBMSD pThis, PUSBMSDEP pEp, PVUSBURB pUrb);
369
370
371	/**
372	* Initializes an URB queue.
373	*
374	* @param pQueue The URB queue.
375	*/
376	static void usbMsdQueueInit(PUSBMSDURBQUEUE pQueue)
377	{
378	pQueue->pHead = NULL;
379	pQueue->ppTail = &pQueue->pHead;
380	}
381
382
383
384	/**
385	* Inserts an URB at the end of the queue.
386	*
387	* @param pQueue The URB queue.
388	* @param pUrb The URB to insert.
389	*/
390	DECLINLINE(void) usbMsdQueueAddTail(PUSBMSDURBQUEUE pQueue, PVUSBURB pUrb)
391	{
392	pUrb->Dev.pNext = NULL;
393	*pQueue->ppTail = pUrb;
394	pQueue->ppTail = &pUrb->Dev.pNext;
395	}
396
397
398	/**
399	* Unlinks the head of the queue and returns it.
400	*
401	* @returns The head entry.
402	* @param pQueue The URB queue.
403	*/
404	DECLINLINE(PVUSBURB) usbMsdQueueRemoveHead(PUSBMSDURBQUEUE pQueue)
405	{
406	PVUSBURB pUrb = pQueue->pHead;
407	if (pUrb)
408	{
409	PVUSBURB pNext = pUrb->Dev.pNext;
410	pQueue->pHead = pNext;
411	if (!pNext)
412	pQueue->ppTail = &pQueue->pHead;
413	else
414	pUrb->Dev.pNext = NULL;
415	}
416	return pUrb;
417	}
418
419
420	/**
421	* Removes an URB from anywhere in the queue.
422	*
423	* @returns true if found, false if not.
424	* @param pQueue The URB queue.
425	* @param pUrb The URB to remove.
426	*/
427	DECLINLINE(bool) usbMsdQueueRemove(PUSBMSDURBQUEUE pQueue, PVUSBURB pUrb)
428	{
429	PVUSBURB pCur = pQueue->pHead;
430	if (pCur == pUrb)
431	pQueue->pHead = pUrb->Dev.pNext;
432	else
433	{
434	while (pCur)
435	{
436	if (pCur->Dev.pNext == pUrb)
437	{
438	pCur->Dev.pNext = pUrb->Dev.pNext;
439	break;
440	}
441	pCur = pCur->Dev.pNext;
442	}
443	if (!pCur)
444	return false;
445	}
446	if (!pUrb->Dev.pNext)
447	pQueue->ppTail = &pQueue->pHead;
448	return true;
449	}
450
451
452	/**
453	* Checks if the queue is empty or not.
454	*
455	* @returns true if it is, false if it isn't.
456	* @param pQueue The URB queue.
457	*/
458	DECLINLINE(bool) usbMsdQueueIsEmpty(PCUSBMSDURBQUEUE pQueue)
459	{
460	return pQueue->pHead == NULL;
461	}
462
463
464	/**
465	* Links an URB into the done queue.
466	*
467	* @param pThis The MSD instance.
468	* @param pUrb The URB.
469	*/
470	static void usbMsdLinkDone(PUSBMSD pThis, PVUSBURB pUrb)
471	{
472	usbMsdQueueAddTail(&pThis->DoneQueue, pUrb);
473
474	if (pThis->fHaveDoneQueueWaiter)
475	{
476	int rc = RTSemEventSignal(pThis->hEvtDoneQueue);
477	AssertRC(rc);
478	}
479	}
480
481
482
483
484	/**
485	* Allocates a new request and does basic init.
486	*
487	* @returns Pointer to the new request. NULL if we're out of memory.
488	* @param pUsbIns The instance allocating it.
489	*/
490	static PUSBMSDREQ usbMsdReqAlloc(PPDMUSBINS pUsbIns)
491	{
492	PUSBMSDREQ pReq = (PUSBMSDREQ)PDMUsbHlpMMHeapAllocZ(pUsbIns, sizeof(*pReq));
493	if (pReq)
494	{
495	pReq->enmState = USBMSDREQSTATE_READY;
496	pReq->iScsiReqStatus = -1;
497	pReq->pUsbIns = pUsbIns;
498	}
499	else
500	LogRel(("usbMsdReqAlloc: Out of memory\n"));
501	return pReq;
502	}
503
504
505	/**
506	* Frees a request.
507	*
508	* @param pReq The request.
509	*/
510	static void usbMsdReqFree(PUSBMSDREQ pReq)
511	{
512	/*
513	* Check the input.
514	*/
515	AssertReturnVoid( pReq->enmState > USBMSDREQSTATE_INVALID
516	&& pReq->enmState != USBMSDREQSTATE_EXECUTING
517	&& pReq->enmState < USBMSDREQSTATE_END);
518	PPDMUSBINS pUsbIns = pReq->pUsbIns;
519	AssertPtrReturnVoid(pUsbIns);
520	AssertReturnVoid(PDM_VERSION_ARE_COMPATIBLE(pUsbIns->u32Version, PDM_USBINS_VERSION));
521
522	/*
523	* Invalidate it and free the associated resources.
524	*/
525	pReq->enmState = USBMSDREQSTATE_INVALID;
526	pReq->cbBuf = 0;
527	pReq->offBuf = 0;
528	pReq->ScsiReq.pbCDB = NULL;
529	pReq->ScsiReq.paScatterGatherHead = NULL;
530	pReq->ScsiReq.pbSenseBuffer = NULL;
531	pReq->ScsiReq.pvUser = NULL;
532	pReq->ScsiReqSeg.cbSeg = 0;
533	pReq->ScsiReqSeg.pvSeg = NULL;
534
535	if (pReq->pbBuf)
536	{
537	PDMUsbHlpMMHeapFree(pUsbIns, pReq->pbBuf);
538	pReq->pbBuf = NULL;
539	}
540
541	PDMUsbHlpMMHeapFree(pUsbIns, pReq);
542	}
543
544
545	/**
546	* Prepares a request for execution or data buffering.
547	*
548	* @param pReq The request.
549	* @param pCbw The SCSI command block wrapper.
550	*/
551	static void usbMsdReqPrepare(PUSBMSDREQ pReq, PCUSBCBW pCbw)
552	{
553	/* Copy the CBW */
554	size_t cbCopy = RT_OFFSETOF(USBCBW, CBWCB[pCbw->bCBWCBLength]);
555	memcpy(&pReq->Cbw, pCbw, cbCopy);
556	memset((uint8_t *)&pReq->Cbw + cbCopy, 0, sizeof(pReq->Cbw) - cbCopy);
557
558	/* Setup the SCSI request. */
559	pReq->ScsiReq.uLogicalUnit = pReq->Cbw.bCBWLun;
560	pReq->ScsiReq.uDataDirection = (pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT
561	? PDMSCSIREQUESTTXDIR_TO_DEVICE
562	: PDMSCSIREQUESTTXDIR_FROM_DEVICE;
563	pReq->ScsiReq.cbCDB = pReq->Cbw.bCBWCBLength;
564
565	pReq->ScsiReq.pbCDB = &pReq->Cbw.CBWCB[0];
566	pReq->offBuf = 0;
567	pReq->ScsiReqSeg.pvSeg = pReq->pbBuf;
568	pReq->ScsiReqSeg.cbSeg = pReq->Cbw.dCBWDataTransferLength;
569	pReq->ScsiReq.cbScatterGather = pReq->Cbw.dCBWDataTransferLength;
570	pReq->ScsiReq.cScatterGatherEntries = 1;
571	pReq->ScsiReq.paScatterGatherHead = &pReq->ScsiReqSeg;
572	pReq->ScsiReq.cbSenseBuffer = sizeof(pReq->ScsiReqSense);
573	pReq->ScsiReq.pbSenseBuffer = &pReq->ScsiReqSense[0];
574	pReq->ScsiReq.pvUser = NULL;
575	RT_ZERO(pReq->ScsiReqSense);
576	pReq->iScsiReqStatus = -1;
577	}
578
579
580	/**
581	* Makes sure that there is sufficient buffer space available.
582	*
583	* @returns Success indicator (true/false)
584	* @param pReq
585	* @param cbBuf The required buffer space.
586	*/
587	static int usbMsdReqEnsureBuffer(PUSBMSDREQ pReq, size_t cbBuf)
588	{
589	if (RT_LIKELY(pReq->cbBuf >= cbBuf))
590	RT_BZERO(pReq->pbBuf, cbBuf);
591	else
592	{
593	PDMUsbHlpMMHeapFree(pReq->pUsbIns, pReq->pbBuf);
594	pReq->cbBuf = 0;
595
596	cbBuf = RT_ALIGN_Z(cbBuf, 0x1000);
597	pReq->pbBuf = (uint8_t *)PDMUsbHlpMMHeapAllocZ(pReq->pUsbIns, cbBuf);
598	if (!pReq->pbBuf)
599	return false;
600
601	pReq->cbBuf = cbBuf;
602	}
603	return true;
604	}
605
606
607	/**
608	* Completes the URB with a stalled state, halting the pipe.
609	*/
610	static int usbMsdCompleteStall(PUSBMSD pThis, PUSBMSDEP pEp, PVUSBURB pUrb, const char *pszWhy)
611	{
612	Log(("usbMsdCompleteStall/#%u: pUrb=%p:%s: %s\n", pThis->pUsbIns->iInstance, pUrb, pUrb->pszDesc, pszWhy));
613
614	pUrb->enmStatus = VUSBSTATUS_STALL;
615
616	/** @todo figure out if the stall is global or pipe-specific or both. */
617	if (pEp)
618	pEp->fHalted = true;
619	else
620	{
621	pThis->aEps[1].fHalted = true;
622	pThis->aEps[2].fHalted = true;
623	}
624
625	usbMsdLinkDone(pThis, pUrb);
626	return VINF_SUCCESS;
627	}
628
629
630	/**
631	* Completes the URB with a OK state.
632	*/
633	static int usbMsdCompleteOk(PUSBMSD pThis, PVUSBURB pUrb, size_t cbData)
634	{
635	Log(("usbMsdCompleteOk/#%u: pUrb=%p:%s cbData=%#zx\n", pThis->pUsbIns->iInstance, pUrb, pUrb->pszDesc, cbData));
636
637	pUrb->enmStatus = VUSBSTATUS_OK;
638	pUrb->cbData = cbData;
639
640	usbMsdLinkDone(pThis, pUrb);
641	return VINF_SUCCESS;
642	}
643
644
645	/**
646	* Reset worker for usbMsdUsbReset, usbMsdUsbSetConfiguration and
647	* usbMsdUrbHandleDefaultPipe.
648	*
649	* @returns VBox status code.
650	* @param pThis The MSD instance.
651	* @param pUrb Set when usbMsdUrbHandleDefaultPipe is the
652	* caller.
653	* @param fSetConfig Set when usbMsdUsbSetConfiguration is the
654	* caller.
655	*/
656	static int usbMsdResetWorker(PUSBMSD pThis, PVUSBURB pUrb, bool fSetConfig)
657	{
658	/*
659	* Wait for the any command currently executing to complete before
660	* resetting. (We cannot cancel its execution.) How we do this depends
661	* on the reset method.
662	*/
663	PUSBMSDREQ pReq = pThis->pReq;
664	if ( pReq
665	&& pReq->enmState == USBMSDREQSTATE_EXECUTING)
666	{
667	/* Don't try deal with the set config variant nor multiple build-only
668	mass storage resets. */
669	if (pThis->pResetUrb && (pUrb \|\| fSetConfig))
670	{
671	Log(("usbMsdResetWorker: pResetUrb is already %p:%s - stalling\n", pThis->pResetUrb, pThis->pResetUrb->pszDesc));
672	return usbMsdCompleteStall(pThis, NULL, pUrb, "pResetUrb");
673	}
674
675	/* Bulk-Only Mass Storage Reset: Complete the reset on request completion. */
676	if (pUrb)
677	{
678	pThis->pResetUrb = pUrb;
679	Log(("usbMsdResetWorker: Setting pResetUrb to %p:%s\n", pThis->pResetUrb, pThis->pResetUrb->pszDesc));
680	return VINF_SUCCESS;
681	}
682
683	/* Device reset: Wait for up to 10 ms. If it doesn't work, ditch
684	whoe the request structure. We'll allocate a new one when needed. */
685	Log(("usbMsdResetWorker: Waiting for completion...\n"));
686	Assert(!pThis->fSignalResetSem);
687	pThis->fSignalResetSem = true;
688	RTSemEventMultiReset(pThis->hEvtReset);
689	RTCritSectLeave(&pThis->CritSect);
690
691	int rc = RTSemEventMultiWait(pThis->hEvtReset, 10 /ms/);
692
693	RTCritSectEnter(&pThis->CritSect);
694	pThis->fSignalResetSem = false;
695	if ( RT_FAILURE(rc)
696	\|\| pReq->enmState == USBMSDREQSTATE_EXECUTING)
697	{
698	Log(("usbMsdResetWorker: Didn't complete, ditching the current request (%p)!\n", pReq));
699	Assert(pReq == pThis->pReq);
700	pReq->enmState = USBMSDREQSTATE_DESTROY_ON_COMPLETION;
701	pThis->pReq = NULL;
702	pReq = NULL;
703	}
704	}
705
706	/*
707	* Reset the request and device state.
708	*/
709	if (pReq)
710	{
711	pReq->enmState = USBMSDREQSTATE_READY;
712	pReq->iScsiReqStatus = -1;
713	}
714
715	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aEps); i++)
716	pThis->aEps[i].fHalted = false;
717
718	if (!pUrb && !fSetConfig) /* (only device reset) */
719	pThis->bConfigurationValue = 0; /* default */
720
721	/*
722	* Ditch all pending URBs.
723	*/
724	PVUSBURB pCurUrb;
725	while ((pCurUrb = usbMsdQueueRemoveHead(&pThis->ToHostQueue)) != NULL)
726	{
727	pCurUrb->enmStatus = VUSBSTATUS_CRC;
728	usbMsdLinkDone(pThis, pCurUrb);
729	}
730
731	pCurUrb = pThis->pResetUrb;
732	if (pCurUrb)
733	{
734	pThis->pResetUrb = NULL;
735	pCurUrb->enmStatus = VUSBSTATUS_CRC;
736	usbMsdLinkDone(pThis, pCurUrb);
737	}
738
739	if (pUrb)
740	return usbMsdCompleteOk(pThis, pUrb, 0);
741	return VINF_SUCCESS;
742	}
743
744
745	/**
746	* @interface_method_impl{PDMISCSIPORT,pfnSCSIRequestCompleted}
747	*/
748	static DECLCALLBACK(int) usbMsdLun0ScsiRequestCompleted(PPDMISCSIPORT pInterface, PPDMSCSIREQUEST pSCSIRequest, int rcCompletion)
749	{
750	PUSBMSD pThis = RT_FROM_MEMBER(pInterface, USBMSD, Lun0.IScsiPort);
751	PUSBMSDREQ pReq = RT_FROM_MEMBER(pSCSIRequest, USBMSDREQ, ScsiReq);
752
753	Log(("usbMsdLun0ScsiRequestCompleted: pReq=%p dCBWTag=%#x iScsiReqStatus=%u \n", pReq, pReq->Cbw.dCBWTag, rcCompletion));
754	RTCritSectEnter(&pThis->CritSect);
755
756	if (pReq->enmState != USBMSDREQSTATE_DESTROY_ON_COMPLETION)
757	{
758	Assert(pReq->enmState == USBMSDREQSTATE_EXECUTING);
759	Assert(pThis->pReq == pReq);
760	pReq->iScsiReqStatus = rcCompletion;
761
762	/*
763	* Advance the state machine. The state machine is not affected by
764	* SCSI errors.
765	*/
766	if ((pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT)
767	{
768	pReq->enmState = USBMSDREQSTATE_STATUS;
769	Log(("usbMsdLun0ScsiRequestCompleted: Entering STATUS\n"));
770	}
771	else
772	{
773	pReq->enmState = USBMSDREQSTATE_DATA_TO_HOST;
774	Log(("usbMsdLun0ScsiRequestCompleted: Entering DATA_TO_HOST\n"));
775	}
776
777	/*
778	* Deal with pending to-host URBs.
779	*/
780	for (;;)
781	{
782	PVUSBURB pUrb = usbMsdQueueRemoveHead(&pThis->ToHostQueue);
783	if (!pUrb)
784	break;
785
786	/* Process it as the normal way. */
787	usbMsdHandleBulkDevToHost(pThis, &pThis->aEps[1], pUrb);
788	}
789	}
790	else
791	{
792	Log(("usbMsdLun0ScsiRequestCompleted: freeing %p\n", pReq));
793	usbMsdReqFree(pReq);
794	}
795
796	if (pThis->fSignalResetSem)
797	RTSemEventMultiSignal(pThis->hEvtReset);
798
799	if (pThis->pResetUrb)
800	{
801	pThis->pResetUrb = NULL;
802	usbMsdResetWorker(pThis, pThis->pResetUrb, false /fSetConfig/);
803	}
804
805	RTCritSectLeave(&pThis->CritSect);
806	return VINF_SUCCESS;
807	}
808
809
810	/**
811	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
812	*/
813	static DECLCALLBACK(void ) usbMsdLun0QueryInterface(PPDMIBASE pInterface, const char pszIID)
814	{
815	PUSBMSD pThis = RT_FROM_MEMBER(pInterface, USBMSD, Lun0.IBase);
816	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->Lun0.IBase);
817	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISCSIPORT, &pThis->Lun0.IScsiPort);
818	return NULL;
819	}
820
821
822	/**
823	* @copydoc PDMUSBREG::pfnUrbReap
824	*/
825	static DECLCALLBACK(PVUSBURB) usbMsdUrbReap(PPDMUSBINS pUsbIns, RTMSINTERVAL cMillies)
826	{
827	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
828	LogFlow(("usbMsdUrbReap/#%u: cMillies=%u\n", pUsbIns->iInstance, cMillies));
829
830	RTCritSectEnter(&pThis->CritSect);
831
832	PVUSBURB pUrb = usbMsdQueueRemoveHead(&pThis->DoneQueue);
833	if (!pUrb && cMillies)
834	{
835	/* Wait */
836	pThis->fHaveDoneQueueWaiter = true;
837	RTCritSectLeave(&pThis->CritSect);
838
839	RTSemEventWait(pThis->hEvtDoneQueue, cMillies);
840
841	RTCritSectEnter(&pThis->CritSect);
842	pThis->fHaveDoneQueueWaiter = false;
843
844	pUrb = usbMsdQueueRemoveHead(&pThis->DoneQueue);
845	}
846
847	RTCritSectLeave(&pThis->CritSect);
848
849	if (pUrb)
850	Log(("usbMsdUrbReap/#%u: pUrb=%p:%s\n", pUsbIns->iInstance, pUrb, pUrb->pszDesc));
851	return pUrb;
852	}
853
854
855	/**
856	* @copydoc PDMUSBREG::pfnUrbCancel
857	*/
858	static DECLCALLBACK(int) usbMsdUrbCancel(PPDMUSBINS pUsbIns, PVUSBURB pUrb)
859	{
860	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
861	LogFlow(("usbMsdUrbCancel/#%u: pUrb=%p:%s\n", pUsbIns->iInstance, pUrb, pUrb->pszDesc));
862	RTCritSectEnter(&pThis->CritSect);
863
864	/*
865	* Remove the URB from the to-host queue and move it onto the done queue.
866	*/
867	if (usbMsdQueueRemove(&pThis->ToHostQueue, pUrb))
868	usbMsdLinkDone(pThis, pUrb);
869
870	RTCritSectLeave(&pThis->CritSect);
871	return VINF_SUCCESS;
872	}
873
874
875	/**
876	* Fails an illegal SCSI request.
877	*
878	* @returns VBox status code.
879	* @param pThis The MSD instance data.
880	* @param pReq The MSD request.
881	* @param bAsc The ASC for the SCSI_SENSE_ILLEGAL_REQUEST.
882	* @param bAscq The ASC qualifier.
883	* @param pszWhy For logging why.
884	*/
885	static int usbMsdScsiIllegalRequest(PUSBMSD pThis, PUSBMSDREQ pReq, uint8_t bAsc, uint8_t bAscq, const char *pszWhy)
886	{
887	Log(("usbMsdScsiIllegalRequest: bAsc=%#x bAscq=%#x %s\n", bAsc, bAscq, pszWhy));
888
889	RT_ZERO(pReq->ScsiReqSense);
890	pReq->ScsiReqSense[0] = 0x80 \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
891	pReq->ScsiReqSense[2] = SCSI_SENSE_ILLEGAL_REQUEST;
892	pReq->ScsiReqSense[7] = 10;
893	pReq->ScsiReqSense[12] = SCSI_ASC_INVALID_MESSAGE;
894	pReq->ScsiReqSense[13] = 0; /* Should be ASCQ but it has the same value for success. */
895
896	usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_CHECK_CONDITION);
897	return VINF_SUCCESS;
898	}
899
900
901	/**
902	* The SCSI driver doesn't handle SCSI_REQUEST_SENSE but instead
903	* returns the sense info with the request.
904	*
905	*/
906	static int usbMsdHandleScsiReqestSense(PUSBMSD pThis, PUSBMSDREQ pReq, PCUSBCBW pCbw)
907	{
908	Log(("usbMsdHandleScsiReqestSense: Entering EXECUTING (dCBWTag=%#x).\n", pReq->Cbw.dCBWTag));
909	Assert(pReq == pThis->pReq);
910	pReq->enmState = USBMSDREQSTATE_EXECUTING;
911
912	/* validation */
913	if ((pCbw->bmCBWFlags & USBCBW_DIR_MASK) != USBCBW_DIR_IN)
914	return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "direction");
915	if (pCbw->bCBWCBLength != 6)
916	return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "length");
917	if ((pCbw->CBWCB[1] >> 5) != pCbw->bCBWLun)
918	return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0, "lun");
919	if (pCbw->bCBWLun != 0)
920	return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INVALID_MESSAGE, 0, "lun0");
921	if ((pCbw->CBWCB[4] < 6) != pCbw->bCBWLun)
922	return usbMsdScsiIllegalRequest(pThis, pReq, SCSI_ASC_INV_FIELD_IN_CMD_PACKET, 0, "out length");
923
924	/* If the previous command succeeded successfully, whip up some sense data. */
925	if ( pReq->iScsiReqStatus == SCSI_STATUS_OK
926	&& pReq->ScsiReqSense[0] == 0)
927	{
928	RT_ZERO(pReq->ScsiReqSense);
929	#if 0 /** @todo something upsets linux about this stuff. Needs investigation. */
930	pReq->ScsiReqSense[0] = 0x80 \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
931	pReq->ScsiReqSense[0] = SCSI_SENSE_RESPONSE_CODE_CURR_FIXED;
932	pReq->ScsiReqSense[2] = SCSI_SENSE_NONE;
933	pReq->ScsiReqSense[7] = 10;
934	pReq->ScsiReqSense[12] = SCSI_ASC_NONE;
935	pReq->ScsiReqSense[13] = SCSI_ASC_NONE; /* Should be ASCQ but it has the same value for success. */
936	#endif
937	}
938
939	/* Copy the data into the result buffer. */
940	size_t cbCopy = RT_MIN(pCbw->dCBWDataTransferLength, sizeof(pReq->ScsiReqSense));
941	Log(("usbMsd: SCSI_REQUEST_SENSE - CBWCB[4]=%#x iOldState=%d, %u bytes, raw: %.*Rhxs\n",
942	pCbw->CBWCB[4], pReq->iScsiReqStatus, pCbw->dCBWDataTransferLength, RT_MAX(1, cbCopy), pReq->ScsiReqSense));
943	memcpy(pReq->pbBuf, &pReq->ScsiReqSense[0], cbCopy);
944
945	usbMsdReqPrepare(pReq, pCbw);
946
947	/* Do normal completion. */
948	usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_OK);
949	return VINF_SUCCESS;
950	}
951
952
953	/**
954	* Wrapper around PDMISCSICONNECTOR::pfnSCSIRequestSend that deals with
955	* SCSI_REQUEST_SENSE.
956	*
957	* @returns VBox status code.
958	* @param pThis The MSD instance data.
959	* @param pReq The MSD request.
960	* @param pszCaller Where we're called from.
961	*/
962	static int usbMsdSubmitScsiCommand(PUSBMSD pThis, PUSBMSDREQ pReq, const char *pszCaller)
963	{
964	Log(("%s: Entering EXECUTING (dCBWTag=%#x).\n", pszCaller, pReq->Cbw.dCBWTag));
965	Assert(pReq == pThis->pReq);
966	pReq->enmState = USBMSDREQSTATE_EXECUTING;
967
968	switch (pReq->ScsiReq.pbCDB[0])
969	{
970	case SCSI_REQUEST_SENSE:
971	{
972	}
973
974	default:
975	return pThis->Lun0.pIScsiConnector->pfnSCSIRequestSend(pThis->Lun0.pIScsiConnector, &pReq->ScsiReq);
976	}
977	}
978
979	/**
980	* Validates a SCSI request before passing it down to the SCSI driver.
981	*
982	* @returns true / false. The request will be completed on failure.
983	* @param pThis The MSD instance data.
984	* @param pCbw The USB command block wrapper.
985	* @param pUrb The URB.
986	*/
987	static bool usbMsdIsValidCommand(PUSBMSD pThis, PCUSBCBW pCbw, PVUSBURB pUrb)
988	{
989	switch (pCbw->CBWCB[0])
990	{
991	case SCSI_REQUEST_SENSE:
992	/** @todo validate this. */
993	return true;
994
995	default:
996	return true;
997	}
998	}
999
1000
1001	/**
1002	* Handles request sent to the out-bound (to device) bulk pipe.
1003	*/
1004	static int usbMsdHandleBulkHostToDev(PUSBMSD pThis, PUSBMSDEP pEp, PVUSBURB pUrb)
1005	{
1006	/*
1007	* Stall the request if the pipe is halted.
1008	*/
1009	if (RT_UNLIKELY(pEp->fHalted))
1010	return usbMsdCompleteStall(pThis, NULL, pUrb, "Halted pipe");
1011
1012	/*
1013	* Deal with the URB according to the current state.
1014	*/
1015	PUSBMSDREQ pReq = pThis->pReq;
1016	USBMSDREQSTATE enmState = pReq ? pReq->enmState : USBMSDREQSTATE_READY;
1017	switch (enmState)
1018	{
1019	case USBMSDREQSTATE_STATUS:
1020	LogFlow(("usbMsdHandleBulkHostToDev: Skipping pending status.\n"));
1021	pReq->enmState = USBMSDREQSTATE_READY;
1022	/* fall thru */
1023
1024	/*
1025	* We're ready to receive a command. Start off by validating the
1026	* incoming request.
1027	*/
1028	case USBMSDREQSTATE_READY:
1029	{
1030	PCUSBCBW pCbw = (PUSBCBW)&pUrb->abData[0];
1031	if (pUrb->cbData < RT_UOFFSETOF(USBCBW, CBWCB[1]))
1032	{
1033	Log(("usbMsd: Bad CBW: cbData=%#x < min=%#x\n", pUrb->cbData, RT_UOFFSETOF(USBCBW, CBWCB[1]) ));
1034	return usbMsdCompleteStall(pThis, NULL, pUrb, "BAD CBW");
1035	}
1036	Log(("usbMsd: CBW: dCBWSignature=%#x dCBWTag=%#x dCBWDataTransferLength=%#x bmCBWFlags=%#x bCBWLun=%#x bCBWCBLength=%#x cbData=%#x fShortNotOk=%RTbool\n",
1037	pCbw->dCBWSignature, pCbw->dCBWTag, pCbw->dCBWDataTransferLength, pCbw->bmCBWFlags, pCbw->bCBWLun, pCbw->bCBWCBLength, pUrb->cbData, pUrb->fShortNotOk));
1038	if (pCbw->dCBWSignature != USBCBW_SIGNATURE)
1039	{
1040	Log(("usbMsd: CBW: Invalid dCBWSignature value: %#x\n", pCbw->dCBWSignature));
1041	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad CBW");
1042	}
1043	if (pCbw->bmCBWFlags & ~USBCBW_DIR_MASK)
1044	{
1045	Log(("usbMsd: CBW: Bad bmCBWFlags value: %#x\n", pCbw->bmCBWFlags));
1046	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad CBW");
1047
1048	}
1049	if (pCbw->bCBWLun != 0)
1050	{
1051	Log(("usbMsd: CBW: Bad bCBWLun value: %#x\n", pCbw->bCBWLun));
1052	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad CBW");
1053	}
1054	if (pCbw->bCBWCBLength == 0)
1055	{
1056	Log(("usbMsd: CBW: Bad bCBWCBLength value: %#x\n", pCbw->bCBWCBLength));
1057	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad CBW");
1058	}
1059	if (pUrb->cbData < RT_UOFFSETOF(USBCBW, CBWCB[pCbw->bCBWCBLength]))
1060	{
1061	Log(("usbMsd: CBW: Mismatching cbData and bCBWCBLength values: %#x vs. %#x (%#x)\n",
1062	pUrb->cbData, RT_UOFFSETOF(USBCBW, CBWCB[pCbw->bCBWCBLength]), pCbw->bCBWCBLength));
1063	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad CBW");
1064	}
1065	if (pCbw->dCBWDataTransferLength > _1M)
1066	{
1067	Log(("usbMsd: CBW: dCBWDataTransferLength is too large: %#x (%u)\n",
1068	pCbw->dCBWDataTransferLength, pCbw->dCBWDataTransferLength));
1069	return usbMsdCompleteStall(pThis, NULL, pUrb, "Too big transfer");
1070	}
1071
1072	if (!usbMsdIsValidCommand(pThis, pCbw, pUrb))
1073	return VINF_SUCCESS;
1074
1075	/*
1076	* Make sure we've got a request and a sufficent buffer space.
1077	*
1078	* Note! This will make sure the buffer is ZERO as well, thus
1079	* saving us the trouble of clearing the output buffer on
1080	* failure later.
1081	*/
1082	if (!pReq)
1083	{
1084	pReq = usbMsdReqAlloc(pThis->pUsbIns);
1085	if (!pReq)
1086	return usbMsdCompleteStall(pThis, NULL, pUrb, "Request allocation failure");
1087	pThis->pReq = pReq;
1088	}
1089	if (!usbMsdReqEnsureBuffer(pReq, pCbw->dCBWDataTransferLength))
1090	return usbMsdCompleteStall(pThis, NULL, pUrb, "Buffer allocation failure");
1091
1092	/*
1093	* Special case REQUEST SENSE requests, usbMsdReqPrepare will
1094	* trash the sense data otherwise.
1095	*/
1096	if (pCbw->CBWCB[0] == SCSI_REQUEST_SENSE)
1097	usbMsdHandleScsiReqestSense(pThis, pReq, pCbw);
1098	else
1099	{
1100	/*
1101	* Prepare the request. Kick it off right away if possible.
1102	*/
1103	usbMsdReqPrepare(pReq, pCbw);
1104
1105	if ( pReq->Cbw.dCBWDataTransferLength == 0
1106	\|\| (pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_IN)
1107	{
1108	int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkHostToDev");
1109	if (RT_FAILURE(rc))
1110	{
1111	Log(("usbMsd: Failed sending SCSI request to driver: %Rrc\n", rc));
1112	return usbMsdCompleteStall(pThis, NULL, pUrb, "SCSI Submit #1");
1113	}
1114	}
1115	else
1116	{
1117	Log(("usbMsdHandleBulkHostToDev: Entering DATA_FROM_HOST.\n"));
1118	pReq->enmState = USBMSDREQSTATE_DATA_FROM_HOST;
1119	}
1120	}
1121
1122	return usbMsdCompleteOk(pThis, pUrb, 0);
1123	}
1124
1125	/*
1126	* Stuff the data into the buffer.
1127	*/
1128	case USBMSDREQSTATE_DATA_FROM_HOST:
1129	{
1130	uint32_t cbData = pUrb->cbData;
1131	uint32_t cbLeft = pReq->Cbw.dCBWDataTransferLength - pReq->offBuf;
1132	if (cbData > cbLeft)
1133	{
1134	Log(("usbMsd: Too much data: cbData=%#x offBuf=%#x dCBWDataTransferLength=%#x cbLeft=%#x\n",
1135	cbData, pReq->offBuf, pReq->Cbw.dCBWDataTransferLength, cbLeft));
1136	return usbMsdCompleteStall(pThis, NULL, pUrb, "Too much data");
1137	}
1138	memcpy(&pReq->pbBuf[pReq->offBuf], &pUrb->abData[0], cbData);
1139	pReq->offBuf += cbData;
1140
1141	if (pReq->offBuf == pReq->Cbw.dCBWDataTransferLength)
1142	{
1143	int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkHostToDev");
1144	if (RT_FAILURE(rc))
1145	{
1146	Log(("usbMsd: Failed sending SCSI request to driver: %Rrc\n", rc));
1147	return usbMsdCompleteStall(pThis, NULL, pUrb, "SCSI Submit #2");
1148	}
1149	}
1150	return usbMsdCompleteOk(pThis, pUrb, 0);
1151	}
1152
1153	/*
1154	* Bad state, stall.
1155	*/
1156	case USBMSDREQSTATE_DATA_TO_HOST:
1157	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad state H2D: DATA_TO_HOST");
1158
1159	case USBMSDREQSTATE_EXECUTING:
1160	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad state H2D: EXECUTING");
1161
1162	default:
1163	AssertMsgFailed(("enmState=%d\n", enmState));
1164	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad state (H2D)");
1165	}
1166	}
1167
1168
1169	/**
1170	* Handles request sent to the in-bound (to host) bulk pipe.
1171	*/
1172	static int usbMsdHandleBulkDevToHost(PUSBMSD pThis, PUSBMSDEP pEp, PVUSBURB pUrb)
1173	{
1174	/*
1175	* Stall the request if the pipe is halted OR if there is no
1176	* pending request yet.
1177	*/
1178	PUSBMSDREQ pReq = pThis->pReq;
1179	if (RT_UNLIKELY(pEp->fHalted \|\| !pReq))
1180	return usbMsdCompleteStall(pThis, NULL, pUrb, pEp->fHalted ? "Halted pipe" : "No request");
1181
1182	/*
1183	* Deal with the URB according to the state.
1184	*/
1185	switch (pReq->enmState)
1186	{
1187	/*
1188	* We've data left to transfer to the host.
1189	*/
1190	case USBMSDREQSTATE_DATA_TO_HOST:
1191	{
1192	uint32_t cbData = pUrb->cbData;
1193	uint32_t cbCopy = pReq->Cbw.dCBWDataTransferLength - pReq->offBuf;
1194	if (cbData <= cbCopy)
1195	cbCopy = cbData;
1196	else if (pUrb->fShortNotOk)
1197	{
1198	Log(("usbMsd: Requested more data that we've got; cbData=%#x offBuf=%#x dCBWDataTransferLength=%#x cbLeft=%#x\n",
1199	cbData, pReq->offBuf, pReq->Cbw.dCBWDataTransferLength, cbCopy));
1200	return usbMsdCompleteStall(pThis, NULL, pUrb, "Data underrun");
1201	}
1202	memcpy(&pUrb->abData[0], &pReq->pbBuf[pReq->offBuf], cbCopy);
1203	pReq->offBuf += cbCopy;
1204
1205	if (pReq->offBuf == pReq->Cbw.dCBWDataTransferLength)
1206	{
1207	Log(("usbMsdHandleBulkDevToHost: Entering STATUS\n"));
1208	pReq->enmState = USBMSDREQSTATE_STATUS;
1209	}
1210	return usbMsdCompleteOk(pThis, pUrb, cbCopy);
1211	}
1212
1213	/*
1214	* Status transfer.
1215	*/
1216	case USBMSDREQSTATE_STATUS:
1217	{
1218	/** @todo !fShortNotOk and CSW request? */
1219	if (pUrb->cbData != sizeof(USBCSW))
1220	{
1221	Log(("usbMsd: Unexpected status request size: %#x (expected %#x)\n", pUrb->cbData, sizeof(USBCSW)));
1222	return usbMsdCompleteStall(pThis, NULL, pUrb, "Invalid CSW size");
1223	}
1224
1225	/* Enter a CSW into the URB data buffer. */
1226	PUSBCSW pCsw = (PUSBCSW)&pUrb->abData[0];
1227	pCsw->dCSWSignature = USBCSW_SIGNATURE;
1228	pCsw->dCSWTag = pReq->Cbw.dCBWTag;
1229	pCsw->bCSWStatus = pReq->iScsiReqStatus == SCSI_STATUS_OK
1230	? USBCSW_STATUS_OK
1231	: pReq->iScsiReqStatus >= 0
1232	? USBCSW_STATUS_FAILED
1233	: USBCSW_STATUS_PHASE_ERROR;
1234	if ((pReq->Cbw.bmCBWFlags & USBCBW_DIR_MASK) == USBCBW_DIR_OUT)
1235	pCsw->dCSWDataResidue = pCsw->bCSWStatus == USBCSW_STATUS_OK
1236	? pReq->Cbw.dCBWDataTransferLength - pReq->ScsiReq.cbScatterGather
1237	: pReq->Cbw.dCBWDataTransferLength;
1238	else
1239	pCsw->dCSWDataResidue = pCsw->bCSWStatus == USBCSW_STATUS_OK
1240	? pReq->ScsiReq.cbScatterGather
1241	: 0;
1242	Log(("usbMsdHandleBulkDevToHost: CSW: dCSWTag=%#x bCSWStatus=%d dCSWDataResidue=%#x\n",
1243	pCsw->dCSWTag, pCsw->bCSWStatus, pCsw->dCSWDataResidue));
1244
1245	Log(("usbMsdHandleBulkDevToHost: Entering READY\n"));
1246	pReq->enmState = USBMSDREQSTATE_READY;
1247	return usbMsdCompleteOk(pThis, pUrb, sizeof(*pCsw));
1248	}
1249
1250	/*
1251	* Status request before we've received all (or even any) data.
1252	* Linux 2.4.31 does this sometimes. The recommended behavior is to
1253	* to accept the current data amount and execute the request. (The
1254	* alternative behavior is to stall.)
1255	*/
1256	case USBMSDREQSTATE_DATA_FROM_HOST:
1257	{
1258	if (pUrb->cbData != sizeof(USBCSW))
1259	{
1260	Log(("usbMsdHandleBulkDevToHost: DATA_FROM_HOST; cbData=%#x -> stall\n", pUrb->cbData));
1261	return usbMsdCompleteStall(pThis, NULL, pUrb, "Invalid CSW size");
1262	}
1263
1264	/* Adjust the request and kick it off. Special case the no-data
1265	case since the SCSI driver doesn't like that. */
1266	pReq->ScsiReq.cbScatterGather = pReq->offBuf;
1267	pReq->ScsiReqSeg.cbSeg = pReq->offBuf;
1268	if (!pReq->offBuf)
1269	{
1270	Log(("usbMsdHandleBulkDevToHost: Entering EXECUTING (offBuf=0x0).\n"));
1271	pReq->enmState = USBMSDREQSTATE_EXECUTING;
1272
1273	usbMsdQueueAddTail(&pThis->ToHostQueue, pUrb);
1274	LogFlow(("usbMsdHandleBulkDevToHost: Added %p:%s to the to-host queue\n", pUrb, pUrb->pszDesc));
1275
1276	usbMsdLun0ScsiRequestCompleted(&pThis->Lun0.IScsiPort, &pReq->ScsiReq, SCSI_STATUS_OK);
1277	return VINF_SUCCESS;
1278	}
1279
1280	int rc = usbMsdSubmitScsiCommand(pThis, pReq, "usbMsdHandleBulkDevToHost");
1281	if (RT_FAILURE(rc))
1282	{
1283	Log(("usbMsd: Failed sending SCSI request to driver: %Rrc\n", rc));
1284	return usbMsdCompleteStall(pThis, NULL, pUrb, "SCSI Submit #3");
1285	}
1286
1287	/* fall thru */
1288	}
1289
1290	/*
1291	* The SCSI command is still pending, queue the URB awaiting its
1292	* completion.
1293	*/
1294	case USBMSDREQSTATE_EXECUTING:
1295	usbMsdQueueAddTail(&pThis->ToHostQueue, pUrb);
1296	LogFlow(("usbMsdHandleBulkDevToHost: Added %p:%s to the to-host queue\n", pUrb, pUrb->pszDesc));
1297	return VINF_SUCCESS;
1298
1299	/*
1300	* Bad states, stall.
1301	*/
1302	case USBMSDREQSTATE_READY:
1303	Log(("usbMsdHandleBulkDevToHost: enmState=READ (cbData=%#x)\n", pReq->enmState, pUrb->cbData));
1304	return usbMsdCompleteStall(pThis, NULL, pUrb, "Bad state D2H: READY");
1305
1306	default:
1307	Log(("usbMsdHandleBulkDevToHost: enmState=%d cbData=%#x\n", pReq->enmState, pUrb->cbData));
1308	return usbMsdCompleteStall(pThis, NULL, pUrb, "Really bad state (D2H)!");
1309	}
1310	}
1311
1312
1313	/**
1314	* Handles request send to the default control pipe.
1315	*/
1316	static int usbMsdHandleDefaultPipe(PUSBMSD pThis, PUSBMSDEP pEp, PVUSBURB pUrb)
1317	{
1318	PVUSBSETUP pSetup = (PVUSBSETUP)&pUrb->abData[0];
1319	AssertReturn(pUrb->cbData >= sizeof(*pSetup), VERR_VUSB_FAILED_TO_QUEUE_URB);
1320
1321	if ((pSetup->bmRequestType & VUSB_REQ_MASK) == VUSB_REQ_STANDARD)
1322	{
1323	switch (pSetup->bRequest)
1324	{
1325	case VUSB_REQ_GET_DESCRIPTOR:
1326	{
1327	if (pSetup->bmRequestType != (VUSB_TO_DEVICE \| VUSB_REQ_STANDARD \| VUSB_DIR_TO_HOST))
1328	{
1329	Log(("usbMsd: Bad GET_DESCRIPTOR req: bmRequestType=%#x\n", pSetup->bmRequestType));
1330	return usbMsdCompleteStall(pThis, pEp, pUrb, "Bad GET_DESCRIPTOR");
1331	}
1332
1333	switch (pSetup->wValue >> 8)
1334	{
1335	case VUSB_DT_STRING:
1336	Log(("usbMsd: GET_DESCRIPTOR DT_STRING wValue=%#x wIndex=%#x\n", pSetup->wValue, pSetup->wIndex));
1337	break;
1338	default:
1339	Log(("usbMsd: GET_DESCRIPTOR, huh? wValue=%#x wIndex=%#x\n", pSetup->wValue, pSetup->wIndex));
1340	break;
1341	}
1342	break;
1343	}
1344
1345	case VUSB_REQ_CLEAR_FEATURE:
1346	break;
1347	}
1348
1349	/** @todo implement this. */
1350	Log(("usbMsd: Implement standard request: bmRequestType=%#x bRequest=%#x wValue=%#x wIndex=%#x wLength=%#x\n",
1351	pSetup->bmRequestType, pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
1352
1353	usbMsdCompleteStall(pThis, pEp, pUrb, "TODO: standard request stuff");
1354	}
1355	/* 3.1 Bulk-Only Mass Storage Reset */
1356	else if ( pSetup->bmRequestType == (VUSB_REQ_CLASS \| VUSB_TO_INTERFACE)
1357	&& pSetup->bRequest == 0xff
1358	&& !pSetup->wValue
1359	&& !pSetup->wLength
1360	&& pSetup->wIndex == 0)
1361	{
1362	Log(("usbMsdHandleDefaultPipe: Bulk-Only Mass Storage Reset\n"));
1363	return usbMsdResetWorker(pThis, pUrb, false /fSetConfig/);
1364	}
1365	/* 3.2 Get Max LUN, may stall if we like (but we don't). */
1366	else if ( pSetup->bmRequestType == (VUSB_REQ_CLASS \| VUSB_TO_INTERFACE \| VUSB_DIR_TO_HOST)
1367	&& pSetup->bRequest == 0xfe
1368	&& !pSetup->wValue
1369	&& pSetup->wLength == 1
1370	&& pSetup->wIndex == 0)
1371	{
1372	(uint8_t )(pSetup + 1) = 0; /* max lun is 0 */
1373	usbMsdCompleteOk(pThis, pUrb, 1);
1374	}
1375	else
1376	{
1377	Log(("usbMsd: Unknown control msg: bmRequestType=%#x bRequest=%#x wValue=%#x wIndex=%#x wLength=%#x\n",
1378	pSetup->bmRequestType, pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
1379	return usbMsdCompleteStall(pThis, pEp, pUrb, "Unknown control msg");
1380	}
1381
1382	return VINF_SUCCESS;
1383	}
1384
1385
1386	/**
1387	* @copydoc PDMUSBREG::pfnQueue
1388	*/
1389	static DECLCALLBACK(int) usbMsdQueue(PPDMUSBINS pUsbIns, PVUSBURB pUrb)
1390	{
1391	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1392	LogFlow(("usbMsdQueue/#%u: pUrb=%p:%s EndPt=%#x\n", pUsbIns->iInstance, pUrb, pUrb->pszDesc, pUrb->EndPt));
1393	RTCritSectEnter(&pThis->CritSect);
1394
1395	/*
1396	* Parse on a per end-point basis.
1397	*/
1398	int rc;
1399	switch (pUrb->EndPt)
1400	{
1401	case 0:
1402	rc = usbMsdHandleDefaultPipe(pThis, &pThis->aEps[0], pUrb);
1403	break;
1404
1405	case 0x81:
1406	AssertFailed();
1407	case 0x01:
1408	rc = usbMsdHandleBulkDevToHost(pThis, &pThis->aEps[1], pUrb);
1409	break;
1410
1411	case 0x02:
1412	rc = usbMsdHandleBulkHostToDev(pThis, &pThis->aEps[2], pUrb);
1413	break;
1414
1415	default:
1416	AssertMsgFailed(("EndPt=%d\n", pUrb->EndPt));
1417	rc = VERR_VUSB_FAILED_TO_QUEUE_URB;
1418	break;
1419	}
1420
1421	RTCritSectLeave(&pThis->CritSect);
1422	return rc;
1423	}
1424
1425
1426	/**
1427	* @copydoc PDMUSBREG::pfnUsbClearHaltedEndpoint
1428	*/
1429	static DECLCALLBACK(int) usbMsdUsbClearHaltedEndpoint(PPDMUSBINS pUsbIns, unsigned uEndpoint)
1430	{
1431	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1432	LogFlow(("usbMsdUsbClearHaltedEndpoint/#%u: uEndpoint=%#x\n", pUsbIns->iInstance, uEndpoint));
1433
1434	if ((uEndpoint & ~0x80) < RT_ELEMENTS(pThis->aEps))
1435	{
1436	RTCritSectEnter(&pThis->CritSect);
1437	pThis->aEps[(uEndpoint & ~0x80)].fHalted = false;
1438	RTCritSectLeave(&pThis->CritSect);
1439	}
1440
1441	return VINF_SUCCESS;
1442	}
1443
1444
1445	/**
1446	* @copydoc PDMUSBREG::pfnUsbSetInterface
1447	*/
1448	static DECLCALLBACK(int) usbMsdUsbSetInterface(PPDMUSBINS pUsbIns, uint8_t bInterfaceNumber, uint8_t bAlternateSetting)
1449	{
1450	LogFlow(("usbMsdUsbSetInterface/#%u: bInterfaceNumber=%u bAlternateSetting=%u\n", pUsbIns->iInstance, bInterfaceNumber, bAlternateSetting));
1451	Assert(bAlternateSetting == 0);
1452	return VINF_SUCCESS;
1453	}
1454
1455
1456	/**
1457	* @copydoc PDMUSBREG::pfnUsbSetConfiguration
1458	*/
1459	static DECLCALLBACK(int) usbMsdUsbSetConfiguration(PPDMUSBINS pUsbIns, uint8_t bConfigurationValue,
1460	const void pvOldCfgDesc, const void pvOldIfState, const void *pvNewCfgDesc)
1461	{
1462	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1463	LogFlow(("usbMsdUsbSetConfiguration/#%u: bConfigurationValue=%u\n", pUsbIns->iInstance, bConfigurationValue));
1464	Assert(bConfigurationValue == 1);
1465	RTCritSectEnter(&pThis->CritSect);
1466
1467	/*
1468	* If the same config is applied more than once, it's a kind of reset.
1469	*/
1470	if (pThis->bConfigurationValue == bConfigurationValue)
1471	usbMsdResetWorker(pThis, NULL, true /fSetConfig/); /** @todo figure out the exact difference */
1472	pThis->bConfigurationValue = bConfigurationValue;
1473
1474	RTCritSectLeave(&pThis->CritSect);
1475	return VINF_SUCCESS;
1476	}
1477
1478
1479	/**
1480	* @copydoc PDMUSBREG::pfnUsbGetDescriptorCache
1481	*/
1482	static DECLCALLBACK(PCPDMUSBDESCCACHE) usbMsdUsbGetDescriptorCache(PPDMUSBINS pUsbIns)
1483	{
1484	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1485	LogFlow(("usbMsdUsbGetDescriptorCache/#%u:\n", pUsbIns->iInstance));
1486	return &g_UsbMsdDescCache;
1487	}
1488
1489
1490	/**
1491	* @copydoc PDMUSBREG::pfnUsbReset
1492	*/
1493	static DECLCALLBACK(int) usbMsdUsbReset(PPDMUSBINS pUsbIns, bool fResetOnLinux)
1494	{
1495	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1496	LogFlow(("usbMsdUsbReset/#%u:\n", pUsbIns->iInstance));
1497	RTCritSectEnter(&pThis->CritSect);
1498
1499	int rc = usbMsdResetWorker(pThis, NULL, false /fSetConfig/);
1500
1501	RTCritSectLeave(&pThis->CritSect);
1502	return rc;
1503	}
1504
1505
1506	/**
1507	* @copydoc PDMUSBREG::pfnDestruct
1508	*/
1509	static void usbMsdDestruct(PPDMUSBINS pUsbIns)
1510	{
1511	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1512	LogFlow(("usbMsdDestruct/#%u:\n", pUsbIns->iInstance));
1513
1514	if (RTCritSectIsInitialized(&pThis->CritSect))
1515	{
1516	RTCritSectEnter(&pThis->CritSect);
1517	RTCritSectLeave(&pThis->CritSect);
1518	RTCritSectDelete(&pThis->CritSect);
1519	}
1520
1521	if (pThis->pReq)
1522	{
1523	usbMsdReqFree(pThis->pReq);
1524	pThis->pReq = NULL;
1525	}
1526
1527	if (pThis->hEvtDoneQueue != NIL_RTSEMEVENT)
1528	{
1529	RTSemEventDestroy(pThis->hEvtDoneQueue);
1530	pThis->hEvtDoneQueue = NIL_RTSEMEVENT;
1531	}
1532
1533	if (pThis->hEvtReset != NIL_RTSEMEVENTMULTI)
1534	{
1535	RTSemEventMultiDestroy(pThis->hEvtReset);
1536	pThis->hEvtReset = NIL_RTSEMEVENTMULTI;
1537	}
1538	}
1539
1540
1541	/**
1542	* @copydoc PDMUSBREG::pfnConstruct
1543	*/
1544	static DECLCALLBACK(int) usbMsdConstruct(PPDMUSBINS pUsbIns, int iInstance, PCFGMNODE pCfg, PCFGMNODE pCfgGlobal)
1545	{
1546	PUSBMSD pThis = PDMINS_2_DATA(pUsbIns, PUSBMSD);
1547	Log(("usbMsdConstruct/#%u:\n", iInstance));
1548
1549	/*
1550	* Perform the basic structure initialization first so the destructor
1551	* will not misbehave.
1552	*/
1553	pThis->pUsbIns = pUsbIns;
1554	pThis->hEvtDoneQueue = NIL_RTSEMEVENT;
1555	pThis->hEvtReset = NIL_RTSEMEVENTMULTI;
1556	pThis->Lun0.IBase.pfnQueryInterface = usbMsdLun0QueryInterface;
1557	pThis->Lun0.IScsiPort.pfnSCSIRequestCompleted = usbMsdLun0ScsiRequestCompleted;
1558	usbMsdQueueInit(&pThis->ToHostQueue);
1559	usbMsdQueueInit(&pThis->DoneQueue);
1560
1561	int rc = RTCritSectInit(&pThis->CritSect);
1562	AssertRCReturn(rc, rc);
1563
1564	rc = RTSemEventCreate(&pThis->hEvtDoneQueue);
1565	AssertRCReturn(rc, rc);
1566
1567	rc = RTSemEventMultiCreate(&pThis->hEvtReset);
1568	AssertRCReturn(rc, rc);
1569
1570	/*
1571	* Validate and read the configuration.
1572	*/
1573	rc = CFGMR3ValidateConfig(pCfg, "/", "", "", "UsbMsd", iInstance);
1574	if (RT_FAILURE(rc))
1575	return rc;
1576
1577	/*
1578	* Attach the SCSI driver.
1579	*/
1580	rc = pUsbIns->pHlpR3->pfnDriverAttach(pUsbIns, 0 /iLun/, &pThis->Lun0.IBase, &pThis->Lun0.pIBase, "SCSI Port");
1581	if (RT_FAILURE(rc))
1582	return PDMUsbHlpVMSetError(pUsbIns, rc, RT_SRC_POS, N_("MSD failed to attach SCSI driver"));
1583	pThis->Lun0.pIScsiConnector = PDMIBASE_QUERY_INTERFACE(pThis->Lun0.pIBase, PDMISCSICONNECTOR);
1584	if (!pThis->Lun0.pIScsiConnector)
1585	return PDMUsbHlpVMSetError(pUsbIns, VERR_PDM_MISSING_INTERFACE_BELOW, RT_SRC_POS,
1586	N_("MSD failed to query the PDMISCSICONNECTOR from the driver below it"));
1587
1588	return VINF_SUCCESS;
1589	}
1590
1591
1592	/**
1593	* The USB Mass Storage Device (MSD) registration record.
1594	*/
1595	const PDMUSBREG g_UsbMsd =
1596	{
1597	/* u32Version */
1598	PDM_USBREG_VERSION,
1599	/* szName */
1600	"Msd",
1601	/* pszDescription */
1602	"USB Mass Storage Device, one LUN.",
1603	/* fFlags */
1604	0,
1605	/* cMaxInstances */
1606	~0,
1607	/* cbInstance */
1608	sizeof(USBMSD),
1609	/* pfnConstruct */
1610	usbMsdConstruct,
1611	/* pfnDestruct */
1612	usbMsdDestruct,
1613	/* pfnVMInitComplete */
1614	NULL,
1615	/* pfnVMPowerOn */
1616	NULL,
1617	/* pfnVMReset */
1618	NULL,
1619	/* pfnVMSuspend */
1620	NULL,
1621	/* pfnVMResume */
1622	NULL,
1623	/* pfnVMPowerOff */
1624	NULL,
1625	/* pfnHotPlugged */
1626	NULL,
1627	/* pfnHotUnplugged */
1628	NULL,
1629	/* pfnDriverAttach */
1630	NULL,
1631	/* pfnDriverDetach */
1632	NULL,
1633	/* pfnQueryInterface */
1634	NULL,
1635	/* pfnUsbReset */
1636	usbMsdUsbReset,
1637	/* pfnUsbGetCachedDescriptors */
1638	usbMsdUsbGetDescriptorCache,
1639	/* pfnUsbSetConfiguration */
1640	usbMsdUsbSetConfiguration,
1641	/* pfnUsbSetInterface */
1642	usbMsdUsbSetInterface,
1643	/* pfnUsbClearHaltedEndpoint */
1644	usbMsdUsbClearHaltedEndpoint,
1645	/* pfnUrbNew */
1646	NULL/usbMsdUrbNew/,
1647	/* pfnQueue */
1648	usbMsdQueue,
1649	/* pfnUrbCancel */
1650	usbMsdUrbCancel,
1651	/* pfnUrbReap */
1652	usbMsdUrbReap,
1653	/* u32TheEnd */
1654	PDM_USBREG_VERSION
1655	};
1656

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

source: vbox/trunk/src/VBox/Devices/Storage/UsbMsd.cpp@ 32484

Download in other formats: