DrvSCSI.cpp@ 64150

Last change on this file since 64150 was 64150, checked in by vboxsync, 9 years ago
DrvSCSI: Forward a few selected methods from the exposed media interface down to the underlying driver, required for the BIOS code to determine the geometry
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.5 KB

Line
1	/* $Id: DrvSCSI.cpp 64150 2016-10-05 09:26:33Z vboxsync $ */
2	/** @file
3	* VBox storage drivers: Generic SCSI command parser and execution driver
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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 DEBUG
23	#define LOG_GROUP LOG_GROUP_DRV_SCSI
24	#include <VBox/vmm/pdmdrv.h>
25	#include <VBox/vmm/pdmifs.h>
26	#include <VBox/vmm/pdmqueue.h>
27	#include <VBox/vmm/pdmstorageifs.h>
28	#include <VBox/vmm/pdmthread.h>
29	#include <VBox/vscsi.h>
30	#include <VBox/scsi.h>
31	#include <iprt/asm.h>
32	#include <iprt/assert.h>
33	#include <iprt/mem.h>
34	#include <iprt/req.h>
35	#include <iprt/semaphore.h>
36	#include <iprt/string.h>
37	#include <iprt/uuid.h>
38
39	#include "VBoxDD.h"
40
41	/** The maximum number of release log entries per device. */
42	#define MAX_LOG_REL_ERRORS 1024
43
44	/**
45	* Eject state.
46	*/
47	typedef struct DRVSCSIEJECTSTATE
48	{
49	/** The item core for the PDM queue. */
50	PDMQUEUEITEMCORE Core;
51	/** Event semaphore to signal when complete. */
52	RTSEMEVENT hSemEvt;
53	} DRVSCSIEJECTSTATE;
54	typedef DRVSCSIEJECTSTATE *PDRVSCSIEJECTSTATE;
55
56	/**
57	* SCSI driver private per request data.
58	*/
59	typedef struct DRVSCSIREQ
60	{
61	/** Size of the guest buffer. */
62	size_t cbBuf;
63	/** Temporary buffer holding the data. */
64	void *pvBuf;
65	/** Data segment. */
66	RTSGSEG Seg;
67	/** Transfer direction. */
68	PDMMEDIAEXIOREQSCSITXDIR enmXferDir;
69	/** The VSCSI request handle. */
70	VSCSIREQ hVScsiReq;
71	/** Where to store the SCSI status code. */
72	uint8_t *pu8ScsiSts;
73	/** Start of the request data for the device above us. */
74	uint8_t abAlloc[1];
75	} DRVSCSIREQ;
76	/** Pointer to the driver private per request data. */
77	typedef DRVSCSIREQ *PDRVSCSIREQ;
78
79	/**
80	* SCSI driver instance data.
81	*
82	* @implements PDMISCSICONNECTOR
83	* @implements PDMIMEDIAEXPORT
84	* @implements PDMIMEDIAEX
85	* @implements PDMIMOUNTNOTIFY
86	*/
87	typedef struct DRVSCSI
88	{
89	/** Pointer driver instance. */
90	PPDMDRVINS pDrvIns;
91
92	/** Pointer to the attached driver's base interface. */
93	PPDMIBASE pDrvBase;
94	/** Pointer to the attached driver's block interface. */
95	PPDMIMEDIA pDrvMedia;
96	/** Pointer to the attached driver's extended media interface. */
97	PPDMIMEDIAEX pDrvMediaEx;
98	/** Pointer to the attached driver's mount interface. */
99	PPDMIMOUNT pDrvMount;
100	/** Pointer to the SCSI port interface of the device above. */
101	PPDMISCSIPORT pDevScsiPort;
102	/** Pointer to the extended media port interface of the device above. */
103	PPDMIMEDIAEXPORT pDevMediaExPort;
104	/** Pointer to the media port interface of the device above. */
105	PPDMIMEDIAPORT pDevMediaPort;
106	/** pointer to the Led port interface of the dveice above. */
107	PPDMILEDPORTS pLedPort;
108	/** The scsi connector interface .*/
109	PDMISCSICONNECTOR ISCSIConnector;
110	/** The media interface for the device above. */
111	PDMIMEDIA IMedia;
112	/** The extended media interface for the device above. */
113	PDMIMEDIAEX IMediaEx;
114	/** The media port interface. */
115	PDMIMEDIAPORT IPort;
116	/** The optional extended media port interface. */
117	PDMIMEDIAEXPORT IPortEx;
118	/** The mount notify interface. */
119	PDMIMOUNTNOTIFY IMountNotify;
120	/** Fallback status LED state for this drive.
121	* This is used in case the device doesn't has a LED interface. */
122	PDMLED Led;
123	/** Pointer to the status LED for this drive. */
124	PPDMLED pLed;
125
126	/** VSCSI device handle. */
127	VSCSIDEVICE hVScsiDevice;
128	/** VSCSI LUN handle. */
129	VSCSILUN hVScsiLun;
130	/** I/O callbacks. */
131	VSCSILUNIOCALLBACKS VScsiIoCallbacks;
132
133	/** Indicates whether PDMDrvHlpAsyncNotificationCompleted should be called by
134	* any of the dummy functions. */
135	bool volatile fDummySignal;
136	/** Release statistics: number of bytes written. */
137	STAMCOUNTER StatBytesWritten;
138	/** Release statistics: number of bytes read. */
139	STAMCOUNTER StatBytesRead;
140	/** Release statistics: Current I/O depth. */
141	volatile uint32_t StatIoDepth;
142	/** Errors printed in the release log. */
143	unsigned cErrors;
144
145	/** Size of the I/O request to allocate. */
146	size_t cbIoReqAlloc;
147	/** Size of a VSCSI I/O request. */
148	size_t cbVScsiIoReqAlloc;
149	/** Queue to defer unmounting to EMT. */
150	PPDMQUEUE pQueue;
151	} DRVSCSI, *PDRVSCSI;
152
153	/** Convert a VSCSI I/O request handle to the associated PDMIMEDIAEX I/O request. */
154	#define DRVSCSI_VSCSIIOREQ_2_PDMMEDIAEXIOREQ(a_hVScsiIoReq) ((PPDMMEDIAEXIOREQ)((uint8_t )(a_hVScsiIoReq) - sizeof(PDMMEDIAEXIOREQ)))
155	/** Convert a PDMIMEDIAEX I/O additional request memory to a VSCSI I/O request. */
156	#define DRVSCSI_PDMMEDIAEXIOREQ_2_VSCSIIOREQ(a_pvIoReqAlloc) ((VSCSIIOREQ)((uint8_t *)(a_pvIoReqAlloc) + sizeof(PDMMEDIAEXIOREQ)))
157
158	/**
159	* Returns whether the given status code indicates a non fatal error.
160	*
161	* @returns True if the error can be fixed by the user after the VM was suspended.
162	* False if not and the error should be reported to the guest.
163	* @param rc The status code to check.
164	*/
165	DECLINLINE(bool) drvscsiIsRedoPossible(int rc)
166	{
167	if ( rc == VERR_DISK_FULL
168	\|\| rc == VERR_FILE_TOO_BIG
169	\|\| rc == VERR_BROKEN_PIPE
170	\|\| rc == VERR_NET_CONNECTION_REFUSED
171	\|\| rc == VERR_VD_DEK_MISSING)
172	return true;
173
174	return false;
175	}
176
177	/* -=-=-=-=- VScsiIoCallbacks -=-=-=-=- */
178
179	/**
180	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunReqAllocSizeSet}
181	*/
182	static DECLCALLBACK(int) drvscsiReqAllocSizeSet(VSCSILUN hVScsiLun, void *pvScsiLunUser, size_t cbVScsiIoReqAlloc)
183	{
184	RT_NOREF(hVScsiLun);
185	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
186
187	/* We need to store the I/O request handle so we can get it when VSCSI queues an I/O request. */
188	int rc = pThis->pDrvMediaEx->pfnIoReqAllocSizeSet(pThis->pDrvMediaEx, cbVScsiIoReqAlloc + sizeof(PDMMEDIAEXIOREQ));
189	if (RT_SUCCESS(rc))
190	pThis->cbVScsiIoReqAlloc = cbVScsiIoReqAlloc + sizeof(PDMMEDIAEXIOREQ);
191
192	return rc;
193	}
194
195	/**
196	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunReqAlloc}
197	*/
198	static DECLCALLBACK(int) drvscsiReqAlloc(VSCSILUN hVScsiLun, void *pvScsiLunUser,
199	uint64_t u64Tag, PVSCSIIOREQ phVScsiIoReq)
200	{
201	RT_NOREF(hVScsiLun);
202	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
203	PDMMEDIAEXIOREQ hIoReq;
204	void *pvIoReqAlloc;
205	int rc = pThis->pDrvMediaEx->pfnIoReqAlloc(pThis->pDrvMediaEx, &hIoReq, &pvIoReqAlloc, u64Tag,
206	PDMIMEDIAEX_F_DEFAULT);
207	if (RT_SUCCESS(rc))
208	{
209	PPDMMEDIAEXIOREQ phIoReq = (PPDMMEDIAEXIOREQ)pvIoReqAlloc;
210
211	*phIoReq = hIoReq;
212	*phVScsiIoReq = (VSCSIIOREQ)(phIoReq + 1);
213	}
214
215	return rc;
216	}
217
218	/**
219	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunReqFree}
220	*/
221	static DECLCALLBACK(int) drvscsiReqFree(VSCSILUN hVScsiLun, void *pvScsiLunUser, VSCSIIOREQ hVScsiIoReq)
222	{
223	RT_NOREF(hVScsiLun);
224	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
225	PDMMEDIAEXIOREQ hIoReq = DRVSCSI_VSCSIIOREQ_2_PDMMEDIAEXIOREQ(hVScsiIoReq);
226
227	return pThis->pDrvMediaEx->pfnIoReqFree(pThis->pDrvMediaEx, hIoReq);
228	}
229
230	/**
231	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunMediumGetSize}
232	*/
233	static DECLCALLBACK(int) drvscsiGetSize(VSCSILUN hVScsiLun, void pvScsiLunUser, uint64_t pcbSize)
234	{
235	RT_NOREF(hVScsiLun);
236	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
237
238	*pcbSize = pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia);
239
240	return VINF_SUCCESS;
241	}
242
243	/**
244	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunMediumGetSectorSize}
245	*/
246	static DECLCALLBACK(int) drvscsiGetSectorSize(VSCSILUN hVScsiLun, void pvScsiLunUser, uint32_t pcbSectorSize)
247	{
248	RT_NOREF(hVScsiLun);
249	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
250
251	*pcbSectorSize = pThis->pDrvMedia->pfnGetSectorSize(pThis->pDrvMedia);
252
253	return VINF_SUCCESS;
254	}
255
256	/**
257	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunMediumSetLock}
258	*/
259	static DECLCALLBACK(int) drvscsiSetLock(VSCSILUN hVScsiLun, void *pvScsiLunUser, bool fLocked)
260	{
261	RT_NOREF(hVScsiLun);
262	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
263
264	if (fLocked)
265	pThis->pDrvMount->pfnLock(pThis->pDrvMount);
266	else
267	pThis->pDrvMount->pfnUnlock(pThis->pDrvMount);
268
269	return VINF_SUCCESS;
270	}
271
272	/** @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunMediumEject} */
273	static DECLCALLBACK(int) drvscsiEject(VSCSILUN hVScsiLun, void *pvScsiLunUser)
274	{
275	RT_NOREF(hVScsiLun);
276	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
277	int rc = VINF_SUCCESS;
278	RTSEMEVENT hSemEvt = NIL_RTSEMEVENT;
279
280	/* This must be done from EMT. */
281	rc = RTSemEventCreate(&hSemEvt);
282	if (RT_SUCCESS(rc))
283	{
284	PDRVSCSIEJECTSTATE pEjectState = (PDRVSCSIEJECTSTATE)PDMQueueAlloc(pThis->pQueue);
285	if (pEjectState)
286	{
287	pEjectState->hSemEvt = hSemEvt;
288	PDMQueueInsert(pThis->pQueue, &pEjectState->Core);
289
290	/* Wait for completion. */
291	rc = RTSemEventWait(pEjectState->hSemEvt, RT_INDEFINITE_WAIT);
292	}
293	else
294	rc = VERR_NO_MEMORY;
295
296	RTSemEventDestroy(pEjectState->hSemEvt);
297	}
298
299	return rc;
300	}
301
302	/**
303	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunReqTransferEnqueue}
304	*/
305	static DECLCALLBACK(int) drvscsiReqTransferEnqueue(VSCSILUN hVScsiLun, void *pvScsiLunUser, VSCSIIOREQ hVScsiIoReq)
306	{
307	RT_NOREF(hVScsiLun);
308	int rc = VINF_SUCCESS;
309	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
310	PDMMEDIAEXIOREQ hIoReq = DRVSCSI_VSCSIIOREQ_2_PDMMEDIAEXIOREQ(hVScsiIoReq);
311
312	LogFlowFunc(("Enqueuing hVScsiIoReq=%#p\n", hVScsiIoReq));
313
314	VSCSIIOREQTXDIR enmTxDir = VSCSIIoReqTxDirGet(hVScsiIoReq);
315	switch (enmTxDir)
316	{
317	case VSCSIIOREQTXDIR_FLUSH:
318	{
319	rc = pThis->pDrvMediaEx->pfnIoReqFlush(pThis->pDrvMediaEx, hIoReq);
320	if ( RT_FAILURE(rc)
321	&& pThis->cErrors++ < MAX_LOG_REL_ERRORS)
322	LogRel(("SCSI#%u: Flush returned rc=%Rrc\n",
323	pThis->pDrvIns->iInstance, rc));
324	break;
325	}
326	case VSCSIIOREQTXDIR_UNMAP:
327	{
328	PCRTRANGE paRanges;
329	unsigned cRanges;
330
331	rc = VSCSIIoReqUnmapParamsGet(hVScsiIoReq, &paRanges, &cRanges);
332	AssertRC(rc);
333
334	pThis->pLed->Asserted.s.fWriting = pThis->pLed->Actual.s.fWriting = 1;
335	rc = pThis->pDrvMediaEx->pfnIoReqDiscard(pThis->pDrvMediaEx, hIoReq, cRanges);
336	if ( RT_FAILURE(rc)
337	&& pThis->cErrors++ < MAX_LOG_REL_ERRORS)
338	LogRel(("SCSI#%u: Discard returned rc=%Rrc\n",
339	pThis->pDrvIns->iInstance, rc));
340	break;
341	}
342	case VSCSIIOREQTXDIR_READ:
343	case VSCSIIOREQTXDIR_WRITE:
344	{
345	uint64_t uOffset = 0;
346	size_t cbTransfer = 0;
347	size_t cbSeg = 0;
348	PCRTSGSEG paSeg = NULL;
349	unsigned cSeg = 0;
350
351	rc = VSCSIIoReqParamsGet(hVScsiIoReq, &uOffset, &cbTransfer,
352	&cSeg, &cbSeg, &paSeg);
353	AssertRC(rc);
354
355	if (enmTxDir == VSCSIIOREQTXDIR_READ)
356	{
357	pThis->pLed->Asserted.s.fReading = pThis->pLed->Actual.s.fReading = 1;
358	rc = pThis->pDrvMediaEx->pfnIoReqRead(pThis->pDrvMediaEx, hIoReq, uOffset, cbTransfer);
359	STAM_REL_COUNTER_ADD(&pThis->StatBytesRead, cbTransfer);
360	}
361	else
362	{
363	pThis->pLed->Asserted.s.fWriting = pThis->pLed->Actual.s.fWriting = 1;
364	rc = pThis->pDrvMediaEx->pfnIoReqWrite(pThis->pDrvMediaEx, hIoReq, uOffset, cbTransfer);
365	STAM_REL_COUNTER_ADD(&pThis->StatBytesWritten, cbTransfer);
366	}
367
368	if ( RT_FAILURE(rc)
369	&& pThis->cErrors++ < MAX_LOG_REL_ERRORS)
370	LogRel(("SCSI#%u: %s at offset %llu (%u bytes left) returned rc=%Rrc\n",
371	pThis->pDrvIns->iInstance,
372	enmTxDir == VSCSIIOREQTXDIR_READ
373	? "Read"
374	: "Write",
375	uOffset,
376	cbTransfer, rc));
377	break;
378	}
379	default:
380	AssertMsgFailed(("Invalid transfer direction %u\n", enmTxDir));
381	}
382
383	if (rc == VINF_SUCCESS)
384	{
385	if (enmTxDir == VSCSIIOREQTXDIR_READ)
386	pThis->pLed->Actual.s.fReading = 0;
387	else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
388	pThis->pLed->Actual.s.fWriting = 0;
389	else
390	AssertMsg(enmTxDir == VSCSIIOREQTXDIR_FLUSH, ("Invalid transfer direction %u\n", enmTxDir));
391
392	VSCSIIoReqCompleted(hVScsiIoReq, VINF_SUCCESS, false);
393	rc = VINF_SUCCESS;
394	}
395	else if (rc == VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
396	rc = VINF_SUCCESS;
397	else if (RT_FAILURE(rc))
398	{
399	if (enmTxDir == VSCSIIOREQTXDIR_READ)
400	pThis->pLed->Actual.s.fReading = 0;
401	else if (enmTxDir == VSCSIIOREQTXDIR_WRITE)
402	pThis->pLed->Actual.s.fWriting = 0;
403	else
404	AssertMsg(enmTxDir == VSCSIIOREQTXDIR_FLUSH, ("Invalid transfer direction %u\n", enmTxDir));
405
406	VSCSIIoReqCompleted(hVScsiIoReq, rc, drvscsiIsRedoPossible(rc));
407	rc = VINF_SUCCESS;
408	}
409	else
410	AssertMsgFailed(("Invalid return code rc=%Rrc\n", rc));
411
412	return rc;
413	}
414
415	/**
416	* @interface_method_impl{VSCSILUNIOCALLBACKS,pfnVScsiLunGetFeatureFlags}
417	*/
418	static DECLCALLBACK(int) drvscsiGetFeatureFlags(VSCSILUN hVScsiLun, void pvScsiLunUser, uint64_t pfFeatures)
419	{
420	RT_NOREF(hVScsiLun);
421	PDRVSCSI pThis = (PDRVSCSI)pvScsiLunUser;
422
423	*pfFeatures = 0;
424
425	uint32_t fFeatures = 0;
426	int rc = pThis->pDrvMediaEx->pfnQueryFeatures(pThis->pDrvMediaEx, &fFeatures);
427	if (RT_SUCCESS(rc) && (fFeatures & PDMIMEDIAEX_FEATURE_F_DISCARD))
428	*pfFeatures \|= VSCSI_LUN_FEATURE_UNMAP;
429
430	if ( pThis->pDrvMedia
431	&& pThis->pDrvMedia->pfnIsNonRotational(pThis->pDrvMedia))
432	*pfFeatures \|= VSCSI_LUN_FEATURE_NON_ROTATIONAL;
433
434	if (pThis->pDrvMedia->pfnIsReadOnly(pThis->pDrvMedia))
435	*pfFeatures \|= VSCSI_LUN_FEATURE_READONLY;
436
437	return VINF_SUCCESS;
438	}
439
440
441	/* -=-=-=-=- IPortEx -=-=-=-=- */
442
443	/**
444	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
445	*/
446	static DECLCALLBACK(int) drvscsiIoReqCompleteNotify(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
447	void *pvIoReqAlloc, int rcReq)
448	{
449	RT_NOREF1(hIoReq);
450
451	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IPortEx);
452	VSCSIIOREQ hVScsiIoReq = (VSCSIIOREQ)((uint8_t *)pvIoReqAlloc + sizeof(PDMMEDIAEXIOREQ));
453	VSCSIIOREQTXDIR enmTxDir = VSCSIIoReqTxDirGet(hVScsiIoReq);
454
455	LogFlowFunc(("Request hVScsiIoReq=%#p completed\n", hVScsiIoReq));
456
457	if (enmTxDir == VSCSIIOREQTXDIR_READ)
458	pThis->pLed->Actual.s.fReading = 0;
459	else if ( enmTxDir == VSCSIIOREQTXDIR_WRITE
460	\|\| enmTxDir == VSCSIIOREQTXDIR_UNMAP)
461	pThis->pLed->Actual.s.fWriting = 0;
462	else
463	AssertMsg(enmTxDir == VSCSIIOREQTXDIR_FLUSH, ("Invalid transfer direction %u\n", enmTxDir));
464
465	if (RT_SUCCESS(rcReq))
466	VSCSIIoReqCompleted(hVScsiIoReq, rcReq, false /* fRedoPossible */);
467	else
468	{
469	pThis->cErrors++;
470	if (pThis->cErrors < MAX_LOG_REL_ERRORS)
471	{
472	if (enmTxDir == VSCSIIOREQTXDIR_FLUSH)
473	LogRel(("SCSI#%u: Flush returned rc=%Rrc\n",
474	pThis->pDrvIns->iInstance, rcReq));
475	else if (enmTxDir == VSCSIIOREQTXDIR_UNMAP)
476	LogRel(("SCSI#%u: Unmap returned rc=%Rrc\n",
477	pThis->pDrvIns->iInstance, rcReq));
478	else
479	{
480	uint64_t uOffset = 0;
481	size_t cbTransfer = 0;
482	size_t cbSeg = 0;
483	PCRTSGSEG paSeg = NULL;
484	unsigned cSeg = 0;
485
486	VSCSIIoReqParamsGet(hVScsiIoReq, &uOffset, &cbTransfer,
487	&cSeg, &cbSeg, &paSeg);
488
489	LogRel(("SCSI#%u: %s at offset %llu (%u bytes left) returned rc=%Rrc\n",
490	pThis->pDrvIns->iInstance,
491	enmTxDir == VSCSIIOREQTXDIR_READ
492	? "Read"
493	: "Write",
494	uOffset,
495	cbTransfer, rcReq));
496	}
497	}
498
499	VSCSIIoReqCompleted(hVScsiIoReq, rcReq, drvscsiIsRedoPossible(rcReq));
500	}
501
502	return VINF_SUCCESS;
503	}
504
505	/**
506	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
507	*/
508	static DECLCALLBACK(int) drvscsiIoReqCopyFromBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
509	void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf,
510	size_t cbCopy)
511	{
512	RT_NOREF2(pInterface, hIoReq);
513
514	VSCSIIOREQ hVScsiIoReq = DRVSCSI_PDMMEDIAEXIOREQ_2_VSCSIIOREQ(pvIoReqAlloc);
515	uint64_t uOffset = 0;
516	size_t cbTransfer = 0;
517	size_t cbSeg = 0;
518	PCRTSGSEG paSeg = NULL;
519	unsigned cSeg = 0;
520	size_t cbCopied = 0;
521
522	int rc = VSCSIIoReqParamsGet(hVScsiIoReq, &uOffset, &cbTransfer, &cSeg, &cbSeg, &paSeg);
523	if (RT_SUCCESS(rc))
524	{
525	RTSGBUF SgBuf;
526	RTSgBufInit(&SgBuf, paSeg, cSeg);
527
528	RTSgBufAdvance(&SgBuf, offDst);
529	cbCopied = RTSgBufCopy(&SgBuf, pSgBuf, cbCopy);
530	}
531
532	return cbCopied == cbCopy ? VINF_SUCCESS : VERR_PDM_MEDIAEX_IOBUF_OVERFLOW;
533	}
534
535	/**
536	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyToBuf}
537	*/
538	static DECLCALLBACK(int) drvscsiIoReqCopyToBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
539	void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf,
540	size_t cbCopy)
541	{
542	RT_NOREF2(pInterface, hIoReq);
543
544	VSCSIIOREQ hVScsiIoReq = DRVSCSI_PDMMEDIAEXIOREQ_2_VSCSIIOREQ(pvIoReqAlloc);
545	uint64_t uOffset = 0;
546	size_t cbTransfer = 0;
547	size_t cbSeg = 0;
548	PCRTSGSEG paSeg = NULL;
549	unsigned cSeg = 0;
550	size_t cbCopied = 0;
551
552	int rc = VSCSIIoReqParamsGet(hVScsiIoReq, &uOffset, &cbTransfer, &cSeg, &cbSeg, &paSeg);
553	if (RT_SUCCESS(rc))
554	{
555	RTSGBUF SgBuf;
556	RTSgBufInit(&SgBuf, paSeg, cSeg);
557
558	RTSgBufAdvance(&SgBuf, offSrc);
559	cbCopied = RTSgBufCopy(pSgBuf, &SgBuf, cbCopy);
560	}
561
562	return cbCopied == cbCopy ? VINF_SUCCESS : VERR_PDM_MEDIAEX_IOBUF_UNDERRUN;
563	}
564
565	/**
566	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqQueryDiscardRanges}
567	*/
568	static DECLCALLBACK(int) drvscsiIoReqQueryDiscardRanges(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
569	void *pvIoReqAlloc, uint32_t idxRangeStart,
570	uint32_t cRanges, PRTRANGE paRanges,
571	uint32_t *pcRanges)
572	{
573	RT_NOREF2(pInterface, hIoReq);
574
575	VSCSIIOREQ hVScsiIoReq = DRVSCSI_PDMMEDIAEXIOREQ_2_VSCSIIOREQ(pvIoReqAlloc);
576	PCRTRANGE paRangesVScsi;
577	unsigned cRangesVScsi;
578
579	int rc = VSCSIIoReqUnmapParamsGet(hVScsiIoReq, &paRangesVScsi, &cRangesVScsi);
580	if (RT_SUCCESS(rc))
581	{
582	uint32_t cRangesCopy = RT_MIN(cRangesVScsi - idxRangeStart, cRanges);
583	Assert( idxRangeStart < cRangesVScsi
584	&& (idxRangeStart + cRanges) <= cRangesVScsi);
585
586	memcpy(paRanges, &paRangesVScsi[idxRangeStart], cRangesCopy * sizeof(RTRANGE));
587	*pcRanges = cRangesCopy;
588	}
589	return rc;
590	}
591
592	/**
593	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqStateChanged}
594	*/
595	static DECLCALLBACK(void) drvscsiIoReqStateChanged(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
596	void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
597	{
598	RT_NOREF4(pInterface, hIoReq, pvIoReqAlloc, enmState);
599	AssertLogRelMsgFailed(("This should not be hit because I/O requests should not be suspended\n"));
600	}
601
602	static DECLCALLBACK(void) drvscsiVScsiReqCompleted(VSCSIDEVICE hVScsiDevice, void *pVScsiDeviceUser,
603	void *pVScsiReqUser, int rcScsiCode, bool fRedoPossible, int rcReq)
604	{
605	RT_NOREF(hVScsiDevice);
606	PDRVSCSI pThis = (PDRVSCSI)pVScsiDeviceUser;
607
608	ASMAtomicDecU32(&pThis->StatIoDepth);
609
610	pThis->pDevScsiPort->pfnSCSIRequestCompleted(pThis->pDevScsiPort, (PPDMSCSIREQUEST)pVScsiReqUser,
611	rcScsiCode, fRedoPossible, rcReq);
612
613	if (RT_UNLIKELY(pThis->fDummySignal) && !pThis->StatIoDepth)
614	PDMDrvHlpAsyncNotificationCompleted(pThis->pDrvIns);
615	}
616
617	/* -=-=-=-=- ISCSIConnector -=-=-=-=- */
618
619	#ifdef DEBUG
620	/**
621	* Dumps a SCSI request structure for debugging purposes.
622	*
623	* @returns nothing.
624	* @param pRequest Pointer to the request to dump.
625	*/
626	static void drvscsiDumpScsiRequest(PPDMSCSIREQUEST pRequest)
627	{
628	Log(("Dump for pRequest=%#p Command: %s\n", pRequest, SCSICmdText(pRequest->pbCDB[0])));
629	Log(("cbCDB=%u\n", pRequest->cbCDB));
630	for (uint32_t i = 0; i < pRequest->cbCDB; i++)
631	Log(("pbCDB[%u]=%#x\n", i, pRequest->pbCDB[i]));
632	Log(("cbScatterGather=%u\n", pRequest->cbScatterGather));
633	Log(("cScatterGatherEntries=%u\n", pRequest->cScatterGatherEntries));
634	/* Print all scatter gather entries. */
635	for (uint32_t i = 0; i < pRequest->cScatterGatherEntries; i++)
636	{
637	Log(("ScatterGatherEntry[%u].cbSeg=%u\n", i, pRequest->paScatterGatherHead[i].cbSeg));
638	Log(("ScatterGatherEntry[%u].pvSeg=%#p\n", i, pRequest->paScatterGatherHead[i].pvSeg));
639	}
640	Log(("pvUser=%#p\n", pRequest->pvUser));
641	}
642	#endif
643
644	/** @interface_method_impl{PDMISCSICONNECTOR,pfnSCSIRequestSend} */
645	static DECLCALLBACK(int) drvscsiRequestSend(PPDMISCSICONNECTOR pInterface, PPDMSCSIREQUEST pSCSIRequest)
646	{
647	int rc;
648	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, ISCSIConnector);
649	VSCSIREQ hVScsiReq;
650
651	#ifdef DEBUG
652	drvscsiDumpScsiRequest(pSCSIRequest);
653	#endif
654
655	rc = VSCSIDeviceReqCreate(pThis->hVScsiDevice, &hVScsiReq,
656	pSCSIRequest->uLogicalUnit,
657	pSCSIRequest->pbCDB,
658	pSCSIRequest->cbCDB,
659	pSCSIRequest->cbScatterGather,
660	pSCSIRequest->cScatterGatherEntries,
661	pSCSIRequest->paScatterGatherHead,
662	pSCSIRequest->pbSenseBuffer,
663	pSCSIRequest->cbSenseBuffer,
664	pSCSIRequest);
665	if (RT_FAILURE(rc))
666	return rc;
667
668	ASMAtomicIncU32(&pThis->StatIoDepth);
669	rc = VSCSIDeviceReqEnqueue(pThis->hVScsiDevice, hVScsiReq);
670
671	return rc;
672	}
673
674	/** @interface_method_impl{PDMISCSICONNECTOR,pfnQueryLUNType} */
675	static DECLCALLBACK(int) drvscsiQueryLUNType(PPDMISCSICONNECTOR pInterface, uint32_t iLun, PPDMSCSILUNTYPE pLunType)
676	{
677	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, ISCSIConnector);
678	VSCSILUNTYPE enmLunType;
679
680	int rc = VSCSIDeviceLunQueryType(pThis->hVScsiDevice, iLun, &enmLunType);
681	if (RT_FAILURE(rc))
682	return rc;
683
684	switch (enmLunType)
685	{
686	case VSCSILUNTYPE_SBC: *pLunType = PDMSCSILUNTYPE_SBC; break;
687	case VSCSILUNTYPE_MMC: *pLunType = PDMSCSILUNTYPE_MMC; break;
688	case VSCSILUNTYPE_SSC: *pLunType = PDMSCSILUNTYPE_SSC; break;
689	default: *pLunType = PDMSCSILUNTYPE_INVALID;
690	}
691
692	return rc;
693	}
694
695	/* -=-=-=-=- IMedia -=-=-=-=- */
696
697	/** @interface_method_impl{PDMIMEDIA,pfnGetSize} */
698	static DECLCALLBACK(uint64_t) drvscsiGetSize(PPDMIMEDIA pInterface)
699	{
700	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
701	return pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia);
702	}
703
704	/** @interface_method_impl{PDMIMEDIA,pfnGetSectorSize} */
705	static DECLCALLBACK(uint32_t) drvscsiGetSectorSize(PPDMIMEDIA pInterface)
706	{
707	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
708	return pThis->pDrvMedia->pfnGetSectorSize(pThis->pDrvMedia);
709	}
710
711	/** @interface_method_impl{PDMIMEDIA,pfnIsReadOnly} */
712	static DECLCALLBACK(bool) drvscsiIsReadOnly(PPDMIMEDIA pInterface)
713	{
714	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
715	return pThis->pDrvMedia->pfnIsReadOnly(pThis->pDrvMedia);
716	}
717
718	/** @interface_method_impl{PDMIMEDIA,pfnIsNonRotational} */
719	static DECLCALLBACK(bool) drvscsiIsNonRotational(PPDMIMEDIA pInterface)
720	{
721	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
722	return pThis->pDrvMedia->pfnIsNonRotational(pThis->pDrvMedia);
723	}
724
725	/** @interface_method_impl{PDMIMEDIA,pfnBiosGetPCHSGeometry} */
726	static DECLCALLBACK(int) drvscsiBiosGetPCHSGeometry(PPDMIMEDIA pInterface,
727	PPDMMEDIAGEOMETRY pPCHSGeometry)
728	{
729	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
730	return pThis->pDrvMedia->pfnBiosGetPCHSGeometry(pThis->pDrvMedia, pPCHSGeometry);
731	}
732
733	/** @interface_method_impl{PDMIMEDIA,pfnBiosSetPCHSGeometry} */
734	static DECLCALLBACK(int) drvscsiBiosSetPCHSGeometry(PPDMIMEDIA pInterface,
735	PCPDMMEDIAGEOMETRY pPCHSGeometry)
736	{
737	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
738	return pThis->pDrvMedia->pfnBiosSetPCHSGeometry(pThis->pDrvMedia, pPCHSGeometry);
739	}
740
741	/** @interface_method_impl{PDMIMEDIA,pfnBiosGetLCHSGeometry} */
742	static DECLCALLBACK(int) drvscsiBiosGetLCHSGeometry(PPDMIMEDIA pInterface,
743	PPDMMEDIAGEOMETRY pLCHSGeometry)
744	{
745	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
746	return pThis->pDrvMedia->pfnBiosGetLCHSGeometry(pThis->pDrvMedia, pLCHSGeometry);
747	}
748
749	/** @interface_method_impl{PDMIMEDIA,pfnBiosSetLCHSGeometry} */
750	static DECLCALLBACK(int) drvscsiBiosSetLCHSGeometry(PPDMIMEDIA pInterface,
751	PCPDMMEDIAGEOMETRY pLCHSGeometry)
752	{
753	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
754	return pThis->pDrvMedia->pfnBiosSetLCHSGeometry(pThis->pDrvMedia, pLCHSGeometry);
755	}
756
757	/** @interface_method_impl{PDMIMEDIA,pfnBiosIsVisible} */
758	static DECLCALLBACK(bool) drvscsiBiosIsVisible(PPDMIMEDIA pInterface)
759	{
760	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
761	return pThis->pDrvMedia->pfnBiosIsVisible(pThis->pDrvMedia);
762	}
763
764	/** @interface_method_impl{PDMIMEDIA,pfnGetType} */
765	static DECLCALLBACK(PDMMEDIATYPE) drvscsiGetType(PPDMIMEDIA pInterface)
766	{
767	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
768	VSCSILUNTYPE enmLunType;
769	PDMMEDIATYPE enmMediaType = PDMMEDIATYPE_ERROR;
770
771	int rc = VSCSIDeviceLunQueryType(pThis->hVScsiDevice, 0, &enmLunType);
772	if (RT_SUCCESS(rc))
773	{
774	switch (enmLunType)
775	{
776	case VSCSILUNTYPE_SBC:
777	enmMediaType = PDMMEDIATYPE_HARD_DISK;
778	break;
779	case VSCSILUNTYPE_MMC:
780	enmMediaType = PDMMEDIATYPE_CDROM;
781	break;
782	default:
783	enmMediaType = PDMMEDIATYPE_ERROR;
784	break;
785	}
786	}
787
788	return enmMediaType;
789	}
790
791	/** @interface_method_impl{PDMIMEDIA,pfnGetUuid} */
792	static DECLCALLBACK(int) drvscsiGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
793	{
794	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMedia);
795
796	int rc = VINF_SUCCESS;
797	if (pThis->pDrvMedia)
798	rc = pThis->pDrvMedia->pfnGetUuid(pThis->pDrvMedia, pUuid);
799	else
800	RTUuidClear(pUuid);
801
802	return rc;
803	}
804
805	/* -=-=-=-=- IMediaEx -=-=-=-=- */
806
807	/** @interface_method_impl{PDMIMEDIAEX,pfnQueryFeatures} */
808	static DECLCALLBACK(int) drvscsiQueryFeatures(PPDMIMEDIAEX pInterface, uint32_t *pfFeatures)
809	{
810	RT_NOREF1(pInterface);
811
812	*pfFeatures = PDMIMEDIAEX_FEATURE_F_RAWSCSICMD;
813	return VINF_SUCCESS;
814	}
815
816	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqAllocSizeSet} */
817	static DECLCALLBACK(int) drvscsiIoReqAllocSizeSet(PPDMIMEDIAEX pInterface, size_t cbIoReqAlloc)
818	{
819	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMediaEx);
820
821	pThis->cbIoReqAlloc = RT_OFFSETOF(DRVSCSIREQ, abAlloc[cbIoReqAlloc]);
822	return VINF_SUCCESS;
823	}
824
825	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqAlloc} */
826	static DECLCALLBACK(int) drvscsiIoReqAlloc(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc,
827	PDMMEDIAEXIOREQID uIoReqId, uint32_t fFlags)
828	{
829	RT_NOREF2(uIoReqId, fFlags);
830
831	int rc = VINF_SUCCESS;
832	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMediaEx);
833	PDRVSCSIREQ pReq = (PDRVSCSIREQ)RTMemAllocZ(pThis->cbIoReqAlloc);
834	if (RT_LIKELY(pReq))
835	{
836	*phIoReq = (PDMMEDIAEXIOREQ)pReq;
837	*ppvIoReqAlloc = &pReq->abAlloc[0];
838	}
839	else
840	rc = VERR_NO_MEMORY;
841
842	return rc;
843	}
844
845	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqFree} */
846	static DECLCALLBACK(int) drvscsiIoReqFree(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
847	{
848	RT_NOREF1(pInterface);
849	PDRVSCSIREQ pReq = (PDRVSCSIREQ)hIoReq;
850
851	if (pReq->pvBuf)
852	RTMemFree(pReq->pvBuf);
853
854	RTMemFree(pReq);
855	return VINF_SUCCESS;
856	}
857
858	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQueryResidual} */
859	static DECLCALLBACK(int) drvscsiIoReqQueryResidual(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, size_t *pcbResidual)
860	{
861	RT_NOREF2(pInterface, hIoReq);
862
863	pcbResidual = 0; /* @todo: Implement. */
864	return VINF_SUCCESS;
865	}
866
867	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancelAll} */
868	static DECLCALLBACK(int) drvscsiIoReqCancelAll(PPDMIMEDIAEX pInterface)
869	{
870	RT_NOREF1(pInterface);
871	return VINF_SUCCESS;
872	}
873
874	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancel} */
875	static DECLCALLBACK(int) drvscsiIoReqCancel(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQID uIoReqId)
876	{
877	RT_NOREF2(pInterface, uIoReqId);
878	return VERR_PDM_MEDIAEX_IOREQID_NOT_FOUND;
879	}
880
881	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqRead} */
882	static DECLCALLBACK(int) drvscsiIoReqRead(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbRead)
883	{
884	RT_NOREF4(pInterface, hIoReq, off, cbRead);
885	return VERR_NOT_SUPPORTED;
886	}
887
888	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqWrite} */
889	static DECLCALLBACK(int) drvscsiIoReqWrite(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbWrite)
890	{
891	RT_NOREF4(pInterface, hIoReq, off, cbWrite);
892	return VERR_NOT_SUPPORTED;
893	}
894
895	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqFlush} */
896	static DECLCALLBACK(int) drvscsiIoReqFlush(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
897	{
898	RT_NOREF2(pInterface, hIoReq);
899	return VERR_NOT_SUPPORTED;
900	}
901
902	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqDiscard} */
903	static DECLCALLBACK(int) drvscsiIoReqDiscard(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, unsigned cRangesMax)
904	{
905	RT_NOREF3(pInterface, hIoReq, cRangesMax);
906	return VERR_NOT_SUPPORTED;
907	}
908
909	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd} */
910	static DECLCALLBACK(int) drvscsiIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
911	const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
912	size_t cbBuf, uint8_t pabSense, size_t cbSense, uint8_t pu8ScsiSts,
913	uint32_t cTimeoutMillies)
914	{
915	RT_NOREF1(cTimeoutMillies);
916
917	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMediaEx);
918	PDRVSCSIREQ pReq = (PDRVSCSIREQ)hIoReq;
919	int rc = VINF_SUCCESS;
920
921	Log(("Dump for pReq=%#p Command: %s\n", pReq, SCSICmdText(pbCdb[0])));
922	Log(("cbCdb=%u\n", cbCdb));
923	for (uint32_t i = 0; i < cbCdb; i++)
924	Log(("pbCdb[%u]=%#x\n", i, pbCdb[i]));
925	Log(("cbBuf=%zu\n", cbBuf));
926
927	pReq->enmXferDir = enmTxDir;
928	pReq->cbBuf = cbBuf;
929	pReq->pu8ScsiSts = pu8ScsiSts;
930
931	/* Allocate and sync buffers if a data transfer is indicated. */
932	if (cbBuf)
933	{
934	pReq->pvBuf = RTMemAlloc(cbBuf);
935	if (RT_UNLIKELY(!pReq->pvBuf))
936	rc = VERR_NO_MEMORY;
937	}
938
939	if (RT_SUCCESS(rc))
940	{
941	pReq->Seg.pvSeg = pReq->pvBuf;
942	pReq->Seg.cbSeg = cbBuf;
943
944	if ( cbBuf
945	&& ( enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN
946	\|\| enmTxDir == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE))
947	{
948	RTSGBUF SgBuf;
949	RTSgBufInit(&SgBuf, &pReq->Seg, 1);
950	rc = pThis->pDevMediaExPort->pfnIoReqCopyToBuf(pThis->pDevMediaExPort, hIoReq, &pReq->abAlloc[0],
951	0, &SgBuf, cbBuf);
952	}
953
954	if (RT_SUCCESS(rc))
955	{
956	rc = VSCSIDeviceReqCreate(pThis->hVScsiDevice, &pReq->hVScsiReq,
957	uLun, (uint8_t *)pbCdb, cbCdb, cbBuf, 1, &pReq->Seg,
958	pabSense, cbSense, pReq);
959	if (RT_SUCCESS(rc))
960	{
961	ASMAtomicIncU32(&pThis->StatIoDepth);
962	rc = VSCSIDeviceReqEnqueue(pThis->hVScsiDevice, pReq->hVScsiReq);
963	if (RT_SUCCESS(rc))
964	rc = VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS;
965	}
966	}
967	}
968
969	return rc;
970	}
971
972	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetActiveCount} */
973	static DECLCALLBACK(uint32_t) drvscsiIoReqGetActiveCount(PPDMIMEDIAEX pInterface)
974	{
975	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMediaEx);
976	return pThis->StatIoDepth;
977	}
978
979	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetSuspendedCount} */
980	static DECLCALLBACK(uint32_t) drvscsiIoReqGetSuspendedCount(PPDMIMEDIAEX pInterface)
981	{
982	RT_NOREF1(pInterface);
983	return 0;
984	}
985
986	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedStart} */
987	static DECLCALLBACK(int) drvscsiIoReqQuerySuspendedStart(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc)
988	{
989	RT_NOREF3(pInterface, phIoReq, ppvIoReqAlloc);
990	return VERR_NOT_IMPLEMENTED;
991	}
992
993	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedNext} */
994	static DECLCALLBACK(int) drvscsiIoReqQuerySuspendedNext(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
995	PPDMMEDIAEXIOREQ phIoReqNext, void **ppvIoReqAllocNext)
996	{
997	RT_NOREF4(pInterface, hIoReq, phIoReqNext, ppvIoReqAllocNext);
998	return VERR_NOT_IMPLEMENTED;
999	}
1000
1001	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedSave} */
1002	static DECLCALLBACK(int) drvscsiIoReqSuspendedSave(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1003	{
1004	RT_NOREF3(pInterface, pSSM, hIoReq);
1005	return VERR_NOT_IMPLEMENTED;
1006	}
1007
1008	/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedLoad} */
1009	static DECLCALLBACK(int) drvscsiIoReqSuspendedLoad(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1010	{
1011	RT_NOREF3(pInterface, pSSM, hIoReq);
1012	return VERR_NOT_IMPLEMENTED;
1013	}
1014
1015
1016	static DECLCALLBACK(void) drvscsiIoReqVScsiReqCompleted(VSCSIDEVICE hVScsiDevice, void *pVScsiDeviceUser,
1017	void *pVScsiReqUser, int rcScsiCode, bool fRedoPossible, int rcReq)
1018	{
1019	RT_NOREF2(hVScsiDevice, fRedoPossible);
1020	PDRVSCSI pThis = (PDRVSCSI)pVScsiDeviceUser;
1021	PDRVSCSIREQ pReq = (PDRVSCSIREQ)pVScsiReqUser;
1022
1023	ASMAtomicDecU32(&pThis->StatIoDepth);
1024
1025	/* Sync buffers. */
1026	if ( pReq->cbBuf
1027	&& ( pReq->enmXferDir == PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN
1028	\|\| pReq->enmXferDir == PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE))
1029	{
1030	RTSGBUF SgBuf;
1031	RTSgBufInit(&SgBuf, &pReq->Seg, 1);
1032	int rcCopy = pThis->pDevMediaExPort->pfnIoReqCopyFromBuf(pThis->pDevMediaExPort, (PDMMEDIAEXIOREQ)pReq,
1033	&pReq->abAlloc[0], 0, &SgBuf, pReq->cbBuf);
1034	if (RT_FAILURE(rcCopy))
1035	rcReq = rcCopy;
1036	}
1037
1038	*pReq->pu8ScsiSts = (uint8_t)rcScsiCode;
1039	int rc = pThis->pDevMediaExPort->pfnIoReqCompleteNotify(pThis->pDevMediaExPort, (PDMMEDIAEXIOREQ)pReq,
1040	&pReq->abAlloc[0], rcReq);
1041	AssertRC(rc); RT_NOREF(rc);
1042
1043	if (RT_UNLIKELY(pThis->fDummySignal) && !pThis->StatIoDepth)
1044	PDMDrvHlpAsyncNotificationCompleted(pThis->pDrvIns);
1045	}
1046
1047	/**
1048	* Consumer for the queue
1049	*
1050	* @returns Success indicator.
1051	* If false the item will not be removed and the flushing will stop.
1052	* @param pDrvIns The driver instance.
1053	* @param pItem The item to consume. Upon return this item will be freed.
1054	*/
1055	static DECLCALLBACK(bool) drvscsiR3NotifyQueueConsumer(PPDMDRVINS pDrvIns, PPDMQUEUEITEMCORE pItem)
1056	{
1057	PDRVSCSIEJECTSTATE pEjectState = (PDRVSCSIEJECTSTATE)pItem;
1058	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1059
1060	int rc = pThis->pDrvMount->pfnUnmount(pThis->pDrvMount, false/=fForce/, true/=fEject/);
1061	Assert(RT_SUCCESS(rc) \|\| rc == VERR_PDM_MEDIA_LOCKED \|\| rc == VERR_PDM_MEDIA_NOT_MOUNTED);
1062	if (RT_SUCCESS(rc))
1063	{
1064	if (pThis->pDevMediaExPort)
1065	pThis->pDevMediaExPort->pfnMediumEjected(pThis->pDevMediaExPort);
1066	}
1067
1068	RTSemEventSignal(pEjectState->hSemEvt);
1069	return true;
1070	}
1071
1072	/* -=-=-=-=- IBase -=-=-=-=- */
1073
1074	/**
1075	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1076	*/
1077	static DECLCALLBACK(void ) drvscsiQueryInterface(PPDMIBASE pInterface, const char pszIID)
1078	{
1079	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1080	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1081
1082	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUNT, pThis->pDrvMount);
1083	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1084	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISCSICONNECTOR, &pThis->ISCSIConnector);
1085	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEX, pThis->pDevMediaExPort ? &pThis->IMediaEx : NULL);
1086	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, pThis->pDevMediaPort ? &pThis->IMedia : NULL);
1087	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAPORT, &pThis->IPort);
1088	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUNTNOTIFY, &pThis->IMountNotify);
1089	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEXPORT, &pThis->IPortEx);
1090	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, pThis->pDrvMedia);
1091	return NULL;
1092	}
1093
1094	static DECLCALLBACK(int) drvscsiQueryDeviceLocation(PPDMIMEDIAPORT pInterface, const char **ppcszController,
1095	uint32_t piInstance, uint32_t piLUN)
1096	{
1097	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IPort);
1098
1099	if (pThis->pDevScsiPort)
1100	return pThis->pDevScsiPort->pfnQueryDeviceLocation(pThis->pDevScsiPort, ppcszController,
1101	piInstance, piLUN);
1102	if (pThis->pDevMediaPort)
1103	return pThis->pDevMediaPort->pfnQueryDeviceLocation(pThis->pDevMediaPort, ppcszController,
1104	piInstance, piLUN);
1105
1106	return VERR_NOT_SUPPORTED;
1107	}
1108
1109	/**
1110	* Called when media is mounted.
1111	*
1112	* @param pInterface Pointer to the interface structure containing the called function pointer.
1113	*/
1114	static DECLCALLBACK(void) drvscsiMountNotify(PPDMIMOUNTNOTIFY pInterface)
1115	{
1116	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMountNotify);
1117	LogFlowFunc(("mounting LUN#%p\n", pThis->hVScsiLun));
1118
1119	/* Ignore the call if we're called while being attached. */
1120	if (!pThis->pDrvMedia)
1121	return;
1122
1123	/* Let the LUN know that a medium was mounted. */
1124	VSCSILunMountNotify(pThis->hVScsiLun);
1125	}
1126
1127	/**
1128	* Called when media is unmounted
1129	*
1130	* @param pInterface Pointer to the interface structure containing the called function pointer.
1131	*/
1132	static DECLCALLBACK(void) drvscsiUnmountNotify(PPDMIMOUNTNOTIFY pInterface)
1133	{
1134	PDRVSCSI pThis = RT_FROM_MEMBER(pInterface, DRVSCSI, IMountNotify);
1135	LogFlowFunc(("unmounting LUN#%p\n", pThis->hVScsiLun));
1136
1137	/* Let the LUN know that the medium was unmounted. */
1138	VSCSILunUnmountNotify(pThis->hVScsiLun);
1139	}
1140
1141	/**
1142	* Worker for drvscsiReset, drvscsiSuspend and drvscsiPowerOff.
1143	*
1144	* @param pDrvIns The driver instance.
1145	* @param pfnAsyncNotify The async callback.
1146	*/
1147	static void drvscsiR3ResetOrSuspendOrPowerOff(PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify)
1148	{
1149	RT_NOREF1(pfnAsyncNotify);
1150
1151	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1152
1153	if (pThis->StatIoDepth > 0)
1154	ASMAtomicWriteBool(&pThis->fDummySignal, true);
1155	}
1156
1157	/**
1158	* Callback employed by drvscsiSuspend and drvscsiPowerOff.
1159	*
1160	* @returns true if we've quiesced, false if we're still working.
1161	* @param pDrvIns The driver instance.
1162	*/
1163	static DECLCALLBACK(bool) drvscsiIsAsyncSuspendOrPowerOffDone(PPDMDRVINS pDrvIns)
1164	{
1165	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1166
1167	if (pThis->StatIoDepth > 0)
1168	return false;
1169	else
1170	return true;
1171	}
1172
1173	/**
1174	* @copydoc FNPDMDRVPOWEROFF
1175	*/
1176	static DECLCALLBACK(void) drvscsiPowerOff(PPDMDRVINS pDrvIns)
1177	{
1178	drvscsiR3ResetOrSuspendOrPowerOff(pDrvIns, drvscsiIsAsyncSuspendOrPowerOffDone);
1179	}
1180
1181	/**
1182	* @copydoc FNPDMDRVSUSPEND
1183	*/
1184	static DECLCALLBACK(void) drvscsiSuspend(PPDMDRVINS pDrvIns)
1185	{
1186	drvscsiR3ResetOrSuspendOrPowerOff(pDrvIns, drvscsiIsAsyncSuspendOrPowerOffDone);
1187	}
1188
1189	/**
1190	* Callback employed by drvscsiReset.
1191	*
1192	* @returns true if we've quiesced, false if we're still working.
1193	* @param pDrvIns The driver instance.
1194	*/
1195	static DECLCALLBACK(bool) drvscsiIsAsyncResetDone(PPDMDRVINS pDrvIns)
1196	{
1197	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1198
1199	if (pThis->StatIoDepth > 0)
1200	return false;
1201	else
1202	return true;
1203	}
1204
1205	/** @copydoc FNPDMDRVATTACH */
1206	static DECLCALLBACK(int) drvscsiAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
1207	{
1208	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1209
1210	LogFlowFunc(("pDrvIns=%#p fFlags=%#x\n", pDrvIns, fFlags));
1211
1212	AssertMsgReturn((fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
1213	("SCSI: Hotplugging is not supported\n"),
1214	VERR_INVALID_PARAMETER);
1215
1216	/*
1217	* Try attach driver below and query it's media interface.
1218	*/
1219	int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pThis->pDrvBase);
1220	AssertMsgReturn(RT_SUCCESS(rc), ("Attaching driver below failed rc=%Rrc\n", rc), rc);
1221
1222	/*
1223	* Query the media interface.
1224	*/
1225	pThis->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMEDIA);
1226	AssertMsgReturn(VALID_PTR(pThis->pDrvMedia), ("VSCSI configuration error: No media interface!\n"),
1227	VERR_PDM_MISSING_INTERFACE);
1228
1229	/* Query the extended media interface. */
1230	pThis->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMEDIAEX);
1231	AssertMsgReturn(VALID_PTR(pThis->pDrvMediaEx), ("VSCSI configuration error: No extended media interface!\n"),
1232	VERR_PDM_MISSING_INTERFACE);
1233
1234	pThis->pDrvMount = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMOUNT);
1235
1236	if (pThis->cbVScsiIoReqAlloc)
1237	{
1238	rc = pThis->pDrvMediaEx->pfnIoReqAllocSizeSet(pThis->pDrvMediaEx, pThis->cbVScsiIoReqAlloc);
1239	AssertMsgReturn(RT_SUCCESS(rc), ("Setting the I/O request allocation size failed with rc=%Rrc\n", rc), rc);
1240	}
1241
1242	if (pThis->pDrvMount)
1243	{
1244	if (pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia))
1245	{
1246	rc = VINF_SUCCESS; VSCSILunMountNotify(pThis->hVScsiLun);
1247	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to notify the LUN of media being mounted\n"), rc);
1248	}
1249	else
1250	{
1251	rc = VINF_SUCCESS; VSCSILunUnmountNotify(pThis->hVScsiLun);
1252	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to notify the LUN of media being unmounted\n"), rc);
1253	}
1254	}
1255
1256	return rc;
1257	}
1258
1259	/** @copydoc FNPDMDRVDETACH */
1260	static DECLCALLBACK(void) drvscsiDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
1261	{
1262	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1263
1264	LogFlowFunc(("pDrvIns=%#p fFlags=%#x\n", pDrvIns, fFlags));
1265
1266	AssertMsgReturnVoid((fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
1267	("SCSI: Hotplugging is not supported\n"));
1268
1269	/*
1270	* Zero some important members.
1271	*/
1272	pThis->pDrvBase = NULL;
1273	pThis->pDrvMedia = NULL;
1274	pThis->pDrvMediaEx = NULL;
1275	pThis->pDrvMount = NULL;
1276	}
1277
1278	/**
1279	* @copydoc FNPDMDRVRESET
1280	*/
1281	static DECLCALLBACK(void) drvscsiReset(PPDMDRVINS pDrvIns)
1282	{
1283	drvscsiR3ResetOrSuspendOrPowerOff(pDrvIns, drvscsiIsAsyncResetDone);
1284	}
1285
1286	/**
1287	* Destruct a driver instance.
1288	*
1289	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
1290	* resources can be freed correctly.
1291	*
1292	* @param pDrvIns The driver instance data.
1293	*/
1294	static DECLCALLBACK(void) drvscsiDestruct(PPDMDRVINS pDrvIns)
1295	{
1296	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1297	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1298
1299	/* Free the VSCSI device and LUN handle. */
1300	if (pThis->hVScsiDevice)
1301	{
1302	VSCSILUN hVScsiLun;
1303	int rc = VSCSIDeviceLunDetach(pThis->hVScsiDevice, 0, &hVScsiLun);
1304	AssertRC(rc);
1305
1306	Assert(hVScsiLun == pThis->hVScsiLun);
1307	rc = VSCSILunDestroy(hVScsiLun);
1308	AssertRC(rc);
1309	rc = VSCSIDeviceDestroy(pThis->hVScsiDevice);
1310	AssertRC(rc);
1311
1312	pThis->hVScsiDevice = NULL;
1313	pThis->hVScsiLun = NULL;
1314	}
1315
1316	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatBytesRead);
1317	PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatBytesWritten);
1318	PDMDrvHlpSTAMDeregister(pDrvIns, (void *)&pThis->StatIoDepth);
1319	}
1320
1321	/**
1322	* Construct a block driver instance.
1323	*
1324	* @copydoc FNPDMDRVCONSTRUCT
1325	*/
1326	static DECLCALLBACK(int) drvscsiConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1327	{
1328	int rc = VINF_SUCCESS;
1329	PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
1330	LogFlowFunc(("pDrvIns=%#p pCfg=%#p\n", pDrvIns, pCfg));
1331	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1332
1333	/*
1334	* Initialize the instance data.
1335	*/
1336	pThis->pDrvIns = pDrvIns;
1337	pThis->ISCSIConnector.pfnSCSIRequestSend = drvscsiRequestSend;
1338	pThis->ISCSIConnector.pfnQueryLUNType = drvscsiQueryLUNType;
1339
1340	pDrvIns->IBase.pfnQueryInterface = drvscsiQueryInterface;
1341
1342	/* IMedia */
1343	pThis->IMedia.pfnRead = NULL;
1344	pThis->IMedia.pfnReadPcBios = NULL;
1345	pThis->IMedia.pfnWrite = NULL;
1346	pThis->IMedia.pfnFlush = NULL;
1347	pThis->IMedia.pfnSendCmd = NULL;
1348	pThis->IMedia.pfnMerge = NULL;
1349	pThis->IMedia.pfnSetSecKeyIf = NULL;
1350	pThis->IMedia.pfnGetSize = drvscsiGetSize;
1351	pThis->IMedia.pfnGetSectorSize = drvscsiGetSectorSize;
1352	pThis->IMedia.pfnIsReadOnly = drvscsiIsReadOnly;
1353	pThis->IMedia.pfnIsNonRotational = drvscsiIsNonRotational;
1354	pThis->IMedia.pfnBiosGetPCHSGeometry = drvscsiBiosGetPCHSGeometry;
1355	pThis->IMedia.pfnBiosSetPCHSGeometry = drvscsiBiosSetPCHSGeometry;
1356	pThis->IMedia.pfnBiosGetLCHSGeometry = drvscsiBiosGetLCHSGeometry;
1357	pThis->IMedia.pfnBiosSetLCHSGeometry = drvscsiBiosSetLCHSGeometry;
1358	pThis->IMedia.pfnBiosIsVisible = drvscsiBiosIsVisible;
1359	pThis->IMedia.pfnGetType = drvscsiGetType;
1360	pThis->IMedia.pfnGetUuid = drvscsiGetUuid;
1361	pThis->IMedia.pfnDiscard = NULL;
1362
1363	/* IMediaEx */
1364	pThis->IMediaEx.pfnQueryFeatures = drvscsiQueryFeatures;
1365	pThis->IMediaEx.pfnIoReqAllocSizeSet = drvscsiIoReqAllocSizeSet;
1366	pThis->IMediaEx.pfnIoReqAlloc = drvscsiIoReqAlloc;
1367	pThis->IMediaEx.pfnIoReqFree = drvscsiIoReqFree;
1368	pThis->IMediaEx.pfnIoReqQueryResidual = drvscsiIoReqQueryResidual;
1369	pThis->IMediaEx.pfnIoReqCancelAll = drvscsiIoReqCancelAll;
1370	pThis->IMediaEx.pfnIoReqCancel = drvscsiIoReqCancel;
1371	pThis->IMediaEx.pfnIoReqRead = drvscsiIoReqRead;
1372	pThis->IMediaEx.pfnIoReqWrite = drvscsiIoReqWrite;
1373	pThis->IMediaEx.pfnIoReqFlush = drvscsiIoReqFlush;
1374	pThis->IMediaEx.pfnIoReqDiscard = drvscsiIoReqDiscard;
1375	pThis->IMediaEx.pfnIoReqSendScsiCmd = drvscsiIoReqSendScsiCmd;
1376	pThis->IMediaEx.pfnIoReqGetActiveCount = drvscsiIoReqGetActiveCount;
1377	pThis->IMediaEx.pfnIoReqGetSuspendedCount = drvscsiIoReqGetSuspendedCount;
1378	pThis->IMediaEx.pfnIoReqQuerySuspendedStart = drvscsiIoReqQuerySuspendedStart;
1379	pThis->IMediaEx.pfnIoReqQuerySuspendedNext = drvscsiIoReqQuerySuspendedNext;
1380	pThis->IMediaEx.pfnIoReqSuspendedSave = drvscsiIoReqSuspendedSave;
1381	pThis->IMediaEx.pfnIoReqSuspendedLoad = drvscsiIoReqSuspendedLoad;
1382
1383	pThis->IMountNotify.pfnMountNotify = drvscsiMountNotify;
1384	pThis->IMountNotify.pfnUnmountNotify = drvscsiUnmountNotify;
1385	pThis->IPort.pfnQueryDeviceLocation = drvscsiQueryDeviceLocation;
1386	pThis->IPortEx.pfnIoReqCompleteNotify = drvscsiIoReqCompleteNotify;
1387	pThis->IPortEx.pfnIoReqCopyFromBuf = drvscsiIoReqCopyFromBuf;
1388	pThis->IPortEx.pfnIoReqCopyToBuf = drvscsiIoReqCopyToBuf;
1389	pThis->IPortEx.pfnIoReqQueryDiscardRanges = drvscsiIoReqQueryDiscardRanges;
1390	pThis->IPortEx.pfnIoReqStateChanged = drvscsiIoReqStateChanged;
1391
1392	/* Query the optional SCSI port interface above. */
1393	pThis->pDevScsiPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMISCSIPORT);
1394
1395	/* Query the optional media port interface above. */
1396	pThis->pDevMediaPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAPORT);
1397
1398	/* Query the optional extended media port interface above. */
1399	pThis->pDevMediaExPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAEXPORT);
1400
1401	AssertMsgReturn(pThis->pDevScsiPort \|\| pThis->pDevMediaExPort,
1402	("Missing SCSI or extended media port interface above\n"), VERR_PDM_MISSING_INTERFACE);
1403
1404	/* Query the optional LED interface above. */
1405	pThis->pLedPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMILEDPORTS);
1406	if (pThis->pLedPort != NULL)
1407	{
1408	/* Get The Led. */
1409	rc = pThis->pLedPort->pfnQueryStatusLed(pThis->pLedPort, 0, &pThis->pLed);
1410	if (RT_FAILURE(rc))
1411	pThis->pLed = &pThis->Led;
1412	}
1413	else
1414	pThis->pLed = &pThis->Led;
1415
1416	/*
1417	* Validate and read configuration.
1418	*/
1419	if (!CFGMR3AreValuesValid(pCfg, ""))
1420	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
1421	N_("SCSI configuration error: unknown option specified"));
1422
1423	/*
1424	* Try attach driver below and query it's media interface.
1425	*/
1426	rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pThis->pDrvBase);
1427	AssertMsgReturn(RT_SUCCESS(rc), ("Attaching driver below failed rc=%Rrc\n", rc), rc);
1428
1429	/*
1430	* Query the media interface.
1431	*/
1432	pThis->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMEDIA);
1433	AssertMsgReturn(VALID_PTR(pThis->pDrvMedia), ("VSCSI configuration error: No media interface!\n"),
1434	VERR_PDM_MISSING_INTERFACE);
1435
1436	/* Query the extended media interface. */
1437	pThis->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMEDIAEX);
1438	AssertMsgReturn(VALID_PTR(pThis->pDrvMediaEx), ("VSCSI configuration error: No extended media interface!\n"),
1439	VERR_PDM_MISSING_INTERFACE);
1440
1441	pThis->pDrvMount = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIMOUNT);
1442
1443	PDMMEDIATYPE enmType = pThis->pDrvMedia->pfnGetType(pThis->pDrvMedia);
1444	VSCSILUNTYPE enmLunType;
1445	switch (enmType)
1446	{
1447	case PDMMEDIATYPE_HARD_DISK:
1448	enmLunType = VSCSILUNTYPE_SBC;
1449	break;
1450	case PDMMEDIATYPE_CDROM:
1451	case PDMMEDIATYPE_DVD:
1452	enmLunType = VSCSILUNTYPE_MMC;
1453	break;
1454	default:
1455	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_UNSUPPORTED_BLOCK_TYPE, RT_SRC_POS,
1456	N_("Only hard disks and CD/DVD-ROMs are currently supported as SCSI devices (enmType=%d)"),
1457	enmType);
1458	}
1459	if ( ( enmType == PDMMEDIATYPE_DVD
1460	\|\| enmType == PDMMEDIATYPE_CDROM)
1461	&& !pThis->pDrvMount)
1462	{
1463	AssertMsgFailed(("Internal error: cdrom without a mountable interface\n"));
1464	return VERR_INTERNAL_ERROR;
1465	}
1466
1467	/* Create VSCSI device and LUN. */
1468	pThis->VScsiIoCallbacks.pfnVScsiLunReqAllocSizeSet = drvscsiReqAllocSizeSet;
1469	pThis->VScsiIoCallbacks.pfnVScsiLunReqAlloc = drvscsiReqAlloc;
1470	pThis->VScsiIoCallbacks.pfnVScsiLunReqFree = drvscsiReqFree;
1471	pThis->VScsiIoCallbacks.pfnVScsiLunMediumGetSize = drvscsiGetSize;
1472	pThis->VScsiIoCallbacks.pfnVScsiLunMediumGetSectorSize = drvscsiGetSectorSize;
1473	pThis->VScsiIoCallbacks.pfnVScsiLunMediumEject = drvscsiEject;
1474	pThis->VScsiIoCallbacks.pfnVScsiLunReqTransferEnqueue = drvscsiReqTransferEnqueue;
1475	pThis->VScsiIoCallbacks.pfnVScsiLunGetFeatureFlags = drvscsiGetFeatureFlags;
1476	pThis->VScsiIoCallbacks.pfnVScsiLunMediumSetLock = drvscsiSetLock;
1477
1478	rc = VSCSIDeviceCreate(&pThis->hVScsiDevice,
1479	pThis->pDevMediaExPort
1480	? drvscsiIoReqVScsiReqCompleted
1481	: drvscsiVScsiReqCompleted,
1482	pThis);
1483	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create VSCSI device rc=%Rrc\n", rc), rc);
1484	rc = VSCSILunCreate(&pThis->hVScsiLun, enmLunType, &pThis->VScsiIoCallbacks,
1485	pThis);
1486	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create VSCSI LUN rc=%Rrc\n", rc), rc);
1487	rc = VSCSIDeviceLunAttach(pThis->hVScsiDevice, pThis->hVScsiLun, 0);
1488	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to attached the LUN to the SCSI device\n"), rc);
1489
1490	/// @todo This is a very hacky way of telling the LUN whether a medium was mounted.
1491	// The mount/unmount interface doesn't work in a very sensible manner!
1492	if (pThis->pDrvMount)
1493	{
1494	if (pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia))
1495	{
1496	rc = VINF_SUCCESS; VSCSILunMountNotify(pThis->hVScsiLun);
1497	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to notify the LUN of media being mounted\n"), rc);
1498	}
1499	else
1500	{
1501	rc = VINF_SUCCESS; VSCSILunUnmountNotify(pThis->hVScsiLun);
1502	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to notify the LUN of media being unmounted\n"), rc);
1503	}
1504	}
1505
1506	const char *pszCtrl = NULL;
1507	uint32_t iCtrlInstance = 0;
1508	uint32_t iCtrlLun = 0;
1509
1510	if (pThis->pDevScsiPort)
1511	rc = pThis->pDevScsiPort->pfnQueryDeviceLocation(pThis->pDevScsiPort, &pszCtrl, &iCtrlInstance, &iCtrlLun);
1512	if (pThis->pDevMediaPort)
1513	rc = pThis->pDevMediaPort->pfnQueryDeviceLocation(pThis->pDevMediaPort, &pszCtrl, &iCtrlInstance, &iCtrlLun);
1514	if (RT_SUCCESS(rc))
1515	{
1516	const char *pszCtrlId = strcmp(pszCtrl, "Msd") == 0 ? "USB"
1517	: strcmp(pszCtrl, "lsilogicsas") == 0 ? "SAS"
1518	: "SCSI";
1519	/* Register statistics counter. */
1520	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,
1521	"Amount of data read.", "/Devices/%s%u/%u/ReadBytes", pszCtrlId, iCtrlInstance, iCtrlLun);
1522	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,
1523	"Amount of data written.", "/Devices/%s%u/%u/WrittenBytes", pszCtrlId, iCtrlInstance, iCtrlLun);
1524	PDMDrvHlpSTAMRegisterF(pDrvIns, (void *)&pThis->StatIoDepth, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT,
1525	"Number of active tasks.", "/Devices/%s%u/%u/IoDepth", pszCtrlId, iCtrlInstance, iCtrlLun);
1526	}
1527
1528	pThis->StatIoDepth = 0;
1529
1530	uint32_t fFeatures = 0;
1531	rc = pThis->pDrvMediaEx->pfnQueryFeatures(pThis->pDrvMediaEx, &fFeatures);
1532	if (RT_FAILURE(rc))
1533	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1534	N_("VSCSI configuration error: Failed to query features of device"));
1535	if (fFeatures & PDMIMEDIAEX_FEATURE_F_DISCARD)
1536	LogRel(("SCSI#%d: Enabled UNMAP support\n", pDrvIns->iInstance));
1537
1538	rc = PDMDrvHlpQueueCreate(pDrvIns, sizeof(DRVSCSIEJECTSTATE), 1, 0, drvscsiR3NotifyQueueConsumer,
1539	"SCSI-Eject", &pThis->pQueue);
1540	if (RT_FAILURE(rc))
1541	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1542	N_("VSCSI configuration error: Failed to create notification queue"));
1543
1544	return VINF_SUCCESS;
1545	}
1546
1547	/**
1548	* SCSI driver registration record.
1549	*/
1550	const PDMDRVREG g_DrvSCSI =
1551	{
1552	/* u32Version */
1553	PDM_DRVREG_VERSION,
1554	/* szName */
1555	"SCSI",
1556	/* szRCMod */
1557	"",
1558	/* szR0Mod */
1559	"",
1560	/* pszDescription */
1561	"Generic SCSI driver.",
1562	/* fFlags */
1563	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1564	/* fClass. */
1565	PDM_DRVREG_CLASS_SCSI,
1566	/* cMaxInstances */
1567	~0U,
1568	/* cbInstance */
1569	sizeof(DRVSCSI),
1570	/* pfnConstruct */
1571	drvscsiConstruct,
1572	/* pfnDestruct */
1573	drvscsiDestruct,
1574	/* pfnRelocate */
1575	NULL,
1576	/* pfnIOCtl */
1577	NULL,
1578	/* pfnPowerOn */
1579	NULL,
1580	/* pfnReset */
1581	drvscsiReset,
1582	/* pfnSuspend */
1583	drvscsiSuspend,
1584	/* pfnResume */
1585	NULL,
1586	/* pfnAttach */
1587	drvscsiAttach,
1588	/* pfnDetach */
1589	drvscsiDetach,
1590	/* pfnPowerOff */
1591	drvscsiPowerOff,
1592	/* pfnSoftReset */
1593	NULL,
1594	/* u32EndVersion */
1595	PDM_DRVREG_VERSION
1596	};

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

source: vbox/trunk/src/VBox/Devices/Storage/DrvSCSI.cpp@ 64150

Download in other formats: