DrvSCSI.cpp@ 68080

Last change on this file since 68080 was 67597, checked in by vboxsync, 8 years ago
DrvSCSI.cpp/drvscsiConstruct: Don't assert on PDMDrvHlpAttach failure, it's really annoying in combination with VISO.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 54.1 KB

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

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

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

Download in other formats: