DrvSCSIHost.cpp@ 28125

Last change on this file since 28125 was 28065, checked in by vboxsync, 15 years ago
Storage: Convert from PDMDATASEG to RTSGSEG to avoid casting between those two in VBoxHDD and more async I/O updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.4 KB

Line
1	/* $Id: DrvSCSIHost.cpp 28065 2010-04-07 20:54:34Z vboxsync $ */
2	/** @file
3	* VBox storage drivers: Host SCSI access driver.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	//#define DEBUG
26	#define LOG_GROUP LOG_GROUP_DRV_SCSIHOST
27	#include <VBox/pdmdrv.h>
28	#include <VBox/pdmifs.h>
29	#include <VBox/pdmthread.h>
30	#include <VBox/scsi.h>
31	#include <iprt/assert.h>
32	#include <iprt/file.h>
33	#include <iprt/mem.h>
34	#include <iprt/req.h>
35	#include <iprt/string.h>
36	#include <iprt/uuid.h>
37
38	#if defined(RT_OS_LINUX)
39	# include <limits.h>
40	# include <scsi/sg.h>
41	# include <sys/ioctl.h>
42	#endif
43
44	#include "../Builtins.h"
45
46	/**
47	* SCSI driver instance data.
48	*
49	* @implements PDMISCSICONNECTOR
50	*/
51	typedef struct DRVSCSIHOST
52	{
53	/** Pointer driver instance. */
54	PPDMDRVINS pDrvIns;
55
56	/** Pointer to the SCSI port interface of the device above. */
57	PPDMISCSIPORT pDevScsiPort;
58	/** The SCSI connector interface . */
59	PDMISCSICONNECTOR ISCSIConnector;
60
61	/** PAth to the device file. */
62	char *pszDevicePath;
63	/** Handle to the device. */
64	RTFILE DeviceFile;
65
66	/** The dedicated I/O thread. */
67	PPDMTHREAD pAsyncIOThread;
68	/** Queue for passing the requests to the thread. */
69	PRTREQQUEUE pQueueRequests;
70	} DRVSCSIHOST, *PDRVSCSIHOST;
71
72	/** Converts a pointer to DRVSCSIHOST::ISCSIConnecotr to a PDRVSCSIHOST. */
73	#define PDMISCSICONNECTOR_2_DRVSCSIHOST(pInterface) ( (PDRVSCSIHOST)((uintptr_t)pInterface - RT_OFFSETOF(DRVSCSIHOST, ISCSIConnector)) )
74
75	#ifdef DEBUG
76	/**
77	* Dumps a SCSI request structure for debugging purposes.
78	*
79	* @returns nothing.
80	* @param pRequest Pointer to the request to dump.
81	*/
82	static void drvscsihostDumpScsiRequest(PPDMSCSIREQUEST pRequest)
83	{
84	Log(("Dump for pRequest=%#p Command: %s\n", pRequest, SCSICmdText(pRequest->pbCDB[0])));
85	Log(("cbCDB=%u\n", pRequest->cbCDB));
86	for (uint32_t i = 0; i < pRequest->cbCDB; i++)
87	Log(("pbCDB[%u]=%#x\n", i, pRequest->pbCDB[i]));
88	Log(("cbScatterGather=%u\n", pRequest->cbScatterGather));
89	Log(("cScatterGatherEntries=%u\n", pRequest->cScatterGatherEntries));
90	/* Print all scatter gather entries. */
91	for (uint32_t i = 0; i < pRequest->cScatterGatherEntries; i++)
92	{
93	Log(("ScatterGatherEntry[%u].cbSeg=%u\n", i, pRequest->paScatterGatherHead[i].cbSeg));
94	Log(("ScatterGatherEntry[%u].pvSeg=%#p\n", i, pRequest->paScatterGatherHead[i].pvSeg));
95	}
96	Log(("pvUser=%#p\n", pRequest->pvUser));
97	}
98	#endif
99
100	/**
101	* Copy the content of a buffer to a scatter gather list
102	* copying only the amount of data which fits into the
103	* scatter gather list.
104	*
105	* @returns VBox status code.
106	* @param pRequest Pointer to the request which contains the S/G list entries.
107	* @param pvBuf Pointer to the buffer which should be copied.
108	* @param cbBuf Size of the buffer.
109	*/
110	static int drvscsihostScatterGatherListCopyFromBuffer(PPDMSCSIREQUEST pRequest, void *pvBuf, size_t cbBuf)
111	{
112	unsigned cSGEntry = 0;
113	PRTSGSEG pSGEntry = &pRequest->paScatterGatherHead[cSGEntry];
114	uint8_t pu8Buf = (uint8_t )pvBuf;
115
116	while (cSGEntry < pRequest->cScatterGatherEntries)
117	{
118	size_t cbToCopy = (cbBuf < pSGEntry->cbSeg) ? cbBuf : pSGEntry->cbSeg;
119
120	memcpy(pSGEntry->pvSeg, pu8Buf, cbToCopy);
121
122	cbBuf -= cbToCopy;
123	/* We finished. */
124	if (!cbBuf)
125	break;
126
127	/* Advance the buffer. */
128	pu8Buf += cbToCopy;
129
130	/* Go to the next entry in the list. */
131	pSGEntry++;
132	cSGEntry++;
133	}
134
135	return VINF_SUCCESS;
136	}
137
138	/**
139	* Set the sense and advanced sense key in the buffer for error conditions.
140	*
141	* @returns nothing.
142	* @param pRequest Pointer to the request which contains the sense buffer.
143	* @param uSCSISenseKey The sense key to set.
144	* @param uSCSIASC The advanced sense key to set.
145	*/
146	DECLINLINE(void) drvscsiCmdError(PPDMSCSIREQUEST pRequest, uint8_t uSCSISenseKey, uint8_t uSCSIASC)
147	{
148	AssertMsg(pRequest->cbSenseBuffer >= 2, ("Sense buffer is not big enough\n"));
149	AssertMsg(pRequest->pbSenseBuffer, ("Sense buffer pointer is NULL\n"));
150	pRequest->pbSenseBuffer[0] = uSCSISenseKey;
151	pRequest->pbSenseBuffer[1] = uSCSIASC;
152	}
153
154	/**
155	* Sets the sense key for a status good condition.
156	*
157	* @returns nothing.
158	* @param pRequest Pointer to the request which contains the sense buffer.
159	*/
160	DECLINLINE(void) drvscsihostCmdOk(PPDMSCSIREQUEST pRequest)
161	{
162	AssertMsg(pRequest->cbSenseBuffer >= 2, ("Sense buffer is not big enough\n"));
163	AssertMsg(pRequest->pbSenseBuffer, ("Sense buffer pointer is NULL\n"));
164	pRequest->pbSenseBuffer[0] = SCSI_SENSE_NONE;
165	pRequest->pbSenseBuffer[1] = SCSI_ASC_NONE;
166	}
167
168	/**
169	* Returns the transfer direction of the given command
170	* in case the device does not provide this info.
171	*
172	* @returns transfer direction of the command.
173	* SCSIHOSTTXDIR_NONE if no data is transfered.
174	* SCSIHOSTTXDIR_FROM_DEVICE if the data is read from the device.
175	* SCSIHOSTTXDIR_TO_DEVICE if the data is written to the device.
176	* @param uCommand The command byte.
177	*/
178	static unsigned drvscsihostGetTransferDirectionFromCommand(uint8_t uCommand)
179	{
180	switch (uCommand)
181	{
182	case SCSI_INQUIRY:
183	case SCSI_REPORT_LUNS:
184	case SCSI_MODE_SENSE_6:
185	case SCSI_READ_TOC_PMA_ATIP:
186	case SCSI_READ_CAPACITY:
187	case SCSI_MODE_SENSE_10:
188	case SCSI_GET_EVENT_STATUS_NOTIFICATION:
189	case SCSI_GET_CONFIGURATION:
190	case SCSI_READ_10:
191	case SCSI_READ_12:
192	case SCSI_READ_BUFFER:
193	case SCSI_READ_BUFFER_CAPACITY:
194	case SCSI_READ_DISC_INFORMATION:
195	case SCSI_READ_DVD_STRUCTURE:
196	case SCSI_READ_FORMAT_CAPACITIES:
197	case SCSI_READ_SUBCHANNEL:
198	case SCSI_READ_TRACK_INFORMATION:
199	case SCSI_READ_CD:
200	case SCSI_READ_CD_MSF:
201	return PDMSCSIREQUESTTXDIR_FROM_DEVICE;
202	case SCSI_TEST_UNIT_READY:
203	case SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL:
204	case SCSI_START_STOP_UNIT:
205	return PDMSCSIREQUESTTXDIR_NONE;
206	case SCSI_WRITE_10:
207	case SCSI_WRITE_12:
208	case SCSI_WRITE_BUFFER:
209	return PDMSCSIREQUESTTXDIR_TO_DEVICE;
210	default:
211	AssertMsgFailed(("Command not known %#x\n", uCommand));
212	}
213
214	/* We should never get here in debug mode. */
215	AssertMsgFailed(("Impossible to get here!!!\n"));
216	return PDMSCSIREQUESTTXDIR_NONE; /* to make compilers happy. */
217	}
218
219	static int drvscsihostProcessRequestOne(PDRVSCSIHOST pThis, PPDMSCSIREQUEST pRequest)
220	{
221	int rc = VINF_SUCCESS;
222	unsigned uTxDir;
223
224	LogFlowFunc(("Entered\n"));
225
226	#ifdef DEBUG
227	drvscsihostDumpScsiRequest(pRequest);
228	#endif
229
230	/* We implement only one device. */
231	if (pRequest->uLogicalUnit != 0)
232	{
233	switch (pRequest->pbCDB[0])
234	{
235	case SCSI_INQUIRY:
236	{
237	SCSIINQUIRYDATA ScsiInquiryReply;
238
239	memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
240
241	ScsiInquiryReply.u5PeripheralDeviceType = SCSI_INQUIRY_DATA_PERIPHERAL_DEVICE_TYPE_UNKNOWN;
242	ScsiInquiryReply.u3PeripheralQualifier = SCSI_INQUIRY_DATA_PERIPHERAL_QUALIFIER_NOT_CONNECTED_NOT_SUPPORTED;
243	drvscsihostScatterGatherListCopyFromBuffer(pRequest, &ScsiInquiryReply, sizeof(SCSIINQUIRYDATA));
244	drvscsihostCmdOk(pRequest);
245	break;
246	}
247	default:
248	AssertMsgFailed(("Command not implemented for attached device\n"));
249	drvscsiCmdError(pRequest, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_NONE);
250	}
251	}
252	else
253	{
254	#if defined(RT_OS_LINUX)
255	sg_io_hdr_t ScsiIoReq;
256	sg_iovec_t *paSG = NULL;
257
258	/* Setup SCSI request. */
259	memset(&ScsiIoReq, 0, sizeof(sg_io_hdr_t));
260	ScsiIoReq.interface_id = 'S';
261
262	if (pRequest->uDataDirection == PDMSCSIREQUESTTXDIR_UNKNOWN)
263	uTxDir = drvscsihostGetTransferDirectionFromCommand(pRequest->pbCDB[0]);
264	else
265	uTxDir = pRequest->uDataDirection;
266
267	if (uTxDir == PDMSCSIREQUESTTXDIR_NONE)
268	ScsiIoReq.dxfer_direction = SG_DXFER_NONE;
269	else if (uTxDir == PDMSCSIREQUESTTXDIR_TO_DEVICE)
270	ScsiIoReq.dxfer_direction = SG_DXFER_TO_DEV;
271	else if (uTxDir == PDMSCSIREQUESTTXDIR_FROM_DEVICE)
272	ScsiIoReq.dxfer_direction = SG_DXFER_FROM_DEV;
273	else
274	AssertMsgFailed(("Invalid transfer direction %u\n", uTxDir));
275
276	ScsiIoReq.cmd_len = pRequest->cbCDB;
277	ScsiIoReq.mx_sb_len = pRequest->cbSenseBuffer;
278	ScsiIoReq.dxfer_len = pRequest->cbScatterGather;
279
280	if (pRequest->cScatterGatherEntries > 0)
281	{
282	if (pRequest->cScatterGatherEntries == 1)
283	{
284	ScsiIoReq.iovec_count = 0;
285	ScsiIoReq.dxferp = pRequest->paScatterGatherHead[0].pvSeg;
286	}
287	else
288	{
289	ScsiIoReq.iovec_count = pRequest->cScatterGatherEntries;
290
291	paSG = (sg_iovec_t )RTMemAllocZ(pRequest->cScatterGatherEntries sizeof(sg_iovec_t));
292	AssertPtrReturn(paSG, VERR_NO_MEMORY);
293
294	for (unsigned i = 0; i < pRequest->cScatterGatherEntries; i++)
295	{
296	paSG[i].iov_base = pRequest->paScatterGatherHead[i].pvSeg;
297	paSG[i].iov_len = pRequest->paScatterGatherHead[i].cbSeg;
298	}
299	ScsiIoReq.dxferp = paSG;
300	}
301	}
302
303	ScsiIoReq.cmdp = pRequest->pbCDB;
304	ScsiIoReq.sbp = pRequest->pbSenseBuffer;
305	ScsiIoReq.timeout = UINT_MAX;
306	ScsiIoReq.flags \|= SG_FLAG_DIRECT_IO;
307
308	/** Issue command. */
309	rc = ioctl(pThis->DeviceFile, SG_IO, &ScsiIoReq);
310	if (rc < 0)
311	{
312	AssertMsgFailed(("Ioctl failed with rc=%d\n", rc));
313	}
314
315	/* Request processed successfully. */
316	Log(("Command successfully processed\n"));
317	if (ScsiIoReq.iovec_count > 0)
318	RTMemFree(paSG);
319	#endif
320	}
321	/* Notify device that request finished. */
322	rc = pThis->pDevScsiPort->pfnSCSIRequestCompleted(pThis->pDevScsiPort, pRequest, SCSI_STATUS_OK);
323	AssertMsgRC(rc, ("Notifying device above failed rc=%Rrc\n", rc));
324
325	return rc;
326
327	}
328
329	/**
330	* Request function to wakeup the thread.
331	*
332	* @returns VWRN_STATE_CHANGED.
333	*/
334	static int drvscsihostAsyncIOLoopWakeupFunc(void)
335	{
336	return VWRN_STATE_CHANGED;
337	}
338
339	/**
340	* The thread function which processes the requests asynchronously.
341	*
342	* @returns VBox status code.
343	* @param pDrvIns Pointer to the device instance data.
344	* @param pThread Pointer to the thread instance data.
345	*/
346	static int drvscsihostAsyncIOLoop(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
347	{
348	int rc = VINF_SUCCESS;
349	PDRVSCSIHOST pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSIHOST);
350
351	LogFlowFunc(("Entering async IO loop.\n"));
352
353	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
354	return VINF_SUCCESS;
355
356	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
357	{
358	rc = RTReqProcess(pThis->pQueueRequests, RT_INDEFINITE_WAIT);
359	AssertMsg(rc == VWRN_STATE_CHANGED, ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n", rc));
360	}
361
362	return VINF_SUCCESS;
363	}
364
365	static int drvscsihostAsyncIOLoopWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
366	{
367	int rc;
368	PDRVSCSIHOST pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSIHOST);
369	PRTREQ pReq;
370
371	AssertMsgReturn(pThis->pQueueRequests, ("pQueueRequests is NULL\n"), VERR_INVALID_STATE);
372
373	rc = RTReqCall(pThis->pQueueRequests, &pReq, 10000 /* 10 sec. */, (PFNRT)drvscsihostAsyncIOLoopWakeupFunc, 0);
374	AssertMsgRC(rc, ("Inserting request into queue failed rc=%Rrc\n"));
375
376	return rc;
377	}
378
379	/* -=-=-=-=- ISCSIConnector -=-=-=-=- */
380
381	/** @copydoc PDMISCSICONNECTOR::pfnSCSIRequestSend. */
382	static DECLCALLBACK(int) drvscsihostRequestSend(PPDMISCSICONNECTOR pInterface, PPDMSCSIREQUEST pSCSIRequest)
383	{
384	int rc;
385	PDRVSCSIHOST pThis = PDMISCSICONNECTOR_2_DRVSCSIHOST(pInterface);
386	PRTREQ pReq;
387
388	AssertMsgReturn(pThis->pQueueRequests, ("pQueueRequests is NULL\n"), VERR_INVALID_STATE);
389
390	rc = RTReqCallEx(pThis->pQueueRequests, &pReq, 0, RTREQFLAGS_NO_WAIT, (PFNRT)drvscsihostProcessRequestOne, 2, pThis, pSCSIRequest);
391	AssertMsgReturn(RT_SUCCESS(rc), ("Inserting request into queue failed rc=%Rrc\n", rc), rc);
392
393	return VINF_SUCCESS;
394	}
395
396	/* -=-=-=-=- PDMIBASE -=-=-=-=- */
397
398	/**
399	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
400	*/
401	static DECLCALLBACK(void ) drvscsihostQueryInterface(PPDMIBASE pInterface, const char pszIID)
402	{
403	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
404	PDRVSCSIHOST pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSIHOST);
405
406	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
407	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISCSICONNECTOR, &pThis->ISCSIConnector);
408	return NULL;
409	}
410
411	/* -=-=-=-=- PDMDRVREG -=-=-=-=- */
412
413	/**
414	* Destruct a driver instance.
415	*
416	* Most VM resources are freed by the VM. This callback is provided so that any non-VM
417	* resources can be freed correctly.
418	*
419	* @param pDrvIns The driver instance data.
420	*/
421	static DECLCALLBACK(void) drvscsihostDestruct(PPDMDRVINS pDrvIns)
422	{
423	PDRVSCSIHOST pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSIHOST);
424	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
425
426	if (pThis->DeviceFile != NIL_RTFILE)
427	RTFileClose(pThis->DeviceFile);
428
429	if (pThis->pszDevicePath)
430	MMR3HeapFree(pThis->pszDevicePath);
431
432	if (pThis->pQueueRequests)
433	{
434	int rc = RTReqDestroyQueue(pThis->pQueueRequests);
435	AssertMsgRC(rc, ("Failed to destroy queue rc=%Rrc\n", rc));
436	}
437
438	}
439
440	/**
441	* Construct a block driver instance.
442	*
443	* @copydoc FNPDMDRVCONSTRUCT
444	*/
445	static DECLCALLBACK(int) drvscsihostConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
446	{
447	PDRVSCSIHOST pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSIHOST);
448	LogFlowFunc(("pDrvIns=%#p pCfg=%#p\n", pDrvIns, pCfg));
449	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
450
451	/*
452	* Read the configuration.
453	*/
454	if (!CFGMR3AreValuesValid(pCfg, "DevicePath\0"))
455	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES,
456	N_("Invalid configuration for host scsi access driver"));
457
458	/*
459	* Initialize interfaces.
460	*/
461	pDrvIns->IBase.pfnQueryInterface = drvscsihostQueryInterface;
462	pThis->ISCSIConnector.pfnSCSIRequestSend = drvscsihostRequestSend;
463	pThis->pDrvIns = pDrvIns;
464	pThis->DeviceFile = NIL_RTFILE;
465
466	/* Query the SCSI port interface above. */
467	pThis->pDevScsiPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMISCSIPORT);
468	AssertMsgReturn(pThis->pDevScsiPort, ("Missing SCSI port interface above\n"), VERR_PDM_MISSING_INTERFACE);
469
470	/* Create request queue. */
471	int rc = RTReqCreateQueue(&pThis->pQueueRequests);
472	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create request queue rc=%Rrc\n"), rc);
473
474	/* Open the device. */
475	rc = CFGMR3QueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);
476	if (RT_FAILURE(rc))
477	return PDMDRV_SET_ERROR(pDrvIns, rc,
478	N_("Configuration error: Failed to get the \"DevicePath\" value"));
479
480	rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
481	if (RT_FAILURE(rc))
482	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
483	N_("DrvSCSIHost#%d: Failed to open device '%s'"), pDrvIns->iInstance, pThis->pszDevicePath);
484
485	/* Create I/O thread. */
486	rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pAsyncIOThread, pThis, drvscsihostAsyncIOLoop,
487	drvscsihostAsyncIOLoopWakeup, 0, RTTHREADTYPE_IO, "SCSI async IO");
488	AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create async I/O thread rc=%Rrc\n"), rc);
489
490	return VINF_SUCCESS;
491	}
492
493	/**
494	* SCSI driver registration record.
495	*/
496	const PDMDRVREG g_DrvSCSIHost =
497	{
498	/* u32Version */
499	PDM_DRVREG_VERSION,
500	/* szName */
501	"SCSIHost",
502	/* szRCMod */
503	"",
504	/* szR0Mod */
505	"",
506	/* pszDescription */
507	"Host SCSI driver.",
508	/* fFlags */
509	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
510	/* fClass. */
511	PDM_DRVREG_CLASS_SCSI,
512	/* cMaxInstances */
513	~0,
514	/* cbInstance */
515	sizeof(DRVSCSIHOST),
516	/* pfnConstruct */
517	drvscsihostConstruct,
518	/* pfnDestruct */
519	drvscsihostDestruct,
520	/* pfnRelocate */
521	NULL,
522	/* pfnIOCtl */
523	NULL,
524	/* pfnPowerOn */
525	NULL,
526	/* pfnReset */
527	NULL,
528	/* pfnSuspend */
529	NULL,
530	/* pfnResume */
531	NULL,
532	/* pfnAttach */
533	NULL,
534	/* pfnDetach */
535	NULL,
536	/* pfnPowerOff */
537	NULL,
538	/* pfnSoftReset */
539	NULL,
540	/* u32EndVersion */
541	PDM_DRVREG_VERSION
542	};
543

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

source: vbox/trunk/src/VBox/Devices/Storage/DrvSCSIHost.cpp@ 28125

Download in other formats: