DevVirtioSCSI.cpp@ 102468

Last change on this file since 102468 was 100400, checked in by vboxsync, 18 months ago
Devices/VirtIO: Add support for the VirtIO over MMIO transport mode useful for ARM, bugref:10459
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 121.1 KB

Line
1	/* $Id: DevVirtioSCSI.cpp 100400 2023-07-06 08:58:02Z vboxsync $ */
2	/** @file
3	* VBox storage devices - Virtio SCSI Driver
4	*
5	* Log-levels used:
6	* - Level 1: The most important (but usually rare) things to note
7	* - Level 2: SCSI command logging
8	* - Level 3: Vector and I/O transfer summary (shows what client sent an expects and fulfillment)
9	* - Level 6: Device <-> Guest Driver negotation, traffic, notifications and state handling
10	* - Level 12: Brief formatted hex dumps of I/O data
11	*/
12
13	/*
14	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
15	*
16	* This file is part of VirtualBox base platform packages, as
17	* available from https://www.virtualbox.org.
18	*
19	* This program is free software; you can redistribute it and/or
20	* modify it under the terms of the GNU General Public License
21	* as published by the Free Software Foundation, in version 3 of the
22	* License.
23	*
24	* This program is distributed in the hope that it will be useful, but
25	* WITHOUT ANY WARRANTY; without even the implied warranty of
26	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27	* General Public License for more details.
28	*
29	* You should have received a copy of the GNU General Public License
30	* along with this program; if not, see <https://www.gnu.org/licenses>.
31	*
32	* SPDX-License-Identifier: GPL-3.0-only
33	*/
34
35
36	/*********************************************************************************************************************************
37	* Header Files *
38	*********************************************************************************************************************************/
39	//#define LOG_GROUP LOG_GROUP_DRV_SCSI
40	#define LOG_GROUP LOG_GROUP_DEV_VIRTIO
41
42	#include <VBox/vmm/pdmdev.h>
43	#include <VBox/vmm/pdmstorageifs.h>
44	#include <VBox/vmm/pdmcritsect.h>
45	#include <VBox/AssertGuest.h>
46	#include <VBox/msi.h>
47	#include <VBox/version.h>
48	#include <VBox/log.h>
49	#include <iprt/errcore.h>
50	#include <iprt/assert.h>
51	#include <iprt/string.h>
52	#include <VBox/sup.h>
53	#include "../build/VBoxDD.h"
54	#include <VBox/scsi.h>
55	#ifdef IN_RING3
56	# include <iprt/alloc.h>
57	# include <iprt/memcache.h>
58	# include <iprt/semaphore.h>
59	# include <iprt/sg.h>
60	# include <iprt/param.h>
61	# include <iprt/uuid.h>
62	#endif
63	#include "../VirtIO/VirtioCore.h"
64
65	#include "VBoxSCSI.h"
66	#include "VBoxDD.h"
67
68
69	/*********************************************************************************************************************************
70	* Defined Constants And Macros *
71	*********************************************************************************************************************************/
72	/** The current saved state version. */
73	#define VIRTIOSCSI_SAVED_STATE_VERSION UINT32_C(1)
74
75
76	#define LUN0 0
77	/** @name VirtIO 1.0 SCSI Host feature bits (See VirtIO 1.0 specification, Section 5.6.3)
78	* @{ */
79	#define VIRTIO_SCSI_F_INOUT RT_BIT_64(0) /** Request is device readable AND writeable */
80	#define VIRTIO_SCSI_F_HOTPLUG RT_BIT_64(1) /** Host allows hotplugging SCSI LUNs & targets */
81	#define VIRTIO_SCSI_F_CHANGE RT_BIT_64(2) /** Host LUNs chgs via VIRTIOSCSI_T_PARAM_CHANGE evt */
82	#define VIRTIO_SCSI_F_T10_PI RT_BIT_64(3) /** Add T10 port info (DIF/DIX) in SCSI req hdr */
83	/** @} */
84
85
86	#define VIRTIOSCSI_HOST_SCSI_FEATURES_ALL \
87	(VIRTIO_SCSI_F_INOUT \| VIRTIO_SCSI_F_HOTPLUG \| VIRTIO_SCSI_F_CHANGE \| VIRTIO_SCSI_F_T10_PI)
88
89	#define VIRTIOSCSI_HOST_SCSI_FEATURES_NONE 0
90
91	#define VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED VIRTIOSCSI_HOST_SCSI_FEATURES_NONE
92
93	#define VIRTIOSCSI_REQ_VIRTQ_CNT 4 /*< T.B.D. Consider increasing /
94	#define VIRTIOSCSI_VIRTQ_CNT (VIRTIOSCSI_REQ_VIRTQ_CNT + 2)
95	#define VIRTIOSCSI_MAX_TARGETS 256 /*< T.B.D. Figure out a a good value for this. /
96	#define VIRTIOSCSI_MAX_LUN 1 /*< VirtIO specification, section 5.6.4 /
97	#define VIRTIOSCSI_MAX_COMMANDS_PER_LUN 128 /*< T.B.D. What is a good value for this? /
98	#define VIRTIOSCSI_MAX_SEG_COUNT 126 /*< T.B.D. What is a good value for this? /
99	#define VIRTIOSCSI_MAX_SECTORS_HINT 0x10000 /*< VirtIO specification, section 5.6.4 /
100	#define VIRTIOSCSI_MAX_CHANNEL_HINT 0 /*< VirtIO specification, section 5.6.4 should be 0 /
101
102	#define PCI_DEVICE_ID_VIRTIOSCSI_HOST 0x1048 /*< Informs guest driver of type of VirtIO device /
103	#define PCI_CLASS_BASE_MASS_STORAGE 0x01 /*< PCI Mass Storage device class /
104	#define PCI_CLASS_SUB_SCSI_STORAGE_CONTROLLER 0x00 /*< PCI SCSI Controller subclass /
105	#define PCI_CLASS_PROG_UNSPECIFIED 0x00 /*< Programming interface. N/A. /
106	#define VIRTIOSCSI_PCI_CLASS 0x01 /*< Base class Mass Storage? /
107
108	#define VIRTIOSCSI_SENSE_SIZE_DEFAULT 96 /*< VirtIO 1.0: 96 on reset, guest can change /
109	#define VIRTIOSCSI_SENSE_SIZE_MAX 4096 /*< Picked out of thin air by bird. /
110	#define VIRTIOSCSI_CDB_SIZE_DEFAULT 32 /*< VirtIO 1.0: 32 on reset, guest can change /
111	#define VIRTIOSCSI_CDB_SIZE_MAX 255 /*< Picked out of thin air by bird. /
112	#define VIRTIOSCSI_PI_BYTES_IN 1 /*< Value TBD (see section 5.6.6.1) /
113	#define VIRTIOSCSI_PI_BYTES_OUT 1 /*< Value TBD (see section 5.6.6.1) /
114	#define VIRTIOSCSI_DATA_OUT 512 /*< Value TBD (see section 5.6.6.1) /
115
116	/**
117	* VirtIO SCSI Host Device device-specific queue indicies.
118	* (Note: # of request queues is determined by virtio_scsi_config.num_queues. VirtIO 1.0, 5.6.4)
119	*/
120	#define CONTROLQ_IDX 0 /*< VirtIO Spec-defined Index of control queue /
121	#define EVENTQ_IDX 1 /*< VirtIO Spec-defined Index of event queue /
122	#define VIRTQ_REQ_BASE 2 /*< VirtIO Spec-defined base index of req. queues /
123
124	#define VIRTQNAME(uVirtqNbr) (pThis->aszVirtqNames[uVirtqNbr]) /*< Macro to get queue name from its index /
125	#define CBVIRTQNAME(uVirtqNbr) RTStrNLen(VIRTQNAME(uVirtqNbr), sizeof(VIRTQNAME(uVirtqNbr)))
126
127	#define IS_REQ_VIRTQ(uVirtqNbr) (uVirtqNbr >= VIRTQ_REQ_BASE && uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT)
128
129	#define VIRTIO_IS_IN_DIRECTION(pMediaExTxDirEnumValue) \
130	((pMediaExTxDirEnumValue) == PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE)
131
132	#define VIRTIO_IS_OUT_DIRECTION(pMediaExTxDirEnumValue) \
133	((pMediaExTxDirEnumValue) == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE)
134
135	#define IS_VIRTQ_EMPTY(pDevIns, pVirtio, uVirtqNbr) \
136	(virtioCoreVirtqAvailBufCount(pDevIns, pVirtio, uVirtqNbr) == 0)
137
138
139	/*********************************************************************************************************************************
140	* Structures and Typedefs *
141	*********************************************************************************************************************************/
142	/**
143	* VirtIO SCSI Host Device device-specific configuration (see VirtIO 1.0, section 5.6.4)
144	* VBox VirtIO core issues callback to this VirtIO device-specific implementation to handle
145	* MMIO accesses to device-specific configuration parameters.
146	*/
147	typedef struct virtio_scsi_config
148	{
149	uint32_t uNumVirtqs; /*< num_queues \# of req q's exposed by dev /
150	uint32_t uSegMax; /*< seg_max Max \# of segs allowed in cmd /
151	uint32_t uMaxSectors; /*< max_sectors Hint to guest max xfer to use /
152	uint32_t uCmdPerLun; /*< cmd_per_lun Max \# of link cmd sent per lun /
153	uint32_t uEventInfoSize; /*< event_info_size Fill max, evtq bufs /
154	uint32_t uSenseSize; /*< sense_size Max sense data size dev writes /
155	uint32_t uCdbSize; /*< cdb_size Max CDB size driver writes /
156	uint16_t uMaxChannel; /*< max_channel Hint to guest driver /
157	uint16_t uMaxTarget; /*< max_target Hint to guest driver /
158	uint32_t uMaxLun; /*< max_lun Hint to guest driver /
159	} VIRTIOSCSI_CONFIG_T, PVIRTIOSCSI_CONFIG_T;
160
161	/** @name VirtIO 1.0 SCSI Host Device device specific control types
162	* @{ */
163	#define VIRTIOSCSI_T_NO_EVENT 0
164	#define VIRTIOSCSI_T_TRANSPORT_RESET 1
165	#define VIRTIOSCSI_T_ASYNC_NOTIFY 2 /*< Asynchronous notification /
166	#define VIRTIOSCSI_T_PARAM_CHANGE 3
167	/** @} */
168
169	/**
170	* Device operation: eventq
171	*/
172	#define VIRTIOSCSI_T_EVENTS_MISSED UINT32_C(0x80000000)
173	typedef struct virtio_scsi_event
174	{
175	// Device-writable part
176	uint32_t uEvent; /*< event /
177	uint8_t abVirtioLun[8]; /*< lun /
178	uint32_t uReason; /*< reason /
179	} VIRTIOSCSI_EVENT_T, *PVIRTIOSCSI_EVENT_T;
180
181	/** @name VirtIO 1.0 SCSI Host Device device specific event types
182	* @{ */
183	#define VIRTIOSCSI_EVT_RESET_HARD 0 /*< /
184	#define VIRTIOSCSI_EVT_RESET_RESCAN 1 /*< /
185	#define VIRTIOSCSI_EVT_RESET_REMOVED 2 /*< /
186	/** @} */
187
188	/**
189	* Device operation: reqestq
190	*/
191	#pragma pack(1)
192	typedef struct REQ_CMD_HDR_T
193	{
194	uint8_t abVirtioLun[8]; /*< lun /
195	uint64_t uId; /*< id /
196	uint8_t uTaskAttr; /*< task_attr /
197	uint8_t uPrio; /*< prio /
198	uint8_t uCrn; /*< crn /
199	} REQ_CMD_HDR_T;
200	#pragma pack()
201	AssertCompileSize(REQ_CMD_HDR_T, 19);
202
203	typedef struct REQ_CMD_PI_T
204	{
205	uint32_t uPiBytesOut; /*< pi_bytesout /
206	uint32_t uPiBytesIn; /*< pi_bytesin /
207	} REQ_CMD_PI_T;
208	AssertCompileSize(REQ_CMD_PI_T, 8);
209
210	typedef struct REQ_RESP_HDR_T
211	{
212	uint32_t cbSenseLen; /*< sense_len /
213	uint32_t uResidual; /*< residual /
214	uint16_t uStatusQualifier; /*< status_qualifier /
215	uint8_t uStatus; /*< status SCSI status code /
216	uint8_t uResponse; /*< response /
217	} REQ_RESP_HDR_T;
218	AssertCompileSize(REQ_RESP_HDR_T, 12);
219
220	#pragma pack(1)
221	typedef struct VIRTIOSCSI_REQ_CMD_T
222	{
223	/** Device-readable section
224	* @{ */
225	REQ_CMD_HDR_T ReqHdr;
226	uint8_t uCdb[1]; /*< cdb /
227
228	REQ_CMD_PI_T piHdr; /*< T10 Pi block integrity (optional feature) /
229	uint8_t uPiOut[1]; /*< pi_out[] T10 pi block integrity /
230	uint8_t uDataOut[1]; /*< dataout /
231	/** @} */
232
233	/** @name Device writable section
234	* @{ */
235	REQ_RESP_HDR_T respHdr;
236	uint8_t uSense[1]; /*< sense /
237	uint8_t uPiIn[1]; /*< pi_in[] T10 Pi block integrity /
238	uint8_t uDataIn[1]; /*< detain; /
239	/** @} */
240	} VIRTIOSCSI_REQ_CMD_T, *PVIRTIOSCSI_REQ_CMD_T;
241	#pragma pack()
242	AssertCompileSize(VIRTIOSCSI_REQ_CMD_T, 19+8+12+6);
243
244	/** @name VirtIO 1.0 SCSI Host Device Req command-specific response values
245	* @{ */
246	#define VIRTIOSCSI_S_OK 0 /*< control, command /
247	#define VIRTIOSCSI_S_OVERRUN 1 /*< control /
248	#define VIRTIOSCSI_S_ABORTED 2 /*< control /
249	#define VIRTIOSCSI_S_BAD_TARGET 3 /*< control, command /
250	#define VIRTIOSCSI_S_RESET 4 /*< control /
251	#define VIRTIOSCSI_S_BUSY 5 /*< control, command /
252	#define VIRTIOSCSI_S_TRANSPORT_FAILURE 6 /*< control, command /
253	#define VIRTIOSCSI_S_TARGET_FAILURE 7 /*< control, command /
254	#define VIRTIOSCSI_S_NEXUS_FAILURE 8 /*< control, command /
255	#define VIRTIOSCSI_S_FAILURE 9 /*< control, command /
256	#define VIRTIOSCSI_S_INCORRECT_LUN 12 /*< command /
257	/** @} */
258
259	/** @name VirtIO 1.0 SCSI Host Device command-specific task_attr values
260	* @{ */
261	#define VIRTIOSCSI_S_SIMPLE 0 /*< /
262	#define VIRTIOSCSI_S_ORDERED 1 /*< /
263	#define VIRTIOSCSI_S_HEAD 2 /*< /
264	#define VIRTIOSCSI_S_ACA 3 /*< /
265	/** @} */
266
267	/**
268	* VirtIO 1.0 SCSI Host Device Control command before we know type (5.6.6.2)
269	*/
270	typedef struct VIRTIOSCSI_CTRL_T
271	{
272	uint32_t uType;
273	} VIRTIOSCSI_CTRL_T, *PVIRTIOSCSI_CTRL_T;
274
275	/** @name VirtIO 1.0 SCSI Host Device command-specific TMF values
276	* @{ */
277	#define VIRTIOSCSI_T_TMF 0 /*< /
278	#define VIRTIOSCSI_T_TMF_ABORT_TASK 0 /*< /
279	#define VIRTIOSCSI_T_TMF_ABORT_TASK_SET 1 /*< /
280	#define VIRTIOSCSI_T_TMF_CLEAR_ACA 2 /*< /
281	#define VIRTIOSCSI_T_TMF_CLEAR_TASK_SET 3 /*< /
282	#define VIRTIOSCSI_T_TMF_I_T_NEXUS_RESET 4 /*< /
283	#define VIRTIOSCSI_T_TMF_LOGICAL_UNIT_RESET 5 /*< /
284	#define VIRTIOSCSI_T_TMF_QUERY_TASK 6 /*< /
285	#define VIRTIOSCSI_T_TMF_QUERY_TASK_SET 7 /*< /
286	/** @} */
287
288	#pragma pack(1)
289	typedef struct VIRTIOSCSI_CTRL_TMF_T
290	{
291	uint32_t uType; /*< type /
292	uint32_t uSubtype; /*< subtype /
293	uint8_t abScsiLun[8]; /*< lun /
294	uint64_t uId; /*< id /
295	} VIRTIOSCSI_CTRL_TMF_T, *PVIRTIOSCSI_CTRL_TMF_T;
296	#pragma pack()
297	AssertCompileSize(VIRTIOSCSI_CTRL_TMF_T, 24);
298
299	/** VirtIO 1.0 section 5.6.6.2, CTRL TMF response is an 8-bit status */
300
301	/** @name VirtIO 1.0 SCSI Host Device device specific tmf control response values
302	* @{ */
303	#define VIRTIOSCSI_S_FUNCTION_COMPLETE 0 /*< /
304	#define VIRTIOSCSI_S_FUNCTION_SUCCEEDED 10 /*< /
305	#define VIRTIOSCSI_S_FUNCTION_REJECTED 11 /*< /
306	/** @} */
307
308	#define VIRTIOSCSI_T_AN_QUERY 1 /*< Asynchronous notification query /
309	#define VIRTIOSCSI_T_AN_SUBSCRIBE 2 /*< Asynchronous notification subscription /
310
311	#pragma pack(1)
312	typedef struct VIRTIOSCSI_CTRL_AN_T
313	{
314	uint32_t uType; /*< type /
315	uint8_t abScsiLun[8]; /*< lun /
316	uint32_t fEventsRequested; /*< event_requested /
317	} VIRTIOSCSI_CTRL_AN_T, *PVIRTIOSCSI_CTRL_AN_T;
318	#pragma pack()
319	AssertCompileSize(VIRTIOSCSI_CTRL_AN_T, 16);
320
321	/** VirtIO 1.0, Section 5.6.6.2, CTRL AN response is 4-byte evt mask + 8-bit status */
322
323	typedef union VIRTIO_SCSI_CTRL_UNION_T
324	{
325	VIRTIOSCSI_CTRL_T Type;
326	VIRTIOSCSI_CTRL_TMF_T Tmf;
327	VIRTIOSCSI_CTRL_AN_T AsyncNotify;
328	uint8_t ab[24];
329	} VIRTIO_SCSI_CTRL_UNION_T, *PVIRTIO_SCSI_CTRL_UNION_T;
330	AssertCompile(sizeof(VIRTIO_SCSI_CTRL_UNION_T) == 24); /* VIRTIOSCSI_CTRL_T forces 4 byte alignment, the other two are byte packed. */
331
332	/** @name VirtIO 1.0 SCSI Host Device device specific tmf control response values
333	* @{ */
334	#define VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE 2 /*< /
335	#define VIRTIOSCSI_EVT_ASYNC_POWER_MGMT 4 /*< /
336	#define VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST 8 /*< /
337	#define VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE 16 /*< /
338	#define VIRTIOSCSI_EVT_ASYNC_MULTI_HOST 32 /*< /
339	#define VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY 64 /*< /
340	/** @} */
341
342	#define SUBSCRIBABLE_EVENTS \
343	( VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE \
344	\| VIRTIOSCSI_EVT_ASYNC_POWER_MGMT \
345	\| VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST \
346	\| VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE \
347	\| VIRTIOSCSI_EVT_ASYNC_MULTI_HOST \
348	\| VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY )
349
350	#define SUPPORTED_EVENTS 0 /* TBD */
351
352	/**
353	* Worker thread context, shared state.
354	*/
355	typedef struct VIRTIOSCSIWORKER
356	{
357	SUPSEMEVENT hEvtProcess; /*< handle of associated sleep/wake-up semaphore /
358	bool volatile fSleeping; /*< Flags whether worker thread is sleeping or not /
359	bool volatile fNotified; /*< Flags whether worker thread notified /
360	} VIRTIOSCSIWORKER;
361	/** Pointer to a VirtIO SCSI worker. */
362	typedef VIRTIOSCSIWORKER *PVIRTIOSCSIWORKER;
363
364	/**
365	* Worker thread context, ring-3 state.
366	*/
367	typedef struct VIRTIOSCSIWORKERR3
368	{
369	R3PTRTYPE(PPDMTHREAD) pThread; /*< pointer to worker thread's handle /
370	RTCRITSECT CritSectVirtq; /*< Protecting the virtq against concurrent thread access. /
371	uint16_t auRedoDescs[VIRTQ_SIZE]; /*< List of previously suspended reqs to re-submit /
372	uint16_t cRedoDescs; /*< Number of redo desc chain head desc idxes in list /
373	} VIRTIOSCSIWORKERR3;
374	/** Pointer to a VirtIO SCSI worker. */
375	typedef VIRTIOSCSIWORKERR3 *PVIRTIOSCSIWORKERR3;
376
377	/**
378	* State of a target attached to the VirtIO SCSI Host
379	*/
380	typedef struct VIRTIOSCSITARGET
381	{
382	/** The ring-3 device instance so we can easily get our bearings. */
383	PPDMDEVINSR3 pDevIns;
384
385	/** Pointer to attached driver's base interface. */
386	R3PTRTYPE(PPDMIBASE) pDrvBase;
387
388	/** Target number (PDM LUN) */
389	uint32_t uTarget;
390
391	/** Target Description */
392	R3PTRTYPE(char *) pszTargetName;
393
394	/** Target base interface. */
395	PDMIBASE IBase;
396
397	/** Flag whether device is present. */
398	bool fPresent;
399
400	/** Media port interface. */
401	PDMIMEDIAPORT IMediaPort;
402
403	/** Pointer to the attached driver's media interface. */
404	R3PTRTYPE(PPDMIMEDIA) pDrvMedia;
405
406	/** Extended media port interface. */
407	PDMIMEDIAEXPORT IMediaExPort;
408
409	/** Pointer to the attached driver's extended media interface. */
410	R3PTRTYPE(PPDMIMEDIAEX) pDrvMediaEx;
411
412	/** Status LED interface */
413	PDMILEDPORTS ILed;
414
415	/** The status LED state for this device. */
416	PDMLED led;
417
418	} VIRTIOSCSITARGET, *PVIRTIOSCSITARGET;
419
420	/**
421	* VirtIO Host SCSI device state, shared edition.
422	*
423	* @extends VIRTIOCORE
424	*/
425	typedef struct VIRTIOSCSI
426	{
427	/** The core virtio state. */
428	VIRTIOCORE Virtio;
429
430	/** VirtIO Host SCSI device runtime configuration parameters */
431	VIRTIOSCSI_CONFIG_T virtioScsiConfig;
432
433	bool fBootable;
434	bool afPadding0[3];
435
436	/** Number of targets in paTargetInstances. */
437	uint32_t cTargets;
438
439	/** Per device-bound virtq worker-thread contexts (eventq slot unused) */
440	VIRTIOSCSIWORKER aWorkers[VIRTIOSCSI_VIRTQ_CNT];
441
442	/** Instance name */
443	char szInstance[16];
444
445	/** Device-specific spec-based VirtIO VIRTQNAMEs */
446	char aszVirtqNames[VIRTIOSCSI_VIRTQ_CNT][VIRTIO_MAX_VIRTQ_NAME_SIZE];
447
448	/** Track which VirtIO queues we've attached to */
449	bool afVirtqAttached[VIRTIOSCSI_VIRTQ_CNT];
450
451	/** Set if events missed due to lack of bufs avail on eventq */
452	bool fEventsMissed;
453
454	/** Explicit alignment padding. */
455	bool afPadding1[2];
456
457	/** Mask of VirtIO Async Event types this device will deliver */
458	uint32_t fAsyncEvtsEnabled;
459
460	/** Total number of requests active across all targets */
461	volatile uint32_t cActiveReqs;
462
463
464	/** True if the guest/driver and VirtIO framework are in the ready state */
465	uint32_t fVirtioReady;
466
467	/** True if VIRTIO_SCSI_F_T10_PI was negotiated */
468	uint32_t fHasT10pi;
469
470	/** True if VIRTIO_SCSI_F_HOTPLUG was negotiated */
471	uint32_t fHasHotplug;
472
473	/** True if VIRTIO_SCSI_F_INOUT was negotiated */
474	uint32_t fHasInOutBufs;
475
476	/** True if VIRTIO_SCSI_F_CHANGE was negotiated */
477	uint32_t fHasLunChange;
478
479	/** True if in the process of resetting */
480	uint32_t fResetting;
481
482	} VIRTIOSCSI;
483	/** Pointer to the shared state of the VirtIO Host SCSI device. */
484	typedef VIRTIOSCSI *PVIRTIOSCSI;
485
486
487	/**
488	* VirtIO Host SCSI device state, ring-3 edition.
489	*
490	* @extends VIRTIOCORER3
491	*/
492	typedef struct VIRTIOSCSIR3
493	{
494	/** The core virtio ring-3 state. */
495	VIRTIOCORER3 Virtio;
496
497	/** Array of per-target data. */
498	R3PTRTYPE(PVIRTIOSCSITARGET) paTargetInstances;
499
500	/** Per device-bound virtq worker-thread contexts (eventq slot unused) */
501	VIRTIOSCSIWORKERR3 aWorkers[VIRTIOSCSI_VIRTQ_CNT];
502
503	/** Device base interface. */
504	PDMIBASE IBase;
505
506	/** Pointer to the device instance.
507	* @note Only used in interface callbacks. */
508	PPDMDEVINSR3 pDevIns;
509
510	/** Status Target: LEDs port interface. */
511	PDMILEDPORTS ILeds;
512
513	/** IMediaExPort: Media ejection notification */
514	R3PTRTYPE(PPDMIMEDIANOTIFY) pMediaNotify;
515
516	/** Virtq to send tasks to R3. - HC ptr */
517	R3PTRTYPE(PPDMQUEUE) pNotifierVirtqR3;
518
519	/** True if in the process of quiescing I/O */
520	uint32_t fQuiescing;
521
522	/** For which purpose we're quiescing. */
523	VIRTIOVMSTATECHANGED enmQuiescingFor;
524
525	} VIRTIOSCSIR3;
526	/** Pointer to the ring-3 state of the VirtIO Host SCSI device. */
527	typedef VIRTIOSCSIR3 *PVIRTIOSCSIR3;
528
529
530	/**
531	* VirtIO Host SCSI device state, ring-0 edition.
532	*/
533	typedef struct VIRTIOSCSIR0
534	{
535	/** The core virtio ring-0 state. */
536	VIRTIOCORER0 Virtio;
537	} VIRTIOSCSIR0;
538	/** Pointer to the ring-0 state of the VirtIO Host SCSI device. */
539	typedef VIRTIOSCSIR0 *PVIRTIOSCSIR0;
540
541
542	/**
543	* VirtIO Host SCSI device state, raw-mode edition.
544	*/
545	typedef struct VIRTIOSCSIRC
546	{
547	/** The core virtio raw-mode state. */
548	VIRTIOCORERC Virtio;
549	} VIRTIOSCSIRC;
550	/** Pointer to the ring-0 state of the VirtIO Host SCSI device. */
551	typedef VIRTIOSCSIRC *PVIRTIOSCSIRC;
552
553
554	/** @typedef VIRTIOSCSICC
555	* The instance data for the current context. */
556	typedef CTX_SUFF(VIRTIOSCSI) VIRTIOSCSICC;
557	/** @typedef PVIRTIOSCSICC
558	* Pointer to the instance data for the current context. */
559	typedef CTX_SUFF(PVIRTIOSCSI) PVIRTIOSCSICC;
560
561
562	/**
563	* Request structure for IMediaEx (Associated Interfaces implemented by DrvSCSI)
564	* @note cbIn, cbOUt, cbDataOut mostly for debugging
565	*/
566	typedef struct VIRTIOSCSIREQ
567	{
568	PDMMEDIAEXIOREQ hIoReq; /*< Handle of I/O request /
569	PVIRTIOSCSITARGET pTarget; /*< Target /
570	uint16_t uVirtqNbr; /*< Index of queue this request arrived on /
571	PVIRTQBUF pVirtqBuf; /*< Prepared desc chain pulled from virtq avail ring /
572	size_t cbDataIn; /*< size of datain buffer /
573	size_t cbDataOut; /*< size of dataout buffer /
574	uint16_t uDataInOff; /*< Fixed size of respHdr + sense (precede datain) /
575	uint16_t uDataOutOff; /*< Fixed size of reqhdr + cdb (precede dataout) /
576	uint32_t cbSenseAlloc; /*< Size of sense buffer /
577	size_t cbSenseLen; /*< Receives \# bytes written into sense buffer /
578	uint8_t pbSense; /< Pointer to R3 sense buffer /
579	PDMMEDIAEXIOREQSCSITXDIR enmTxDir; /*< Receives transfer direction of I/O req /
580	uint8_t uStatus; /*< SCSI status code /
581	} VIRTIOSCSIREQ;
582	typedef VIRTIOSCSIREQ *PVIRTIOSCSIREQ;
583
584
585	/**
586	* callback_method_impl{VIRTIOCORER0,pfnVirtqNotified}
587	* @todo this causes burn if I prefix with at-sign. This callback is in VIRTIOCORER0 and VIRTIOCORER3
588	*/
589	static DECLCALLBACK(void) virtioScsiNotified(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr)
590	{
591
592	RT_NOREF(pVirtio);
593	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
594
595	AssertReturnVoid(uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT);
596	PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[uVirtqNbr];
597
598	#if defined (IN_RING3) && defined (LOG_ENABLED)
599	RTLogFlush(NULL);
600	#endif
601
602	if (uVirtqNbr == CONTROLQ_IDX \|\| IS_REQ_VIRTQ(uVirtqNbr))
603	{
604	Log6Func(("%s has available data\n", VIRTQNAME(uVirtqNbr)));
605	/* Wake queue's worker thread up if sleeping */
606	if (!ASMAtomicXchgBool(&pWorker->fNotified, true))
607	{
608	if (ASMAtomicReadBool(&pWorker->fSleeping))
609	{
610	Log6Func(("waking %s worker.\n", VIRTQNAME(uVirtqNbr)));
611	int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pWorker->hEvtProcess);
612	AssertRC(rc);
613	}
614	}
615	}
616	else if (uVirtqNbr == EVENTQ_IDX)
617	{
618	Log3Func(("Driver queued buffer(s) to %s\n", VIRTQNAME(uVirtqNbr)));
619	// if (ASMAtomicXchgBool(&pThis->fEventsMissed, false))
620	// virtioScsiR3ReportEventsMissed(pDevIns, pThis, 0);
621	}
622	else
623	LogFunc(("Unexpected queue idx (ignoring): %d\n", uVirtqNbr));
624	}
625
626
627	#ifdef IN_RING3 /* spans most of the file, at the moment. */
628
629
630	DECLINLINE(void) virtioScsiSetVirtqNames(PVIRTIOSCSI pThis)
631	{
632	RTStrCopy(pThis->aszVirtqNames[CONTROLQ_IDX], VIRTIO_MAX_VIRTQ_NAME_SIZE, "controlq");
633	RTStrCopy(pThis->aszVirtqNames[EVENTQ_IDX], VIRTIO_MAX_VIRTQ_NAME_SIZE, "eventq");
634	for (uint16_t uVirtqNbr = VIRTQ_REQ_BASE; uVirtqNbr < VIRTQ_REQ_BASE + VIRTIOSCSI_REQ_VIRTQ_CNT; uVirtqNbr++)
635	RTStrPrintf(pThis->aszVirtqNames[uVirtqNbr], VIRTIO_MAX_VIRTQ_NAME_SIZE,
636	"requestq<%d>", uVirtqNbr - VIRTQ_REQ_BASE);
637	}
638
639	#ifdef LOG_ENABLED
640
641
642	DECLINLINE(const char *) virtioGetTxDirText(uint32_t enmTxDir)
643	{
644	switch (enmTxDir)
645	{
646	case PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN: return "<UNKNOWN>";
647	case PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE: return "<DEV-TO-GUEST>";
648	case PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE: return "<GUEST-TO-DEV>";
649	case PDMMEDIAEXIOREQSCSITXDIR_NONE: return "<NONE>";
650	default: return "<BAD ENUM>";
651	}
652	}
653
654	DECLINLINE(const char *) virtioGetTMFTypeText(uint32_t uSubType)
655	{
656	switch (uSubType)
657	{
658	case VIRTIOSCSI_T_TMF_ABORT_TASK: return "ABORT TASK";
659	case VIRTIOSCSI_T_TMF_ABORT_TASK_SET: return "ABORT TASK SET";
660	case VIRTIOSCSI_T_TMF_CLEAR_ACA: return "CLEAR ACA";
661	case VIRTIOSCSI_T_TMF_CLEAR_TASK_SET: return "CLEAR TASK SET";
662	case VIRTIOSCSI_T_TMF_I_T_NEXUS_RESET: return "I T NEXUS RESET";
663	case VIRTIOSCSI_T_TMF_LOGICAL_UNIT_RESET: return "LOGICAL UNIT RESET";
664	case VIRTIOSCSI_T_TMF_QUERY_TASK: return "QUERY TASK";
665	case VIRTIOSCSI_T_TMF_QUERY_TASK_SET: return "QUERY TASK SET";
666	default: return "<unknown>";
667	}
668	}
669
670	DECLINLINE(const char *) virtioGetReqRespText(uint32_t vboxRc)
671	{
672	switch (vboxRc)
673	{
674	case VIRTIOSCSI_S_OK: return "OK/COMPLETE";
675	case VIRTIOSCSI_S_OVERRUN: return "OVERRRUN";
676	case VIRTIOSCSI_S_ABORTED: return "ABORTED";
677	case VIRTIOSCSI_S_BAD_TARGET: return "BAD TARGET";
678	case VIRTIOSCSI_S_RESET: return "RESET";
679	case VIRTIOSCSI_S_TRANSPORT_FAILURE: return "TRANSPORT FAILURE";
680	case VIRTIOSCSI_S_TARGET_FAILURE: return "TARGET FAILURE";
681	case VIRTIOSCSI_S_NEXUS_FAILURE: return "NEXUS FAILURE";
682	case VIRTIOSCSI_S_BUSY: return "BUSY";
683	case VIRTIOSCSI_S_FAILURE: return "FAILURE";
684	case VIRTIOSCSI_S_INCORRECT_LUN: return "INCORRECT LUN";
685	case VIRTIOSCSI_S_FUNCTION_SUCCEEDED: return "FUNCTION SUCCEEDED";
686	case VIRTIOSCSI_S_FUNCTION_REJECTED: return "FUNCTION REJECTED";
687	default: return "<unknown>";
688	}
689	}
690
691	DECLINLINE(void) virtioGetControlAsyncMaskText(char *pszOutput, uint32_t cbOutput, uint32_t fAsyncTypesMask)
692	{
693	RTStrPrintf(pszOutput, cbOutput, "%s%s%s%s%s%s",
694	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_OPERATIONAL_CHANGE ? "CHANGE_OPERATION " : "",
695	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_POWER_MGMT ? "POWER_MGMT " : "",
696	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_EXTERNAL_REQUEST ? "EXTERNAL_REQ " : "",
697	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE ? "MEDIA_CHANGE " : "",
698	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_MULTI_HOST ? "MULTI_HOST " : "",
699	fAsyncTypesMask & VIRTIOSCSI_EVT_ASYNC_DEVICE_BUSY ? "DEVICE_BUSY " : "");
700	}
701
702	static uint8_t virtioScsiEstimateCdbLen(uint8_t uCmd, uint8_t cbMax)
703	{
704	if (uCmd < 0x1f)
705	return RT_MIN(6, cbMax);
706	if (uCmd >= 0x20 && uCmd < 0x60)
707	return RT_MIN(10, cbMax);
708	if (uCmd >= 0x60 && uCmd < 0x80)
709	return cbMax;
710	if (uCmd >= 0x80 && uCmd < 0xa0)
711	return RT_MIN(16, cbMax);
712	if (uCmd >= 0xa0 && uCmd < 0xc0)
713	return RT_MIN(12, cbMax);
714	return cbMax;
715	}
716
717	#endif /* LOG_ENABLED */
718
719
720	/**
721	* Wrapper around virtioCoreR3VirtqUsedBufPut() and virtioCoreVirtqUsedRingSync() doing some device locking.
722	*
723	* @param pDevIns The PDM device instance.
724	* @param pVirtio Pointer to the shared virtio core structure.
725	* @param uVirtqNbr The virtq number.
726	* @param pSgVirtReturn The S/G buffer to return data from.
727	* @param pVirtqBuf The virtq buffer.
728	*
729	* @note This is a temporary fix, see @bugref{9440#c164} on why it is necessary. Should be moved to VirtioCore or
730	* VirtioCore should be changed to not require locking.
731	*/
732	DECLINLINE(void) virtioScsiR3VirtqUsedBufPutAndSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr, PRTSGBUF pSgVirtReturn,
733	PVIRTQBUF pVirtqBuf)
734	{
735	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
736
737	RTCritSectEnter(&pThisCC->aWorkers[uVirtqNbr].CritSectVirtq);
738	virtioCoreR3VirtqUsedBufPut(pThisCC->pDevIns, pVirtio, uVirtqNbr, pSgVirtReturn, pVirtqBuf, true /* fFence */);
739	virtioCoreVirtqUsedRingSync(pThisCC->pDevIns, pVirtio, uVirtqNbr);
740	RTCritSectLeave(&pThisCC->aWorkers[uVirtqNbr].CritSectVirtq);
741	}
742
743
744	/*
745	* @todo Figure out how to implement this with R0 changes. Not used by current linux driver
746	*/
747
748	#if 0
749	static int virtioScsiR3SendEvent(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget, uint32_t uEventType, uint32_t uReason)
750	{
751	switch (uEventType)
752	{
753	case VIRTIOSCSI_T_NO_EVENT:
754	Log6Func(("(target=%d, LUN=%d): Warning event info guest queued is shorter than configured\n", uTarget, LUN0));
755	break;
756	case VIRTIOSCSI_T_NO_EVENT \| VIRTIOSCSI_T_EVENTS_MISSED:
757	Log6Func(("(target=%d, LUN=%d): Warning driver that events were missed\n", uTarget, LUN0));
758	break;
759	case VIRTIOSCSI_T_TRANSPORT_RESET:
760	switch (uReason)
761	{
762	case VIRTIOSCSI_EVT_RESET_REMOVED:
763	Log6Func(("(target=%d, LUN=%d): Target or LUN removed\n", uTarget, LUN0));
764	break;
765	case VIRTIOSCSI_EVT_RESET_RESCAN:
766	Log6Func(("(target=%d, LUN=%d): Target or LUN added\n", uTarget, LUN0));
767	break;
768	case VIRTIOSCSI_EVT_RESET_HARD:
769	Log6Func(("(target=%d, LUN=%d): Target was reset\n", uTarget, LUN0));
770	break;
771	}
772	break;
773	case VIRTIOSCSI_T_ASYNC_NOTIFY:
774	{
775	#ifdef LOG_ENABLED
776	char szTypeText[128];
777	virtioGetControlAsyncMaskText(szTypeText, sizeof(szTypeText), uReason);
778	Log6Func(("(target=%d, LUN=%d): Delivering subscribed async notification %s\n", uTarget, LUN0, szTypeText));
779	#endif
780	break;
781	}
782	case VIRTIOSCSI_T_PARAM_CHANGE:
783	LogFunc(("(target=%d, LUN=%d): PARAM_CHANGE sense code: 0x%x sense qualifier: 0x%x\n",
784	uTarget, LUN0, uReason & 0xff, (uReason >> 8) & 0xff));
785	break;
786	default:
787	Log6Func(("(target=%d, LUN=%d): Unknown event type: %d, ignoring\n", uTarget, LUN0, uEventType));
788	return VINF_SUCCESS;
789	}
790
791	PVIRTQBUF pVirtqBuf = NULL;
792	int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, EVENTQ_IDX, &pVirtqBuf, true);
793	if (rc == VERR_NOT_AVAILABLE)
794	{
795	LogFunc(("eventq is empty, events missed (driver didn't preload queue)!\n"));
796	ASMAtomicWriteBool(&pThis->fEventsMissed, true);
797	return VINF_SUCCESS;
798	}
799	AssertRCReturn(rc, rc);
800
801	VIRTIOSCSI_EVENT_T Event;
802	Event.uEvent = uEventType;
803	Event.uReason = uReason;
804	Event.abVirtioLun[0] = 1;
805	Event.abVirtioLun[1] = uTarget;
806	Event.abVirtioLun[2] = (LUN0 >> 8) & 0x40;
807	Event.abVirtioLun[3] = LUN0 & 0xff;
808	Event.abVirtioLun[4] = 0;
809	Event.abVirtioLun[5] = 0;
810	Event.abVirtioLun[6] = 0;
811	Event.abVirtioLun[7] = 0;
812
813	RTSGSEG aReqSegs[1];
814	aReqSegs[0].pvSeg = &Event;
815	aReqSegs[0].cbSeg = sizeof(Event);
816
817	RTSGBUF ReqSgBuf;
818	RTSgBufInit(&ReqSgBuf, aReqSegs, RT_ELEMENTS(aReqSegs));
819
820	virtioScsiR3VirtqUsedBufPutAndSync(pDevIns, &pThis->Virtio, EVENTQ_IDX, &ReqSgBuf, pVirtqBuf);
821	virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
822
823	return rc;
824	}
825	#endif
826
827	/**
828	* Releases one reference from the given controller instances active request counter.
829	*
830	* @param pDevIns The device instance.
831	* @param pThis VirtIO SCSI shared instance data.
832	* @param pThisCC VirtIO SCSI ring-3 instance data.
833	*/
834	DECLINLINE(void) virtioScsiR3Release(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC)
835	{
836	Assert(pThis->cActiveReqs);
837
838	if (!ASMAtomicDecU32(&pThis->cActiveReqs) && pThisCC->fQuiescing)
839	PDMDevHlpAsyncNotificationCompleted(pDevIns);
840	}
841
842	/**
843	* Retains one reference for the given controller instances active request counter.
844	*
845	* @param pThis VirtIO SCSI shared instance data.
846	*/
847	DECLINLINE(void) virtioScsiR3Retain(PVIRTIOSCSI pThis)
848	{
849	ASMAtomicIncU32(&pThis->cActiveReqs);
850	}
851
852	/** Internal worker. */
853	static void virtioScsiR3FreeReq(PVIRTIOSCSITARGET pTarget, PVIRTIOSCSIREQ pReq)
854	{
855	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pTarget->pDevIns, PVIRTIOSCSI);
856	RTMemFree(pReq->pbSense);
857	pReq->pbSense = NULL;
858	virtioCoreR3VirtqBufRelease(&pThis->Virtio, pReq->pVirtqBuf);
859	pReq->pVirtqBuf = NULL;
860	pTarget->pDrvMediaEx->pfnIoReqFree(pTarget->pDrvMediaEx, pReq->hIoReq);
861	}
862
863	/**
864	* This is called to complete a request immediately
865	*
866	* @param pDevIns The device instance.
867	* @param pThis VirtIO SCSI shared instance data.
868	* @param uVirtqNbr Virtq index
869	* @param pVirtqBuf Pointer to pre-processed descriptor chain pulled from virtq
870	* @param pRespHdr Response header
871	* @param pbSense Pointer to sense buffer or NULL if none.
872	* @param cbSenseCfg The configured sense buffer size.
873	*
874	* @returns VINF_SUCCESS
875	*/
876	static int virtioScsiR3ReqErr(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uVirtqNbr,
877	PVIRTQBUF pVirtqBuf, REQ_RESP_HDR_T pRespHdr, uint8_t pbSense,
878	size_t cbSenseCfg)
879	{
880	Log2Func((" status: %s response: %s\n",
881	SCSIStatusText(pRespHdr->uStatus), virtioGetReqRespText(pRespHdr->uResponse)));
882
883	RTSGSEG aReqSegs[2];
884
885	/* Segment #1: Response header*/
886	aReqSegs[0].pvSeg = pRespHdr;
887	aReqSegs[0].cbSeg = sizeof(*pRespHdr);
888
889	/* Segment #2: Sense data. */
890	uint8_t abSenseBuf[VIRTIOSCSI_SENSE_SIZE_MAX];
891	AssertCompile(VIRTIOSCSI_SENSE_SIZE_MAX <= 4096);
892	Assert(cbSenseCfg <= sizeof(abSenseBuf));
893
894	RT_ZERO(abSenseBuf);
895	if (pbSense && pRespHdr->cbSenseLen)
896	memcpy(abSenseBuf, pbSense, RT_MIN(pRespHdr->cbSenseLen, sizeof(abSenseBuf)));
897	else
898	pRespHdr->cbSenseLen = 0;
899
900	aReqSegs[1].pvSeg = abSenseBuf;
901	aReqSegs[1].cbSeg = cbSenseCfg;
902
903	/* Init S/G buffer. */
904	RTSGBUF ReqSgBuf;
905	RTSgBufInit(&ReqSgBuf, aReqSegs, RT_ELEMENTS(aReqSegs));
906
907	if (pThis->fResetting)
908	pRespHdr->uResponse = VIRTIOSCSI_S_RESET;
909
910	virtioScsiR3VirtqUsedBufPutAndSync(pDevIns, &pThis->Virtio, uVirtqNbr, &ReqSgBuf, pVirtqBuf);
911	Log2(("---------------------------------------------------------------------------------\n"));
912
913	return VINF_SUCCESS;
914	}
915
916
917	/**
918	* Variant of virtioScsiR3ReqErr that takes four (4) REQ_RESP_HDR_T member
919	* fields rather than a pointer to an initialized structure.
920	*
921	* @param pDevIns The device instance.
922	* @param pThis VirtIO SCSI shared instance data.
923	* @param uVirtqNbr Virtq index
924	* @param pVirtqBuf Pointer to pre-processed descriptor chain pulled from virtq
925	* @param cbResidual The number of residual bytes or something like that.
926	* @param bStatus The SCSI status code.
927	* @param bResponse The virtio SCSI response code.
928	* @param pbSense Pointer to sense buffer or NULL if none.
929	* @param cbSense The number of bytes of sense data. Zero if none.
930	* @param cbSenseCfg The configured sense buffer size.
931	*
932	* @returns VINF_SUCCESS
933	*/
934	static int virtioScsiR3ReqErr4(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uVirtqNbr,
935	PVIRTQBUF pVirtqBuf, size_t cbResidual, uint8_t bStatus, uint8_t bResponse,
936	uint8_t *pbSense, size_t cbSense, size_t cbSenseCfg)
937	{
938	REQ_RESP_HDR_T RespHdr;
939	RespHdr.cbSenseLen = cbSense & UINT32_MAX;
940	RespHdr.uResidual = cbResidual & UINT32_MAX;
941	RespHdr.uStatusQualifier = 0;
942	RespHdr.uStatus = bStatus;
943	RespHdr.uResponse = bResponse;
944
945	return virtioScsiR3ReqErr(pDevIns, pThis, uVirtqNbr, pVirtqBuf, &RespHdr, pbSense, cbSenseCfg);
946	}
947
948	static void virtioScsiR3SenseKeyToVirtioResp(REQ_RESP_HDR_T *respHdr, uint8_t uSenseKey)
949	{
950	switch (uSenseKey)
951	{
952	case SCSI_SENSE_ABORTED_COMMAND:
953	respHdr->uResponse = VIRTIOSCSI_S_ABORTED;
954	break;
955	case SCSI_SENSE_COPY_ABORTED:
956	respHdr->uResponse = VIRTIOSCSI_S_ABORTED;
957	break;
958	case SCSI_SENSE_UNIT_ATTENTION:
959	respHdr->uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
960	break;
961	case SCSI_SENSE_HARDWARE_ERROR:
962	respHdr->uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
963	break;
964	case SCSI_SENSE_NOT_READY:
965	/* Not sure what to return for this. See choices at VirtIO 1.0, 5.6.6.1.1 */
966	respHdr->uResponse = VIRTIOSCSI_S_FAILURE;
967	/* respHdr->uResponse = VIRTIOSCSI_S_BUSY; / / BUSY is VirtIO's 'retryable' response */
968	break;
969	default:
970	respHdr->uResponse = VIRTIOSCSI_S_FAILURE;
971	break;
972	}
973	}
974
975	/**
976	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
977	*/
978	static DECLCALLBACK(int) virtioScsiR3IoReqFinish(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
979	void *pvIoReqAlloc, int rcReq)
980	{
981	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
982	PPDMDEVINS pDevIns = pTarget->pDevIns;
983	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
984	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
985	PPDMIMEDIAEX pIMediaEx = pTarget->pDrvMediaEx;
986	PVIRTIOSCSIREQ pReq = (PVIRTIOSCSIREQ)pvIoReqAlloc;
987
988	size_t cbResidual = 0;
989	int rc = pIMediaEx->pfnIoReqQueryResidual(pIMediaEx, hIoReq, &cbResidual);
990	AssertRC(rc);
991
992	size_t cbXfer = 0;
993	rc = pIMediaEx->pfnIoReqQueryXferSize(pIMediaEx, hIoReq, &cbXfer);
994	AssertRC(rc);
995
996	/* Masking deals with data type size discrepancies between
997	* The APIs (virtio and VBox). Windows C-compiler complains otherwise */
998	Assert(!(cbXfer & 0xffffffff00000000));
999	uint32_t cbXfer32 = cbXfer & 0xffffffff;
1000	REQ_RESP_HDR_T respHdr = { 0 };
1001	respHdr.cbSenseLen = pReq->pbSense[2] == SCSI_SENSE_NONE ? 0 : (uint32_t)pReq->cbSenseLen;
1002	AssertMsg(!(cbResidual & 0xffffffff00000000),
1003	("WARNING: Residual size larger than sizeof(uint32_t), truncating"));
1004	respHdr.uResidual = (uint32_t)(cbResidual & 0xffffffff);
1005	respHdr.uStatus = pReq->uStatus;
1006
1007	/* VirtIO 1.0 spec 5.6.6.1.1 says device MUST return a VirtIO response byte value.
1008	* Some are returned during the submit phase, and a few are not mapped at all,
1009	* wherein anything that can't map specifically gets mapped to VIRTIOSCSI_S_FAILURE
1010	*/
1011	if (pThis->fResetting)
1012	respHdr.uResponse = VIRTIOSCSI_S_RESET;
1013	else
1014	{
1015	switch (rcReq)
1016	{
1017	case SCSI_STATUS_OK:
1018	{
1019	if (pReq->uStatus != SCSI_STATUS_CHECK_CONDITION)
1020	respHdr.uResponse = VIRTIOSCSI_S_OK;
1021	else
1022	virtioScsiR3SenseKeyToVirtioResp(&respHdr, pReq->pbSense[2]);
1023	break;
1024	}
1025	case SCSI_STATUS_CHECK_CONDITION:
1026	virtioScsiR3SenseKeyToVirtioResp(&respHdr, pReq->pbSense[2]);
1027	break;
1028
1029	default:
1030	respHdr.uResponse = VIRTIOSCSI_S_FAILURE;
1031	break;
1032	}
1033	}
1034
1035	Log2Func(("status: (%d) %s, response: (%d) %s\n", pReq->uStatus, SCSIStatusText(pReq->uStatus),
1036	respHdr.uResponse, virtioGetReqRespText(respHdr.uResponse)));
1037
1038	if (RT_FAILURE(rcReq))
1039	Log2Func(("rcReq: %Rrc\n", rcReq));
1040
1041	if (LogIs3Enabled())
1042	{
1043	LogFunc(("cbDataIn = %u, cbDataOut = %u (cbIn = %u, cbOut = %u)\n",
1044	pReq->cbDataIn, pReq->cbDataOut, pReq->pVirtqBuf->cbPhysReturn, pReq->pVirtqBuf->cbPhysSend));
1045	LogFunc(("xfer = %lu, residual = %u\n", cbXfer, cbResidual));
1046	LogFunc(("xfer direction: %s, sense written = %d, sense size = %d\n",
1047	virtioGetTxDirText(pReq->enmTxDir), respHdr.cbSenseLen, pThis->virtioScsiConfig.uSenseSize));
1048	}
1049
1050	if (respHdr.cbSenseLen && LogIs2Enabled())
1051	{
1052	LogFunc(("Sense: %s\n", SCSISenseText(pReq->pbSense[2])));
1053	LogFunc(("Sense Ext3: %s\n", SCSISenseExtText(pReq->pbSense[12], pReq->pbSense[13])));
1054	}
1055
1056	if ( (VIRTIO_IS_IN_DIRECTION(pReq->enmTxDir) && cbXfer32 > pReq->cbDataIn)
1057	\|\| (VIRTIO_IS_OUT_DIRECTION(pReq->enmTxDir) && cbXfer32 > pReq->cbDataOut))
1058	{
1059	Log2Func((" * * * * Data overrun, returning sense\n"));
1060	uint8_t abSense[] = { RT_BIT(7) \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
1061	0, SCSI_SENSE_ILLEGAL_REQUEST, 0, 0, 0, 0, 10, 0, 0, 0 };
1062	respHdr.cbSenseLen = sizeof(abSense);
1063	respHdr.uStatus = SCSI_STATUS_CHECK_CONDITION;
1064	respHdr.uResponse = VIRTIOSCSI_S_OVERRUN;
1065	respHdr.uResidual = pReq->cbDataIn & UINT32_MAX;
1066
1067	virtioScsiR3ReqErr(pDevIns, pThis, pReq->uVirtqNbr, pReq->pVirtqBuf, &respHdr, abSense,
1068	RT_MIN(pThis->virtioScsiConfig.uSenseSize, VIRTIOSCSI_SENSE_SIZE_MAX));
1069	}
1070	else
1071	{
1072	Assert(pReq->pbSense != NULL);
1073
1074	/* req datain bytes already in guest phys mem. via virtioScsiIoReqCopyFromBuf() */
1075	RTSGSEG aReqSegs[2];
1076
1077	aReqSegs[0].pvSeg = &respHdr;
1078	aReqSegs[0].cbSeg = sizeof(respHdr);
1079
1080	aReqSegs[1].pvSeg = pReq->pbSense;
1081	aReqSegs[1].cbSeg = pReq->cbSenseAlloc; /* VirtIO 1.0 spec 5.6.4/5.6.6.1 */
1082
1083	RTSGBUF ReqSgBuf;
1084	RTSgBufInit(&ReqSgBuf, aReqSegs, RT_ELEMENTS(aReqSegs));
1085
1086	size_t cbReqSgBuf = RTSgBufCalcTotalLength(&ReqSgBuf);
1087	/** @todo r=bird: Returning here looks a little bogus... */
1088	AssertMsgReturn(cbReqSgBuf <= pReq->pVirtqBuf->cbPhysReturn,
1089	("Guest expected less req data (space needed: %zu, avail: %u)\n",
1090	cbReqSgBuf, pReq->pVirtqBuf->cbPhysReturn),
1091	VERR_BUFFER_OVERFLOW);
1092
1093	virtioScsiR3VirtqUsedBufPutAndSync(pDevIns, &pThis->Virtio, pReq->uVirtqNbr, &ReqSgBuf, pReq->pVirtqBuf);
1094	Log2(("-----------------------------------------------------------------------------------------\n"));
1095	}
1096
1097	virtioScsiR3FreeReq(pTarget, pReq);
1098	virtioScsiR3Release(pDevIns, pThis, pThisCC);
1099	return rc;
1100	}
1101
1102	/**
1103	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
1104
1105	* Copy virtual memory from VSCSI layer to guest physical memory
1106	*/
1107	static DECLCALLBACK(int) virtioScsiR3IoReqCopyFromBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1108	void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf, size_t cbCopy)
1109	{
1110	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
1111	PPDMDEVINS pDevIns = pTarget->pDevIns;
1112	PVIRTIOSCSIREQ pReq = (PVIRTIOSCSIREQ)pvIoReqAlloc;
1113	RT_NOREF(hIoReq, cbCopy);
1114
1115	if (!pReq->cbDataIn)
1116	return VINF_SUCCESS;
1117
1118	AssertReturn(pReq->pVirtqBuf, VERR_INVALID_PARAMETER);
1119
1120	PVIRTIOSGBUF pSgPhysReturn = pReq->pVirtqBuf->pSgPhysReturn;
1121	virtioCoreGCPhysChainAdvance(pSgPhysReturn, offDst);
1122
1123	size_t cbCopied = 0;
1124	size_t cbRemain = pReq->cbDataIn;
1125
1126	/* Skip past the REQ_RESP_HDR_T and sense code if we're at the start of the buffer. */
1127	if (!pSgPhysReturn->idxSeg && pSgPhysReturn->cbSegLeft == pSgPhysReturn->paSegs[0].cbSeg)
1128	virtioCoreGCPhysChainAdvance(pSgPhysReturn, pReq->uDataInOff);
1129
1130	while (cbRemain)
1131	{
1132	cbCopied = RT_MIN(pSgBuf->cbSegLeft, pSgPhysReturn->cbSegLeft);
1133	Assert(cbCopied > 0);
1134	PDMDevHlpPCIPhysWriteUser(pDevIns, pSgPhysReturn->GCPhysCur, pSgBuf->pvSegCur, cbCopied);
1135	RTSgBufAdvance(pSgBuf, cbCopied);
1136	virtioCoreGCPhysChainAdvance(pSgPhysReturn, cbCopied);
1137	cbRemain -= cbCopied;
1138	}
1139	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE(); /* needed? */
1140
1141	Log3Func((".... Copied %lu bytes from %lu byte guest buffer, residual=%lu\n",
1142	cbCopy, pReq->pVirtqBuf->cbPhysReturn, pReq->pVirtqBuf->cbPhysReturn - cbCopy));
1143
1144	return VINF_SUCCESS;
1145	}
1146
1147	/**
1148	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyToBuf}
1149	*
1150	* Copy guest physical memory to VSCSI layer virtual memory
1151	*/
1152	static DECLCALLBACK(int) virtioScsiR3IoReqCopyToBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1153	void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf, size_t cbCopy)
1154	{
1155	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
1156	PPDMDEVINS pDevIns = pTarget->pDevIns;
1157	PVIRTIOSCSIREQ pReq = (PVIRTIOSCSIREQ)pvIoReqAlloc;
1158	RT_NOREF(hIoReq, cbCopy);
1159
1160	if (!pReq->cbDataOut)
1161	return VINF_SUCCESS;
1162
1163	PVIRTIOSGBUF pSgPhysSend = pReq->pVirtqBuf->pSgPhysSend;
1164	virtioCoreGCPhysChainAdvance(pSgPhysSend, offSrc);
1165
1166	size_t cbCopied = 0;
1167	size_t cbRemain = pReq->cbDataOut;
1168	while (cbRemain)
1169	{
1170	cbCopied = RT_MIN(pSgBuf->cbSegLeft, pSgPhysSend->cbSegLeft);
1171	Assert(cbCopied > 0);
1172	PDMDevHlpPCIPhysReadUser(pDevIns, pSgPhysSend->GCPhysCur, pSgBuf->pvSegCur, cbCopied);
1173	RTSgBufAdvance(pSgBuf, cbCopied);
1174	virtioCoreGCPhysChainAdvance(pSgPhysSend, cbCopied);
1175	cbRemain -= cbCopied;
1176	}
1177
1178	Log2Func((".... Copied %lu bytes to %lu byte guest buffer, residual=%lu\n",
1179	cbCopy, pReq->pVirtqBuf->cbPhysReturn, pReq->pVirtqBuf->cbPhysReturn - cbCopy));
1180
1181	return VINF_SUCCESS;
1182	}
1183
1184	/**
1185	* Handles request queues for/on a worker thread.
1186	*
1187	* @returns VBox status code (logged by caller).
1188	*/
1189	static int virtioScsiR3ReqSubmit(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
1190	uint16_t uVirtqNbr, PVIRTQBUF pVirtqBuf)
1191	{
1192	/*
1193	* Validate configuration values we use here before we start.
1194	*/
1195	uint32_t const cbCdb = pThis->virtioScsiConfig.uCdbSize;
1196	uint32_t const cbSenseCfg = pThis->virtioScsiConfig.uSenseSize;
1197	/** @todo Report these as errors to the guest or does the caller do that? */
1198	ASSERT_GUEST_LOGREL_MSG_RETURN(cbCdb <= VIRTIOSCSI_CDB_SIZE_MAX, ("cbCdb=%#x\n", cbCdb), VERR_OUT_OF_RANGE);
1199	ASSERT_GUEST_LOGREL_MSG_RETURN(cbSenseCfg <= VIRTIOSCSI_SENSE_SIZE_MAX, ("cbSenseCfg=%#x\n", cbSenseCfg), VERR_OUT_OF_RANGE);
1200
1201	/*
1202	* Extract command header and CDB from guest physical memory
1203	* The max size is rather small here (19 + 255 = 274), so put
1204	* it on the stack.
1205	*/
1206	size_t const cbReqHdr = sizeof(REQ_CMD_HDR_T) + cbCdb;
1207	AssertReturn(pVirtqBuf && pVirtqBuf->cbPhysSend >= cbReqHdr, VERR_INVALID_PARAMETER);
1208
1209	AssertCompile(VIRTIOSCSI_CDB_SIZE_MAX < 4096);
1210	union
1211	{
1212	RT_GCC_EXTENSION struct
1213	{
1214	REQ_CMD_HDR_T ReqHdr;
1215	uint8_t abCdb[VIRTIOSCSI_CDB_SIZE_MAX];
1216	} ;
1217	uint8_t ab[sizeof(REQ_CMD_HDR_T) + VIRTIOSCSI_CDB_SIZE_MAX];
1218	uint64_t au64Align[(sizeof(REQ_CMD_HDR_T) + VIRTIOSCSI_CDB_SIZE_MAX) / sizeof(uint64_t)];
1219	} VirtqReq;
1220	RT_ZERO(VirtqReq);
1221
1222	for (size_t offReq = 0; offReq < cbReqHdr; )
1223	{
1224	size_t cbSeg = cbReqHdr - offReq;
1225	RTGCPHYS GCPhys = virtioCoreGCPhysChainGetNextSeg(pVirtqBuf->pSgPhysSend, &cbSeg);
1226	PDMDevHlpPCIPhysReadMeta(pDevIns, GCPhys, &VirtqReq.ab[offReq], cbSeg);
1227	offReq += cbSeg;
1228	}
1229
1230	uint8_t const uType = VirtqReq.ReqHdr.abVirtioLun[0];
1231	uint8_t const uTarget = VirtqReq.ReqHdr.abVirtioLun[1];
1232	uint32_t uScsiLun = RT_MAKE_U16(VirtqReq.ReqHdr.abVirtioLun[3], VirtqReq.ReqHdr.abVirtioLun[2]) & 0x3fff;
1233
1234	bool fBadLUNFormat = false;
1235	if (uType == 0xc1 && uTarget == 0x01)
1236	{
1237	LogRel(("* * * WARNING: REPORT LUNS LU ACCESSED. FEATURE NOT IMPLEMENTED SEE DevVirtioScsi.cpp * * * "));
1238	/* Force rejection. / /* @todo figure out right way to handle. Note this is a very
1239	* vague and confusing part of the VirtIO spec (which deviates from the SCSI standard).
1240	* I have not been able to determine how to implement this properly. I've checked the
1241	* source code of Guest drivers, and so far none seem to use it. If this message is logged,
1242	* meaning a guest expects this feature, implementing it can be re-visited */
1243	uScsiLun = 0xff;
1244	}
1245	else
1246	if (uType != 1)
1247	fBadLUNFormat = true;
1248
1249	LogFunc(("[%s] (Target: %d LUN: %d) CDB: %.*Rhxs\n",
1250	SCSICmdText(VirtqReq.abCdb[0]), uTarget, uScsiLun,
1251	virtioScsiEstimateCdbLen(VirtqReq.abCdb[0], cbCdb), &VirtqReq.abCdb[0]));
1252
1253	Log3Func(("cmd id: %RX64, attr: %x, prio: %d, crn: %x\n",
1254	VirtqReq.ReqHdr.uId, VirtqReq.ReqHdr.uTaskAttr, VirtqReq.ReqHdr.uPrio, VirtqReq.ReqHdr.uCrn));
1255
1256	/*
1257	* Calculate request offsets and data sizes.
1258	*/
1259	uint32_t const offDataOut = sizeof(REQ_CMD_HDR_T) + cbCdb;
1260	uint32_t const offDataIn = sizeof(REQ_RESP_HDR_T) + cbSenseCfg;
1261	size_t const cbDataOut = pVirtqBuf->cbPhysSend - offDataOut;
1262	/** @todo r=bird: Validate cbPhysReturn properly? I've just RT_MAX'ed it for now. */
1263	size_t const cbDataIn = RT_MAX(pVirtqBuf->cbPhysReturn, offDataIn) - offDataIn;
1264	Assert(offDataOut <= UINT16_MAX);
1265	Assert(offDataIn <= UINT16_MAX);
1266
1267	/*
1268	* Handle submission errors
1269	*/
1270	if (RT_LIKELY(!fBadLUNFormat))
1271	{ /* likely */ }
1272	else
1273	{
1274	Log2Func(("Error submitting request, bad LUN format\n"));
1275	return virtioScsiR3ReqErr4(pDevIns, pThis, uVirtqNbr, pVirtqBuf, cbDataIn + cbDataOut, 0 /bStatus/,
1276	VIRTIOSCSI_S_FAILURE, NULL /pbSense/, 0 /cbSense/, cbSenseCfg);
1277	}
1278
1279	PVIRTIOSCSITARGET const pTarget = &pThisCC->paTargetInstances[uTarget];
1280	if (RT_LIKELY( uTarget < pThis->cTargets
1281	&& pTarget->fPresent
1282	&& pTarget->pDrvMediaEx))
1283	{ /* likely */ }
1284	else
1285	{
1286	Log2Func(("Error submitting request to bad target (%d) or bad LUN (%d)\n", uTarget, uScsiLun));
1287	uint8_t abSense[] = { RT_BIT(7) \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
1288	0, SCSI_SENSE_ILLEGAL_REQUEST,
1289	0, 0, 0, 0, 10, SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED, 0, 0 };
1290	return virtioScsiR3ReqErr4(pDevIns, pThis, uVirtqNbr, pVirtqBuf, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
1291	VIRTIOSCSI_S_BAD_TARGET, abSense, sizeof(abSense), cbSenseCfg);
1292	}
1293	if (RT_LIKELY(uScsiLun == 0))
1294	{ /* likely */ }
1295	else
1296	{
1297	Log2Func(("Error submitting request to bad target (%d) or bad LUN (%d)\n", uTarget, uScsiLun));
1298	uint8_t abSense[] = { RT_BIT(7) \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
1299	0, SCSI_SENSE_ILLEGAL_REQUEST,
1300	0, 0, 0, 0, 10, SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED, 0, 0 };
1301	return virtioScsiR3ReqErr4(pDevIns, pThis, uVirtqNbr, pVirtqBuf, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
1302	VIRTIOSCSI_S_OK, abSense, sizeof(abSense), cbSenseCfg);
1303	}
1304	if (RT_LIKELY(!pThis->fResetting))
1305	{ /* likely */ }
1306	else
1307	{
1308	Log2Func(("Aborting req submission because reset is in progress\n"));
1309	return virtioScsiR3ReqErr4(pDevIns, pThis, uVirtqNbr, pVirtqBuf, cbDataIn + cbDataOut, SCSI_STATUS_OK,
1310	VIRTIOSCSI_S_RESET, NULL /pbSense/, 0 /cbSense/, cbSenseCfg);
1311	}
1312
1313	#if 0
1314	if (RT_LIKELY(!cbDataIn \|\| !cbDataOut \|\| pThis->fHasInOutBufs)) /* VirtIO 1.0, 5.6.6.1.1 */
1315	{ /* likely */ }
1316	else
1317	{
1318	Log2Func(("Error submitting request, got datain & dataout bufs w/o INOUT feature negotated\n"));
1319	uint8_t abSense[] = { RT_BIT(7) \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
1320	0, SCSI_SENSE_ILLEGAL_REQUEST, 0, 0, 0, 0, 10, 0, 0, 0 };
1321	return virtioScsiR3ReqErr4(pDevIns, pThis, uVirtqNbr, pVirtqBuf, cbDataIn + cbDataOut, SCSI_STATUS_CHECK_CONDITION,
1322	VIRTIOSCSI_S_FAILURE, abSense, sizeof(abSense), cbSenseCfg);
1323	}
1324	#endif
1325	/*
1326	* Have underlying driver allocate a req of size set during initialization of this device.
1327	*/
1328	virtioScsiR3Retain(pThis);
1329
1330	PDMMEDIAEXIOREQ hIoReq = NULL;
1331	PVIRTIOSCSIREQ pReq = NULL;
1332	PPDMIMEDIAEX pIMediaEx = pTarget->pDrvMediaEx;
1333
1334	int rc = pIMediaEx->pfnIoReqAlloc(pIMediaEx, &hIoReq, (void *)&pReq, 0 / uIoReqId */,
1335	PDMIMEDIAEX_F_SUSPEND_ON_RECOVERABLE_ERR);
1336
1337	if (RT_FAILURE(rc))
1338	{
1339	virtioScsiR3Release(pDevIns, pThis, pThisCC);
1340	return rc;
1341	}
1342
1343	pReq->hIoReq = hIoReq;
1344	pReq->pTarget = pTarget;
1345	pReq->uVirtqNbr = uVirtqNbr;
1346	pReq->cbDataIn = cbDataIn;
1347	pReq->cbDataOut = cbDataOut;
1348	pReq->pVirtqBuf = pVirtqBuf;
1349	virtioCoreR3VirtqBufRetain(pVirtqBuf); /* (For pReq->pVirtqBuf. Released by virtioScsiR3FreeReq.) */
1350	pReq->uDataInOff = offDataIn;
1351	pReq->uDataOutOff = offDataOut;
1352
1353	pReq->cbSenseAlloc = cbSenseCfg;
1354	pReq->pbSense = (uint8_t *)RTMemAllocZ(pReq->cbSenseAlloc);
1355	AssertMsgReturnStmt(pReq->pbSense, ("Out of memory allocating sense buffer"),
1356	virtioScsiR3FreeReq(pTarget, pReq);, VERR_NO_MEMORY);
1357
1358	/* Note: DrvSCSI allocates one virtual memory buffer for input and output phases of the request */
1359	rc = pIMediaEx->pfnIoReqSendScsiCmd(pIMediaEx, pReq->hIoReq, uScsiLun,
1360	&VirtqReq.abCdb[0], cbCdb,
1361	PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, &pReq->enmTxDir,
1362	RT_MAX(cbDataIn, cbDataOut),
1363	pReq->pbSense, pReq->cbSenseAlloc, &pReq->cbSenseLen,
1364	&pReq->uStatus, RT_MS_30SEC);
1365
1366	if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
1367	{
1368	/*
1369	* Getting here means the request failed in early in the submission to the lower level driver,
1370	* and there will be no callback to the finished/completion function for this request
1371	*/
1372	Assert(RT_FAILURE_NP(rc));
1373	Log2Func(("Request-submission error from lower-level driver\n"));
1374	uint8_t uASC, uASCQ = 0;
1375	switch (rc)
1376	{
1377	case VERR_NO_MEMORY:
1378	uASC = SCSI_ASC_SYSTEM_RESOURCE_FAILURE;
1379	break;
1380	default:
1381	uASC = SCSI_ASC_INTERNAL_TARGET_FAILURE;
1382	break;
1383	}
1384	uint8_t abSense[] = { RT_BIT(7) \| SCSI_SENSE_RESPONSE_CODE_CURR_FIXED,
1385	0, SCSI_SENSE_VENDOR_SPECIFIC,
1386	0, 0, 0, 0, 10, uASC, uASCQ, 0 };
1387	REQ_RESP_HDR_T respHdr = { 0 };
1388	respHdr.cbSenseLen = sizeof(abSense);
1389	respHdr.uStatus = SCSI_STATUS_CHECK_CONDITION;
1390	respHdr.uResponse = VIRTIOSCSI_S_FAILURE;
1391	respHdr.uResidual = (cbDataIn + cbDataOut) & UINT32_MAX;
1392	virtioScsiR3ReqErr(pDevIns, pThis, uVirtqNbr, pVirtqBuf, &respHdr, abSense, cbSenseCfg);
1393	virtioScsiR3FreeReq(pTarget, pReq);
1394	virtioScsiR3Release(pDevIns, pThis, pThisCC);
1395	}
1396	return VINF_SUCCESS;
1397	}
1398
1399	/**
1400	* Handles control transfers for/on a worker thread.
1401	*
1402	* @returns VBox status code (ignored by the caller).
1403	* @param pDevIns The device instance.
1404	* @param pThis VirtIO SCSI shared instance data.
1405	* @param pThisCC VirtIO SCSI ring-3 instance data.
1406	* @param uVirtqNbr CONTROLQ_IDX
1407	* @param pVirtqBuf Descriptor chain to process.
1408	*/
1409	static int virtioScsiR3Ctrl(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, PVIRTIOSCSICC pThisCC,
1410	uint16_t uVirtqNbr, PVIRTQBUF pVirtqBuf)
1411	{
1412	AssertReturn(pVirtqBuf->cbPhysSend >= RT_MIN(sizeof(VIRTIOSCSI_CTRL_AN_T),
1413	sizeof(VIRTIOSCSI_CTRL_TMF_T)), 0);
1414
1415	/*
1416	* Allocate buffer and read in the control command
1417	*/
1418	VIRTIO_SCSI_CTRL_UNION_T ScsiCtrlUnion;
1419	RT_ZERO(ScsiCtrlUnion);
1420
1421	size_t const cb = RT_MIN(pVirtqBuf->cbPhysSend, sizeof(VIRTIO_SCSI_CTRL_UNION_T));
1422	for (size_t uOffset = 0; uOffset < cb; )
1423	{
1424	size_t cbSeg = cb - uOffset;
1425	RTGCPHYS GCPhys = virtioCoreGCPhysChainGetNextSeg(pVirtqBuf->pSgPhysSend, &cbSeg);
1426	PDMDevHlpPCIPhysReadMeta(pDevIns, GCPhys, &ScsiCtrlUnion.ab[uOffset], cbSeg);
1427	uOffset += cbSeg;
1428	}
1429
1430	AssertReturn( (ScsiCtrlUnion.Type.uType == VIRTIOSCSI_T_TMF
1431	&& pVirtqBuf->cbPhysSend >= sizeof(VIRTIOSCSI_CTRL_TMF_T))
1432	\|\| ( ( ScsiCtrlUnion.Type.uType == VIRTIOSCSI_T_AN_QUERY
1433	\|\| ScsiCtrlUnion.Type.uType == VIRTIOSCSI_T_AN_SUBSCRIBE)
1434	&& pVirtqBuf->cbPhysSend >= sizeof(VIRTIOSCSI_CTRL_AN_T)),
1435	0 /** @todo r=bird: what kind of status is '0' here? */);
1436
1437	union
1438	{
1439	uint32_t fSupportedEvents;
1440	} uData;
1441	uint8_t bResponse = VIRTIOSCSI_S_OK;
1442	uint8_t cSegs;
1443	RTSGSEG aReqSegs[2];
1444	switch (ScsiCtrlUnion.Type.uType)
1445	{
1446	case VIRTIOSCSI_T_TMF: /* Task Management Functions */
1447	{
1448	uint8_t uTarget = ScsiCtrlUnion.Tmf.abScsiLun[1];
1449	uint32_t uScsiLun = RT_MAKE_U16(ScsiCtrlUnion.Tmf.abScsiLun[3], ScsiCtrlUnion.Tmf.abScsiLun[2]) & 0x3fff;
1450	Log2Func(("[%s] (Target: %d LUN: %d) Task Mgt Function: %s\n",
1451	VIRTQNAME(uVirtqNbr), uTarget, uScsiLun, virtioGetTMFTypeText(ScsiCtrlUnion.Tmf.uSubtype)));
1452
1453	if (uTarget >= pThis->cTargets \|\| !pThisCC->paTargetInstances[uTarget].fPresent)
1454	bResponse = VIRTIOSCSI_S_BAD_TARGET;
1455	else
1456	if (uScsiLun != 0)
1457	bResponse = VIRTIOSCSI_S_INCORRECT_LUN;
1458	else
1459	switch (ScsiCtrlUnion.Tmf.uSubtype)
1460	{
1461	case VIRTIOSCSI_T_TMF_ABORT_TASK:
1462	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1463	break;
1464	case VIRTIOSCSI_T_TMF_ABORT_TASK_SET:
1465	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1466	break;
1467	case VIRTIOSCSI_T_TMF_CLEAR_ACA:
1468	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1469	break;
1470	case VIRTIOSCSI_T_TMF_CLEAR_TASK_SET:
1471	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1472	break;
1473	case VIRTIOSCSI_T_TMF_I_T_NEXUS_RESET:
1474	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1475	break;
1476	case VIRTIOSCSI_T_TMF_LOGICAL_UNIT_RESET:
1477	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
1478	break;
1479	case VIRTIOSCSI_T_TMF_QUERY_TASK:
1480	bResponse = VIRTIOSCSI_S_FUNCTION_REJECTED;
1481	break;
1482	case VIRTIOSCSI_T_TMF_QUERY_TASK_SET:
1483	bResponse = VIRTIOSCSI_S_FUNCTION_REJECTED;
1484	break;
1485	default:
1486	LogFunc(("Unknown TMF type\n"));
1487	bResponse = VIRTIOSCSI_S_FAILURE;
1488	}
1489	cSegs = 0; /* only bResponse */
1490	break;
1491	}
1492	case VIRTIOSCSI_T_AN_QUERY: /* Guest SCSI driver is querying supported async event notifications */
1493	{
1494	uint8_t uTarget = ScsiCtrlUnion.AsyncNotify.abScsiLun[1];
1495	uint32_t uScsiLun = RT_MAKE_U16(ScsiCtrlUnion.AsyncNotify.abScsiLun[3],
1496	ScsiCtrlUnion.AsyncNotify.abScsiLun[2]) & 0x3fff;
1497
1498	if (uTarget >= pThis->cTargets \|\| !pThisCC->paTargetInstances[uTarget].fPresent)
1499	bResponse = VIRTIOSCSI_S_BAD_TARGET;
1500	else
1501	if (uScsiLun != 0)
1502	bResponse = VIRTIOSCSI_S_INCORRECT_LUN;
1503	else
1504	bResponse = VIRTIOSCSI_S_FUNCTION_COMPLETE;
1505
1506	#ifdef LOG_ENABLED
1507	if (LogIs2Enabled())
1508	{
1509	char szTypeText[128];
1510	virtioGetControlAsyncMaskText(szTypeText, sizeof(szTypeText), ScsiCtrlUnion.AsyncNotify.fEventsRequested);
1511	Log2Func(("[%s] (Target: %d LUN: %d) Async. Notification Query: %s\n",
1512	VIRTQNAME(uVirtqNbr), uTarget, uScsiLun, szTypeText));
1513	}
1514	#endif
1515	uData.fSupportedEvents = SUPPORTED_EVENTS;
1516	aReqSegs[0].pvSeg = &uData.fSupportedEvents;
1517	aReqSegs[0].cbSeg = sizeof(uData.fSupportedEvents);
1518	cSegs = 1;
1519	break;
1520	}
1521	case VIRTIOSCSI_T_AN_SUBSCRIBE: /* Guest SCSI driver is subscribing to async event notification(s) */
1522	{
1523	if (ScsiCtrlUnion.AsyncNotify.fEventsRequested & ~SUBSCRIBABLE_EVENTS)
1524	LogFunc(("Unsupported bits in event subscription event mask: %#x\n",
1525	ScsiCtrlUnion.AsyncNotify.fEventsRequested));
1526
1527	uint8_t uTarget = ScsiCtrlUnion.AsyncNotify.abScsiLun[1];
1528	uint32_t uScsiLun = RT_MAKE_U16(ScsiCtrlUnion.AsyncNotify.abScsiLun[3],
1529	ScsiCtrlUnion.AsyncNotify.abScsiLun[2]) & 0x3fff;
1530
1531	#ifdef LOG_ENABLED
1532	if (LogIs2Enabled())
1533	{
1534	char szTypeText[128];
1535	virtioGetControlAsyncMaskText(szTypeText, sizeof(szTypeText), ScsiCtrlUnion.AsyncNotify.fEventsRequested);
1536	Log2Func(("[%s] (Target: %d LUN: %d) Async. Notification Subscribe: %s\n",
1537	VIRTQNAME(uVirtqNbr), uTarget, uScsiLun, szTypeText));
1538	}
1539	#endif
1540	if (uTarget >= pThis->cTargets \|\| !pThisCC->paTargetInstances[uTarget].fPresent)
1541	bResponse = VIRTIOSCSI_S_BAD_TARGET;
1542	else
1543	if (uScsiLun != 0)
1544	bResponse = VIRTIOSCSI_S_INCORRECT_LUN;
1545	else
1546	{
1547	bResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED; /* or VIRTIOSCSI_S_FUNCTION_COMPLETE? */
1548	pThis->fAsyncEvtsEnabled = SUPPORTED_EVENTS & ScsiCtrlUnion.AsyncNotify.fEventsRequested;
1549	}
1550
1551	aReqSegs[0].pvSeg = &pThis->fAsyncEvtsEnabled;
1552	aReqSegs[0].cbSeg = sizeof(pThis->fAsyncEvtsEnabled);
1553	cSegs = 1;
1554	break;
1555	}
1556	default:
1557	{
1558	LogFunc(("Unknown control type extracted from %s: %u\n", VIRTQNAME(uVirtqNbr), ScsiCtrlUnion.Type.uType));
1559
1560	bResponse = VIRTIOSCSI_S_FAILURE;
1561	cSegs = 0; /* only bResponse */
1562	break;
1563	}
1564	}
1565
1566	/* Add the response code: */
1567	aReqSegs[cSegs].pvSeg = &bResponse;
1568	aReqSegs[cSegs].cbSeg = sizeof(bResponse);
1569	cSegs++;
1570	Assert(cSegs <= RT_ELEMENTS(aReqSegs));
1571
1572	LogFunc(("Response code: %s\n", virtioGetReqRespText(bResponse)));
1573
1574	RTSGBUF ReqSgBuf;
1575	RTSgBufInit(&ReqSgBuf, aReqSegs, cSegs);
1576
1577	virtioScsiR3VirtqUsedBufPutAndSync(pDevIns, &pThis->Virtio, uVirtqNbr, &ReqSgBuf, pVirtqBuf);
1578	return VINF_SUCCESS;
1579	}
1580
1581	/**
1582	* @callback_method_impl{FNPDMTHREADWAKEUPDEV}
1583	*/
1584	static DECLCALLBACK(int) virtioScsiR3WorkerWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
1585	{
1586	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
1587	return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[(uintptr_t)pThread->pvUser].hEvtProcess);
1588	}
1589
1590	/**
1591	* @callback_method_impl{FNPDMTHREADDEV}
1592	*/
1593	static DECLCALLBACK(int) virtioScsiR3WorkerThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
1594	{
1595	uint16_t const uVirtqNbr = (uint16_t)(uintptr_t)pThread->pvUser;
1596	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
1597	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
1598	PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[uVirtqNbr];
1599	PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[uVirtqNbr];
1600
1601	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
1602	return VINF_SUCCESS;
1603
1604	Log6Func(("[Re]starting %s worker\n", VIRTQNAME(uVirtqNbr)));
1605	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
1606	{
1607	if ( !pWorkerR3->cRedoDescs
1608	&& IS_VIRTQ_EMPTY(pDevIns, &pThis->Virtio, uVirtqNbr))
1609	{
1610	/* Atomic interlocks avoid missing alarm while going to sleep & notifier waking the awoken */
1611	ASMAtomicWriteBool(&pWorker->fSleeping, true);
1612	bool fNotificationSent = ASMAtomicXchgBool(&pWorker->fNotified, false);
1613	if (!fNotificationSent)
1614	{
1615	Log6Func(("%s worker sleeping...\n", VIRTQNAME(uVirtqNbr)));
1616	Assert(ASMAtomicReadBool(&pWorker->fSleeping));
1617	int rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pWorker->hEvtProcess, RT_INDEFINITE_WAIT);
1618	AssertLogRelMsgReturn(RT_SUCCESS(rc) \|\| rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
1619	if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
1620	{
1621	Log6Func(("%s worker thread not running, exiting\n", VIRTQNAME(uVirtqNbr)));
1622	return VINF_SUCCESS;
1623	}
1624	if (rc == VERR_INTERRUPTED)
1625	{
1626	Log6Func(("%s worker interrupted ... continuing\n", VIRTQNAME(uVirtqNbr)));
1627	continue;
1628	}
1629	Log6Func(("%s worker woken\n", VIRTQNAME(uVirtqNbr)));
1630	ASMAtomicWriteBool(&pWorker->fNotified, false);
1631	}
1632	ASMAtomicWriteBool(&pWorker->fSleeping, false);
1633	}
1634	if (!virtioCoreIsVirtqEnabled(&pThis->Virtio, uVirtqNbr))
1635	{
1636	LogFunc(("%s queue not enabled, worker aborting...\n", VIRTQNAME(uVirtqNbr)));
1637	break;
1638	}
1639
1640	if (!pThis->afVirtqAttached[uVirtqNbr])
1641	{
1642	LogFunc(("%s queue not attached, worker aborting...\n", VIRTQNAME(uVirtqNbr)));
1643	break;
1644	}
1645	if (!pThisCC->fQuiescing)
1646	{
1647	/* Process any reqs that were suspended saved to the redo queue in save exec. */
1648	for (int i = 0; i < pWorkerR3->cRedoDescs; i++)
1649	{
1650	PVIRTQBUF pVirtqBuf = virtioCoreR3VirtqBufAlloc();
1651	if (!pVirtqBuf)
1652	{
1653	LogRel(("Failed to allocate memory for VIRTQBUF\n"));
1654	break; /* No point in trying to allocate memory for other descriptor chains */
1655	}
1656	int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr,
1657	pWorkerR3->auRedoDescs[i], pVirtqBuf);
1658	if (RT_FAILURE(rc))
1659	LogRel(("Error fetching desc chain to redo, %Rrc", rc));
1660
1661	rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
1662	if (RT_FAILURE(rc))
1663	LogRel(("Error submitting req packet, resetting %Rrc", rc));
1664
1665	virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
1666	}
1667	pWorkerR3->cRedoDescs = 0;
1668
1669	Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(uVirtqNbr)));
1670	PVIRTQBUF pVirtqBuf = virtioCoreR3VirtqBufAlloc();
1671	if (!pVirtqBuf)
1672	LogRel(("Failed to allocate memory for VIRTQBUF\n"));
1673	else
1674	{
1675	int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr, pVirtqBuf, true);
1676	if (rc == VERR_NOT_AVAILABLE)
1677	{
1678	Log6Func(("Nothing found in %s\n", VIRTQNAME(uVirtqNbr)));
1679	virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
1680	continue;
1681	}
1682
1683	AssertRC(rc);
1684	if (uVirtqNbr == CONTROLQ_IDX)
1685	virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
1686	else /* request queue index */
1687	{
1688	rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
1689	if (RT_FAILURE(rc))
1690	LogRel(("Error submitting req packet, resetting %Rrc", rc));
1691	}
1692
1693	virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
1694	}
1695	}
1696	}
1697	return VINF_SUCCESS;
1698	}
1699
1700
1701	/*********************************************************************************************************************************
1702	* Sending evnets
1703	*********************************************************************************************************************************/
1704
1705	/*
1706	* @todo Figure out how to implement this with R0 changes. Not used by current linux driver
1707	*/
1708
1709	#if 0
1710	DECLINLINE(void) virtioScsiR3ReportEventsMissed(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
1711	{
1712	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_NO_EVENT \| VIRTIOSCSI_T_EVENTS_MISSED, 0);
1713	}
1714	#endif
1715
1716	#if 0
1717	/* SUBSCRIBABLE EVENT - not sure when to call this or how to detect when media is added or removed
1718	* via the VBox GUI */
1719	DECLINLINE(void) virtioScsiR3ReportMediaChange(PPDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
1720	{
1721	if (pThis->fAsyncEvtsEnabled & VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE)
1722	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_ASYNC_NOTIFY, VIRTIOSCSI_EVT_ASYNC_MEDIA_CHANGE);
1723	}
1724
1725	/* ESSENTIAL (NON-SUBSCRIBABLE) EVENT TYPES (most guest virtio-scsi drivers ignore?) */
1726
1727	DECLINLINE(void) virtioScsiR3ReportTransportReset(PDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
1728	{
1729	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_HARD);
1730	}
1731
1732	DECLINLINE(void) virtioScsiR3ReportParamChange(PDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget,
1733	uint32_t uSenseCode, uint32_t uSenseQualifier)
1734	{
1735	uint32_t uReason = uSenseQualifier << 8 \| uSenseCode;
1736	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_PARAM_CHANGE, uReason);
1737
1738	}
1739
1740	DECLINLINE(void) virtioScsiR3ReportTargetRemoved(PDMDEVINS pDevIns, PVIRTIOSCSI pThis, uint16_t uTarget)
1741	{
1742	if (pThis->fHasHotplug)
1743	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_REMOVED);
1744	}
1745
1746	DECLINLINE(void) virtioScsiR3ReportTargetAdded(PDMDEVINS pDevInsPVIRTIOSCSI pThis, uint16_t uTarget)
1747	{
1748	if (pThis->fHasHotplug)
1749	virtioScsiR3SendEvent(pDevIns, pThis, uTarget, VIRTIOSCSI_T_TRANSPORT_RESET, VIRTIOSCSI_EVT_RESET_RESCAN);
1750	}
1751
1752	#endif
1753
1754	/**
1755	* @callback_method_impl{VIRTIOCORER3,pfnStatusChanged}
1756	*/
1757	static DECLCALLBACK(void) virtioScsiR3StatusChanged(PVIRTIOCORE pVirtio, PVIRTIOCORECC pVirtioCC, uint32_t fVirtioReady)
1758	{
1759	PVIRTIOSCSI pThis = RT_FROM_MEMBER(pVirtio, VIRTIOSCSI, Virtio);
1760	PVIRTIOSCSICC pThisCC = RT_FROM_MEMBER(pVirtioCC, VIRTIOSCSICC, Virtio);
1761
1762	pThis->fVirtioReady = fVirtioReady;
1763
1764	if (fVirtioReady)
1765	{
1766	LogFunc(("VirtIO ready\n-----------------------------------------------------------------------------------------\n"));
1767	uint64_t fFeatures = virtioCoreGetNegotiatedFeatures(&pThis->Virtio);
1768	pThis->fHasT10pi = fFeatures & VIRTIO_SCSI_F_T10_PI;
1769	pThis->fHasHotplug = fFeatures & VIRTIO_SCSI_F_HOTPLUG;
1770	pThis->fHasInOutBufs = fFeatures & VIRTIO_SCSI_F_INOUT;
1771	pThis->fHasLunChange = fFeatures & VIRTIO_SCSI_F_CHANGE;
1772	pThis->fResetting = false;
1773	pThisCC->fQuiescing = false;
1774
1775	for (unsigned i = 0; i < VIRTIOSCSI_VIRTQ_CNT; i++)
1776	pThis->afVirtqAttached[i] = true;
1777	}
1778	else
1779	{
1780	LogFunc(("VirtIO is resetting\n"));
1781	for (unsigned i = 0; i < VIRTIOSCSI_VIRTQ_CNT; i++)
1782	pThis->afVirtqAttached[i] = false;
1783
1784	/*
1785	* BIOS may change these values. When the OS comes up, and KVM driver accessed
1786	* through Windows, it assumes they are the default size. So as per the VirtIO 1.0 spec,
1787	* 5.6.4, these device configuration values must be set to default upon device reset.
1788	*/
1789	pThis->virtioScsiConfig.uSenseSize = VIRTIOSCSI_SENSE_SIZE_DEFAULT;
1790	pThis->virtioScsiConfig.uCdbSize = VIRTIOSCSI_CDB_SIZE_DEFAULT;
1791	}
1792
1793
1794	}
1795
1796
1797	/*********************************************************************************************************************************
1798	* LEDs *
1799	*********************************************************************************************************************************/
1800
1801	/**
1802	* @interface_method_impl{PDMILEDPORTS,pfnQueryStatusLed, Target level.}
1803	*/
1804	static DECLCALLBACK(int) virtioScsiR3TargetQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
1805	{
1806	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, ILed);
1807	if (iLUN == 0)
1808	{
1809	*ppLed = &pTarget->led;
1810	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
1811	return VINF_SUCCESS;
1812	}
1813	return VERR_PDM_LUN_NOT_FOUND;
1814	}
1815	/**
1816	* @interface_method_impl{PDMILEDPORTS,pfnQueryStatusLed, Device level.}
1817	*/
1818	static DECLCALLBACK(int) virtioScsiR3DeviceQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
1819	{
1820	PVIRTIOSCSICC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIOSCSICC, ILeds);
1821	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVIRTIOSCSI);
1822	if (iLUN < pThis->cTargets)
1823	{
1824	*ppLed = &pThisCC->paTargetInstances[iLUN].led;
1825	Assert((*ppLed)->u32Magic == PDMLED_MAGIC);
1826	return VINF_SUCCESS;
1827	}
1828	return VERR_PDM_LUN_NOT_FOUND;
1829	}
1830
1831
1832	/*********************************************************************************************************************************
1833	* PDMIMEDIAPORT (target) *
1834	*********************************************************************************************************************************/
1835
1836	/**
1837	* @interface_method_impl{PDMIMEDIAPORT,pfnQueryDeviceLocation, Target level.}
1838	*/
1839	static DECLCALLBACK(int) virtioScsiR3QueryDeviceLocation(PPDMIMEDIAPORT pInterface, const char **ppcszController,
1840	uint32_t piInstance, uint32_t piLUN)
1841	{
1842	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaPort);
1843	PPDMDEVINS pDevIns = pTarget->pDevIns;
1844
1845	AssertPtrReturn(ppcszController, VERR_INVALID_POINTER);
1846	AssertPtrReturn(piInstance, VERR_INVALID_POINTER);
1847	AssertPtrReturn(piLUN, VERR_INVALID_POINTER);
1848
1849	*ppcszController = pDevIns->pReg->szName;
1850	*piInstance = pDevIns->iInstance;
1851	*piLUN = pTarget->uTarget;
1852
1853	return VINF_SUCCESS;
1854	}
1855
1856
1857	/*********************************************************************************************************************************
1858	* Virtio config. *
1859	*********************************************************************************************************************************/
1860
1861	/**
1862	* Worker for virtioScsiR3DevCapWrite and virtioScsiR3DevCapRead.
1863	*/
1864	static int virtioScsiR3CfgAccessed(PVIRTIOSCSI pThis, uint32_t uOffsetOfAccess, void *pv, uint32_t cb, bool fWrite)
1865	{
1866	AssertReturn(pv && cb <= sizeof(uint32_t), fWrite ? VINF_SUCCESS : VINF_IOM_MMIO_UNUSED_00);
1867
1868	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uNumVirtqs, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1869	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uNumVirtqs, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1870	else
1871	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uSegMax, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1872	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uSegMax, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1873	else
1874	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uMaxSectors, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1875	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uMaxSectors, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1876	else
1877	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uCmdPerLun, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1878	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uCmdPerLun, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1879	else
1880	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uEventInfoSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1881	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uEventInfoSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1882	else
1883	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uSenseSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1884	VIRTIO_DEV_CONFIG_ACCESS( uSenseSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1885	else
1886	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uCdbSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1887	VIRTIO_DEV_CONFIG_ACCESS( uCdbSize, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1888	else
1889	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uMaxChannel, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1890	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uMaxChannel, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1891	else
1892	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uMaxTarget, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1893	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uMaxTarget, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1894	else
1895	if (VIRTIO_DEV_CONFIG_MATCH_MEMBER( uMaxLun, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess))
1896	VIRTIO_DEV_CONFIG_ACCESS_READONLY( uMaxLun, VIRTIOSCSI_CONFIG_T, uOffsetOfAccess, &pThis->virtioScsiConfig);
1897	else
1898	{
1899	LogFunc(("Bad access by guest to virtio_scsi_config: off=%u (%#x), cb=%u\n", uOffsetOfAccess, uOffsetOfAccess, cb));
1900	return fWrite ? VINF_SUCCESS : VINF_IOM_MMIO_UNUSED_00;
1901	}
1902	return VINF_SUCCESS;
1903	}
1904
1905	/**
1906	* @callback_method_impl{VIRTIOCORER3,pfnDevCapRead}
1907	*/
1908	static DECLCALLBACK(int) virtioScsiR3DevCapRead(PPDMDEVINS pDevIns, uint32_t uOffset, void *pv, uint32_t cb)
1909	{
1910	return virtioScsiR3CfgAccessed(PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI), uOffset, pv, cb, false /fRead/);
1911	}
1912
1913	/**
1914	* @callback_method_impl{VIRTIOCORER3,pfnDevCapWrite}
1915	*/
1916	static DECLCALLBACK(int) virtioScsiR3DevCapWrite(PPDMDEVINS pDevIns, uint32_t uOffset, const void *pv, uint32_t cb)
1917	{
1918	return virtioScsiR3CfgAccessed(PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI), uOffset, (void )pv, cb, true /fWrite*/);
1919	}
1920
1921
1922	/*********************************************************************************************************************************
1923	* IBase for device and targets *
1924	*********************************************************************************************************************************/
1925
1926	/**
1927	* @interface_method_impl{PDMIBASE,pfnQueryInterface, Target level.}
1928	*/
1929	static DECLCALLBACK(void ) virtioScsiR3TargetQueryInterface(PPDMIBASE pInterface, const char pszIID)
1930	{
1931	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IBase);
1932	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pTarget->IBase);
1933	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAPORT, &pTarget->IMediaPort);
1934	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEXPORT, &pTarget->IMediaExPort);
1935	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pTarget->ILed);
1936	return NULL;
1937	}
1938
1939	/**
1940	* @interface_method_impl{PDMIBASE,pfnQueryInterface, Device level.}
1941	*/
1942	static DECLCALLBACK(void ) virtioScsiR3DeviceQueryInterface(PPDMIBASE pInterface, const char pszIID)
1943	{
1944	PVIRTIOSCSICC pThisCC = RT_FROM_MEMBER(pInterface, VIRTIOSCSICC, IBase);
1945
1946	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
1947	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds);
1948
1949	return NULL;
1950	}
1951
1952
1953	/*********************************************************************************************************************************
1954	* Misc *
1955	*********************************************************************************************************************************/
1956
1957	/**
1958	* @callback_method_impl{FNDBGFHANDLERDEV, virtio-scsi debugger info callback.}
1959	*/
1960	static DECLCALLBACK(void) virtioScsiR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1961	{
1962	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
1963
1964	/* Parse arguments. */
1965	RT_NOREF(pszArgs); //bool fVerbose = pszArgs && strstr(pszArgs, "verbose") != NULL;
1966
1967	/* Show basic information. */
1968	pHlp->pfnPrintf(pHlp, "%s#%d: virtio-scsci ",
1969	pDevIns->pReg->szName,
1970	pDevIns->iInstance);
1971	pHlp->pfnPrintf(pHlp, "numTargets=%lu", pThis->cTargets);
1972	}
1973
1974
1975	/*********************************************************************************************************************************
1976	* Saved state *
1977	*********************************************************************************************************************************/
1978
1979	/**
1980	* @callback_method_impl{FNSSMDEVLOADEXEC}
1981	*/
1982	static DECLCALLBACK(int) virtioScsiR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
1983	{
1984	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
1985	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
1986	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1987
1988	LogFunc(("LOAD EXEC!!\n"));
1989
1990	AssertReturn(uPass == SSM_PASS_FINAL, VERR_SSM_UNEXPECTED_PASS);
1991	AssertLogRelMsgReturn(uVersion == VIRTIOSCSI_SAVED_STATE_VERSION,
1992	("uVersion=%u\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
1993
1994	virtioScsiSetVirtqNames(pThis);
1995	for (int uVirtqNbr = 0; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
1996	pHlp->pfnSSMGetBool(pSSM, &pThis->afVirtqAttached[uVirtqNbr]);
1997
1998	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uNumVirtqs);
1999	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uSegMax);
2000	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uMaxSectors);
2001	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uCmdPerLun);
2002	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uEventInfoSize);
2003	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uSenseSize);
2004	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uCdbSize);
2005	pHlp->pfnSSMGetU16(pSSM, &pThis->virtioScsiConfig.uMaxChannel);
2006	pHlp->pfnSSMGetU16(pSSM, &pThis->virtioScsiConfig.uMaxTarget);
2007	pHlp->pfnSSMGetU32(pSSM, &pThis->virtioScsiConfig.uMaxLun);
2008	pHlp->pfnSSMGetU32(pSSM, &pThis->fAsyncEvtsEnabled);
2009	pHlp->pfnSSMGetBool(pSSM, &pThis->fEventsMissed);
2010	pHlp->pfnSSMGetU32(pSSM, &pThis->fVirtioReady);
2011	pHlp->pfnSSMGetU32(pSSM, &pThis->fHasT10pi);
2012	pHlp->pfnSSMGetU32(pSSM, &pThis->fHasHotplug);
2013	pHlp->pfnSSMGetU32(pSSM, &pThis->fHasInOutBufs);
2014	pHlp->pfnSSMGetU32(pSSM, &pThis->fHasLunChange);
2015	pHlp->pfnSSMGetU32(pSSM, &pThis->fResetting);
2016
2017	uint32_t cTargets;
2018	int rc = pHlp->pfnSSMGetU32(pSSM, &cTargets);
2019	AssertRCReturn(rc, rc);
2020	AssertReturn(cTargets == pThis->cTargets,
2021	pHlp->pfnSSMSetLoadError(pSSM, VERR_SSM_LOAD_CONFIG_MISMATCH, RT_SRC_POS,
2022	N_("target count has changed: %u saved, %u configured now"),
2023	cTargets, pThis->cTargets));
2024
2025	for (uint16_t uTarget = 0; uTarget < pThis->cTargets; uTarget++)
2026	{
2027	uint16_t cReqsRedo;
2028	rc = pHlp->pfnSSMGetU16(pSSM, &cReqsRedo);
2029	AssertRCReturn(rc, rc);
2030	AssertReturn(cReqsRedo < VIRTQ_SIZE,
2031	pHlp->pfnSSMSetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
2032	N_("Bad count of I/O transactions to re-do in saved state (%#x, max %#x - 1)"),
2033	cReqsRedo, VIRTQ_SIZE));
2034
2035	for (uint16_t uVirtqNbr = VIRTQ_REQ_BASE; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
2036	{
2037	PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[uVirtqNbr];
2038	pWorkerR3->cRedoDescs = 0;
2039	}
2040
2041	for (int i = 0; i < cReqsRedo; i++)
2042	{
2043	uint16_t uVirtqNbr;
2044	rc = pHlp->pfnSSMGetU16(pSSM, &uVirtqNbr);
2045	AssertRCReturn(rc, rc);
2046	AssertReturn(uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT,
2047	pHlp->pfnSSMSetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
2048	N_("Bad queue index for re-do in saved state (%#x, max %#x)"),
2049	uVirtqNbr, VIRTIOSCSI_VIRTQ_CNT - 1));
2050
2051	uint16_t idxHead;
2052	rc = pHlp->pfnSSMGetU16(pSSM, &idxHead);
2053	AssertRCReturn(rc, rc);
2054	AssertReturn(idxHead < VIRTQ_SIZE,
2055	pHlp->pfnSSMSetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
2056	N_("Bad queue element index for re-do in saved state (%#x, max %#x)"),
2057	idxHead, VIRTQ_SIZE - 1));
2058
2059	PVIRTIOSCSIWORKERR3 pWorkerR3 = &pThisCC->aWorkers[uVirtqNbr];
2060	pWorkerR3->auRedoDescs[pWorkerR3->cRedoDescs++] = idxHead;
2061	pWorkerR3->cRedoDescs %= VIRTQ_SIZE;
2062	}
2063	}
2064
2065	/*
2066	* Call the virtio core to let it load its state.
2067	*/
2068	rc = virtioCoreR3ModernDeviceLoadExec(&pThis->Virtio, pDevIns->pHlpR3, pSSM,
2069	uVersion, VIRTIOSCSI_SAVED_STATE_VERSION, pThis->virtioScsiConfig.uNumVirtqs);
2070
2071	/*
2072	* Nudge request queue workers
2073	*/
2074	for (int uVirtqNbr = VIRTQ_REQ_BASE; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
2075	{
2076	if (pThis->afVirtqAttached[uVirtqNbr])
2077	{
2078	LogFunc(("Waking %s worker.\n", VIRTQNAME(uVirtqNbr)));
2079	int rc2 = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[uVirtqNbr].hEvtProcess);
2080	AssertRCReturn(rc, rc2);
2081	}
2082	}
2083
2084	return rc;
2085	}
2086
2087	/**
2088	* @callback_method_impl{FNSSMDEVSAVEEXEC}
2089	*/
2090	static DECLCALLBACK(int) virtioScsiR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2091	{
2092	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2093	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2094	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2095
2096	LogFunc(("SAVE EXEC!!\n"));
2097
2098	for (int uVirtqNbr = 0; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
2099	pHlp->pfnSSMPutBool(pSSM, pThis->afVirtqAttached[uVirtqNbr]);
2100
2101	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uNumVirtqs);
2102	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uSegMax);
2103	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uMaxSectors);
2104	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uCmdPerLun);
2105	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uEventInfoSize);
2106	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uSenseSize);
2107	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uCdbSize);
2108	pHlp->pfnSSMPutU16(pSSM, pThis->virtioScsiConfig.uMaxChannel);
2109	pHlp->pfnSSMPutU16(pSSM, pThis->virtioScsiConfig.uMaxTarget);
2110	pHlp->pfnSSMPutU32(pSSM, pThis->virtioScsiConfig.uMaxLun);
2111	pHlp->pfnSSMPutU32(pSSM, pThis->fAsyncEvtsEnabled);
2112	pHlp->pfnSSMPutBool(pSSM, pThis->fEventsMissed);
2113	pHlp->pfnSSMPutU32(pSSM, pThis->fVirtioReady);
2114	pHlp->pfnSSMPutU32(pSSM, pThis->fHasT10pi);
2115	pHlp->pfnSSMPutU32(pSSM, pThis->fHasHotplug);
2116	pHlp->pfnSSMPutU32(pSSM, pThis->fHasInOutBufs);
2117	pHlp->pfnSSMPutU32(pSSM, pThis->fHasLunChange);
2118	pHlp->pfnSSMPutU32(pSSM, pThis->fResetting);
2119
2120	AssertMsg(!pThis->cActiveReqs, ("There are still outstanding requests on this device\n"));
2121
2122	pHlp->pfnSSMPutU32(pSSM, pThis->cTargets);
2123
2124	for (uint16_t uTarget = 0; uTarget < pThis->cTargets; uTarget++)
2125	{
2126	PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[uTarget];
2127
2128	/* Query all suspended requests and store them in the request queue. */
2129	if (pTarget->pDrvMediaEx)
2130	{
2131	uint32_t cReqsRedo = pTarget->pDrvMediaEx->pfnIoReqGetSuspendedCount(pTarget->pDrvMediaEx);
2132
2133	pHlp->pfnSSMPutU16(pSSM, cReqsRedo);
2134
2135	if (cReqsRedo)
2136	{
2137	PDMMEDIAEXIOREQ hIoReq;
2138	PVIRTIOSCSIREQ pReq;
2139
2140	int rc = pTarget->pDrvMediaEx->pfnIoReqQuerySuspendedStart(pTarget->pDrvMediaEx, &hIoReq,
2141	(void **)&pReq);
2142	AssertRCBreak(rc);
2143
2144	while(--cReqsRedo)
2145	{
2146	pHlp->pfnSSMPutU16(pSSM, pReq->uVirtqNbr);
2147	pHlp->pfnSSMPutU16(pSSM, pReq->pVirtqBuf->uHeadIdx);
2148
2149	rc = pTarget->pDrvMediaEx->pfnIoReqQuerySuspendedNext(pTarget->pDrvMediaEx, hIoReq,
2150	&hIoReq, (void **)&pReq);
2151	AssertRCBreak(rc);
2152	}
2153	}
2154	}
2155	}
2156
2157	/*
2158	* Call the virtio core to let it save its state.
2159	*/
2160	return virtioCoreR3SaveExec(&pThis->Virtio, pDevIns->pHlpR3, pSSM, VIRTIOSCSI_SAVED_STATE_VERSION, VIRTIOSCSI_VIRTQ_CNT);
2161	}
2162
2163
2164	/*********************************************************************************************************************************
2165	* Device interface. *
2166	*********************************************************************************************************************************/
2167
2168	/**
2169	* @interface_method_impl{PDMDEVREGR3,pfnDetach}
2170	*
2171	* One harddisk at one port has been unplugged.
2172	* The VM is suspended at this point.
2173	*/
2174	static DECLCALLBACK(void) virtioScsiR3Detach(PPDMDEVINS pDevIns, unsigned uTarget, uint32_t fFlags)
2175	{
2176	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2177	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2178	AssertReturnVoid(uTarget < pThis->cTargets);
2179	PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[uTarget];
2180
2181	LogFunc((""));
2182
2183	AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
2184	("virtio-scsi: Device does not support hotplugging\n"));
2185	RT_NOREF(fFlags);
2186
2187	/*
2188	* Zero all important members.
2189	*/
2190	pTarget->fPresent = false;
2191	pTarget->pDrvBase = NULL;
2192	pTarget->pDrvMedia = NULL;
2193	pTarget->pDrvMediaEx = NULL;
2194	}
2195
2196	/**
2197	* @interface_method_impl{PDMDEVREGR3,pfnAttach}
2198	*
2199	* This is called when we change block driver.
2200	*/
2201	static DECLCALLBACK(int) virtioScsiR3Attach(PPDMDEVINS pDevIns, unsigned uTarget, uint32_t fFlags)
2202	{
2203	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2204	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2205	AssertReturn(uTarget < pThis->cTargets, VERR_PDM_LUN_NOT_FOUND);
2206	PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[uTarget];
2207
2208	Assert(pTarget->pDevIns == pDevIns);
2209	AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
2210	("virtio-scsi: Device does not support hotplugging\n"),
2211	VERR_INVALID_PARAMETER);
2212
2213	AssertRelease(!pTarget->pDrvBase);
2214	Assert(pTarget->uTarget == uTarget);
2215
2216	/*
2217	* Try attach the SCSI driver and get the interfaces, required as well as optional.
2218	*/
2219	int rc = PDMDevHlpDriverAttach(pDevIns, pTarget->uTarget, &pDevIns->IBase, &pTarget->pDrvBase, pTarget->pszTargetName);
2220	if (RT_SUCCESS(rc))
2221	{
2222	pTarget->fPresent = true;
2223	pTarget->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pTarget->pDrvBase, PDMIMEDIA);
2224	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMedia),
2225	("virtio-scsi configuration error: LUN#%d missing basic media interface!\n", uTarget),
2226	VERR_PDM_MISSING_INTERFACE);
2227
2228	/* Get the extended media interface. */
2229	pTarget->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pTarget->pDrvBase, PDMIMEDIAEX);
2230	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMediaEx),
2231	("virtio-scsi configuration error: LUN#%d missing extended media interface!\n", uTarget),
2232	VERR_PDM_MISSING_INTERFACE);
2233
2234	rc = pTarget->pDrvMediaEx->pfnIoReqAllocSizeSet(pTarget->pDrvMediaEx, sizeof(VIRTIOSCSIREQ));
2235	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMediaEx),
2236	("virtio-scsi configuration error: LUN#%u: Failed to set I/O request size!\n", uTarget),
2237	rc);
2238	}
2239	else
2240	AssertMsgFailed(("Failed to attach %s. rc=%Rrc\n", pTarget->pszTargetName, rc));
2241
2242	if (RT_FAILURE(rc))
2243	{
2244	pTarget->fPresent = false;
2245	pTarget->pDrvBase = NULL;
2246	pTarget->pDrvMedia = NULL;
2247	pTarget->pDrvMediaEx = NULL;
2248	pThisCC->pMediaNotify = NULL;
2249	}
2250	return rc;
2251	}
2252
2253	/**
2254	* @callback_method_impl{FNPDMDEVASYNCNOTIFY}
2255	*/
2256	static DECLCALLBACK(bool) virtioScsiR3DeviceQuiesced(PPDMDEVINS pDevIns)
2257	{
2258	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2259	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2260
2261	if (ASMAtomicReadU32(&pThis->cActiveReqs))
2262	return false;
2263
2264	LogFunc(("Device I/O activity quiesced: %s\n",
2265	virtioCoreGetStateChangeText(pThisCC->enmQuiescingFor)));
2266
2267	virtioCoreR3VmStateChanged(&pThis->Virtio, pThisCC->enmQuiescingFor);
2268
2269	pThis->fResetting = false;
2270	pThisCC->fQuiescing = false;
2271
2272	return true;
2273	}
2274
2275	/**
2276	* Worker for virtioScsiR3Reset() and virtioScsiR3SuspendOrPowerOff().
2277	*/
2278	static void virtioScsiR3QuiesceDevice(PPDMDEVINS pDevIns, VIRTIOVMSTATECHANGED enmQuiscingFor)
2279	{
2280	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2281	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2282
2283	/* Prevent worker threads from removing/processing elements from virtq's */
2284	pThisCC->fQuiescing = true;
2285	pThisCC->enmQuiescingFor = enmQuiscingFor;
2286
2287	PDMDevHlpSetAsyncNotification(pDevIns, virtioScsiR3DeviceQuiesced);
2288
2289	/* If already quiesced invoke async callback. */
2290	if (!ASMAtomicReadU32(&pThis->cActiveReqs))
2291	PDMDevHlpAsyncNotificationCompleted(pDevIns);
2292	}
2293
2294	/**
2295	* @interface_method_impl{PDMDEVREGR3,pfnReset}
2296	*/
2297	static DECLCALLBACK(void) virtioScsiR3Reset(PPDMDEVINS pDevIns)
2298	{
2299	LogFunc(("\n"));
2300	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2301	pThis->fResetting = true;
2302	virtioScsiR3QuiesceDevice(pDevIns, kvirtIoVmStateChangedReset);
2303	}
2304
2305	/**
2306	* @interface_method_impl{PDMDEVREGR3,pfnPowerOff}
2307	*/
2308	static DECLCALLBACK(void) virtioScsiR3SuspendOrPowerOff(PPDMDEVINS pDevIns, VIRTIOVMSTATECHANGED enmType)
2309	{
2310	LogFunc(("\n"));
2311
2312	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2313	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2314
2315	/* VM is halted, thus no new I/O being dumped into queues by the guest.
2316	* Workers have been flagged to stop pulling stuff already queued-up by the guest.
2317	* Now tell lower-level to to suspend reqs (for example, DrvVD suspends all reqs
2318	* on its wait queue, and we will get a callback as the state changes to
2319	* suspended (and later, resumed) for each).
2320	*/
2321	for (uint32_t i = 0; i < pThis->cTargets; i++)
2322	{
2323	PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[i];
2324	if (pTarget->pDrvMediaEx)
2325	pTarget->pDrvMediaEx->pfnNotifySuspend(pTarget->pDrvMediaEx);
2326	}
2327
2328	virtioScsiR3QuiesceDevice(pDevIns, enmType);
2329	}
2330
2331	/**
2332	* @interface_method_impl{PDMDEVREGR3,pfnSuspend}
2333	*/
2334	static DECLCALLBACK(void) virtioScsiR3PowerOff(PPDMDEVINS pDevIns)
2335	{
2336	LogFunc(("\n"));
2337	virtioScsiR3SuspendOrPowerOff(pDevIns, kvirtIoVmStateChangedPowerOff);
2338	}
2339
2340	/**
2341	* @interface_method_impl{PDMDEVREGR3,pfnSuspend}
2342	*/
2343	static DECLCALLBACK(void) virtioScsiR3Suspend(PPDMDEVINS pDevIns)
2344	{
2345	LogFunc(("\n"));
2346	virtioScsiR3SuspendOrPowerOff(pDevIns, kvirtIoVmStateChangedSuspend);
2347	}
2348
2349	/**
2350	* @interface_method_impl{PDMDEVREGR3,pfnResume}
2351	*/
2352	static DECLCALLBACK(void) virtioScsiR3Resume(PPDMDEVINS pDevIns)
2353	{
2354	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2355	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2356	LogFunc(("\n"));
2357
2358	pThisCC->fQuiescing = false;
2359
2360	/* Wake worker threads flagged to skip pulling queue entries during quiesce
2361	* to ensure they re-check their queues. Active request queues may already
2362	* be awake due to new reqs coming in.
2363	*/
2364	for (uint16_t uVirtqNbr = 0; uVirtqNbr < VIRTIOSCSI_REQ_VIRTQ_CNT; uVirtqNbr++)
2365	{
2366	if ( virtioCoreIsVirtqEnabled(&pThis->Virtio, uVirtqNbr)
2367	&& ASMAtomicReadBool(&pThis->aWorkers[uVirtqNbr].fSleeping))
2368	{
2369	Log6Func(("waking %s worker.\n", VIRTQNAME(uVirtqNbr)));
2370	int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->aWorkers[uVirtqNbr].hEvtProcess);
2371	AssertRC(rc);
2372	}
2373	}
2374	/* Ensure guest is working the queues too. */
2375	virtioCoreR3VmStateChanged(&pThis->Virtio, kvirtIoVmStateChangedResume);
2376	}
2377
2378	/**
2379	* @interface_method_impl{PDMIMEDIAEXPORT,pfnMediumEjected}
2380	*/
2381	static DECLCALLBACK(void) virtioScsiR3MediumEjected(PPDMIMEDIAEXPORT pInterface)
2382	{
2383	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
2384	PPDMDEVINS pDevIns = pTarget->pDevIns;
2385	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2386
2387	#if 0 /* need more info about how to use this event. The VirtIO 1.0 specification
2388	* lists several SCSI related event types but presumes the reader knows
2389	* how to use them without providing references. */
2390	virtioScsiR3ReportMediaChange(pDevIns, pThis, pTarget->uTarget);
2391	#endif
2392
2393	if (pThisCC->pMediaNotify)
2394	{
2395	int rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
2396	(PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
2397	pThisCC->pMediaNotify, pTarget->uTarget);
2398	AssertRC(rc);
2399	}
2400	}
2401
2402	/**
2403	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqStateChanged}
2404	*/
2405	static DECLCALLBACK(void) virtioScsiR3IoReqStateChanged(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
2406	void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
2407	{
2408	PVIRTIOSCSITARGET pTarget = RT_FROM_MEMBER(pInterface, VIRTIOSCSITARGET, IMediaExPort);
2409	PPDMDEVINS pDevIns = pTarget->pDevIns;
2410	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2411	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2412	RT_NOREF(hIoReq, pvIoReqAlloc);
2413
2414	switch (enmState)
2415	{
2416	case PDMMEDIAEXIOREQSTATE_SUSPENDED:
2417	{
2418	/* Stop considering this request active */
2419	virtioScsiR3Release(pDevIns, pThis, pThisCC);
2420	break;
2421	}
2422	case PDMMEDIAEXIOREQSTATE_ACTIVE:
2423	virtioScsiR3Retain(pThis);
2424	break;
2425	default:
2426	AssertMsgFailed(("Invalid request state given %u\n", enmState));
2427	}
2428	}
2429
2430	/**
2431	* @interface_method_impl{PDMDEVREGR3,pfnDestruct}
2432	*/
2433	static DECLCALLBACK(int) virtioScsiR3Destruct(PPDMDEVINS pDevIns)
2434	{
2435	PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
2436	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2437	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2438
2439	RTMemFree(pThisCC->paTargetInstances);
2440	pThisCC->paTargetInstances = NULL;
2441	pThisCC->pMediaNotify = NULL;
2442
2443	for (unsigned uVirtqNbr = 0; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
2444	{
2445	PVIRTIOSCSIWORKER pWorker = &pThis->aWorkers[uVirtqNbr];
2446	if (pWorker->hEvtProcess != NIL_SUPSEMEVENT)
2447	{
2448	PDMDevHlpSUPSemEventClose(pDevIns, pWorker->hEvtProcess);
2449	pWorker->hEvtProcess = NIL_SUPSEMEVENT;
2450	}
2451
2452	if (pThisCC->aWorkers[uVirtqNbr].pThread)
2453	{
2454	/* Destroy the thread. */
2455	int rcThread;
2456	int rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->aWorkers[uVirtqNbr].pThread, &rcThread);
2457	if (RT_FAILURE(rc) \|\| RT_FAILURE(rcThread))
2458	AssertMsgFailed(("%s Failed to destroythread rc=%Rrc rcThread=%Rrc\n",
2459	__FUNCTION__, rc, rcThread));
2460	pThisCC->aWorkers[uVirtqNbr].pThread = NULL;
2461	}
2462
2463	if (RTCritSectIsInitialized(&pThisCC->aWorkers[uVirtqNbr].CritSectVirtq))
2464	RTCritSectDelete(&pThisCC->aWorkers[uVirtqNbr].CritSectVirtq);
2465	}
2466
2467	virtioCoreR3Term(pDevIns, &pThis->Virtio, &pThisCC->Virtio);
2468	return VINF_SUCCESS;
2469	}
2470
2471	/**
2472	* @interface_method_impl{PDMDEVREGR3,pfnConstruct}
2473	*/
2474	static DECLCALLBACK(int) virtioScsiR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2475	{
2476	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2477	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2478	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2479	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
2480
2481	/*
2482	* Quick initialization of the state data, making sure that the destructor always works.
2483	*/
2484	pThisCC->pDevIns = pDevIns;
2485
2486	LogFunc(("PDM device instance: %d\n", iInstance));
2487	RTStrPrintf(pThis->szInstance, sizeof(pThis->szInstance), "VIRTIOSCSI%d", iInstance);
2488
2489	pThisCC->IBase.pfnQueryInterface = virtioScsiR3DeviceQueryInterface;
2490	pThisCC->ILeds.pfnQueryStatusLed = virtioScsiR3DeviceQueryStatusLed;
2491
2492	/*
2493	* Validate and read configuration.
2494	*/
2495	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "NumTargets"
2496	"\|Bootable"
2497	"\|MmioBase"
2498	"\|Irq", "");
2499
2500	int rc = pHlp->pfnCFGMQueryU32Def(pCfg, "NumTargets", &pThis->cTargets, 1);
2501	if (RT_FAILURE(rc))
2502	return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-scsi configuration error: failed to read NumTargets as integer"));
2503	if (pThis->cTargets < 1 \|\| pThis->cTargets > VIRTIOSCSI_MAX_TARGETS)
2504	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2505	N_("virtio-scsi configuration error: NumTargets=%u is out of range (1..%u)"),
2506	pThis->cTargets, VIRTIOSCSI_MAX_TARGETS);
2507
2508	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "Bootable", &pThis->fBootable, true);
2509	if (RT_FAILURE(rc))
2510	return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-scsi configuration error: failed to read Bootable as boolean"));
2511
2512	LogRel(("%s: Targets=%u Bootable=%RTbool (unimplemented) R0Enabled=%RTbool RCEnabled=%RTbool\n",
2513	pThis->szInstance, pThis->cTargets, pThis->fBootable, pDevIns->fR0Enabled, pDevIns->fRCEnabled));
2514
2515
2516	/*
2517	* Do core virtio initialization.
2518	*/
2519
2520	/* Configure virtio_scsi_config that transacts via VirtIO implementation's Dev. Specific Cap callbacks */
2521	pThis->virtioScsiConfig.uNumVirtqs = VIRTIOSCSI_REQ_VIRTQ_CNT;
2522	pThis->virtioScsiConfig.uSegMax = VIRTIOSCSI_MAX_SEG_COUNT;
2523	pThis->virtioScsiConfig.uMaxSectors = VIRTIOSCSI_MAX_SECTORS_HINT;
2524	pThis->virtioScsiConfig.uCmdPerLun = VIRTIOSCSI_MAX_COMMANDS_PER_LUN;
2525	pThis->virtioScsiConfig.uEventInfoSize = sizeof(VIRTIOSCSI_EVENT_T); /VirtIO 1.0 Spec says at least this size! /
2526	pThis->virtioScsiConfig.uSenseSize = VIRTIOSCSI_SENSE_SIZE_DEFAULT;
2527	pThis->virtioScsiConfig.uCdbSize = VIRTIOSCSI_CDB_SIZE_DEFAULT;
2528	pThis->virtioScsiConfig.uMaxChannel = VIRTIOSCSI_MAX_CHANNEL_HINT;
2529	pThis->virtioScsiConfig.uMaxTarget = pThis->cTargets;
2530	pThis->virtioScsiConfig.uMaxLun = VIRTIOSCSI_MAX_LUN;
2531
2532	/* Initialize the generic Virtio core: */
2533	pThisCC->Virtio.pfnVirtqNotified = virtioScsiNotified;
2534	pThisCC->Virtio.pfnStatusChanged = virtioScsiR3StatusChanged;
2535	pThisCC->Virtio.pfnDevCapRead = virtioScsiR3DevCapRead;
2536	pThisCC->Virtio.pfnDevCapWrite = virtioScsiR3DevCapWrite;
2537
2538	VIRTIOPCIPARAMS VirtioPciParams;
2539	VirtioPciParams.uDeviceId = PCI_DEVICE_ID_VIRTIOSCSI_HOST;
2540	VirtioPciParams.uClassBase = PCI_CLASS_BASE_MASS_STORAGE;
2541	VirtioPciParams.uClassSub = PCI_CLASS_SUB_SCSI_STORAGE_CONTROLLER;
2542	VirtioPciParams.uClassProg = PCI_CLASS_PROG_UNSPECIFIED;
2543	VirtioPciParams.uSubsystemId = PCI_DEVICE_ID_VIRTIOSCSI_HOST; /* VirtIO 1.0 spec allows PCI Device ID here */
2544	VirtioPciParams.uInterruptLine = 0x00;
2545	VirtioPciParams.uInterruptPin = 0x01;
2546	VirtioPciParams.uDeviceType = VIRTIO_DEVICE_TYPE_SCSI_HOST;
2547
2548	rc = virtioCoreR3Init(pDevIns, &pThis->Virtio, &pThisCC->Virtio, &VirtioPciParams, pThis->szInstance,
2549	VIRTIOSCSI_HOST_SCSI_FEATURES_OFFERED, 0 /fOfferLegacy/,
2550	&pThis->virtioScsiConfig /pvDevSpecificCap/, sizeof(pThis->virtioScsiConfig));
2551	if (RT_FAILURE(rc))
2552	return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-scsi: failed to initialize VirtIO"));
2553
2554	/*
2555	* Initialize queues.
2556	*/
2557
2558	virtioScsiSetVirtqNames(pThis);
2559
2560	/* Attach the queues and create worker threads for them: */
2561	for (uint16_t uVirtqNbr = 0; uVirtqNbr < VIRTIOSCSI_VIRTQ_CNT; uVirtqNbr++)
2562	{
2563	rc = virtioCoreR3VirtqAttach(&pThis->Virtio, uVirtqNbr, VIRTQNAME(uVirtqNbr));
2564	if (RT_FAILURE(rc))
2565	continue;
2566	if (uVirtqNbr == CONTROLQ_IDX \|\| IS_REQ_VIRTQ(uVirtqNbr))
2567	{
2568	rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->aWorkers[uVirtqNbr].pThread,
2569	(void *)(uintptr_t)uVirtqNbr, virtioScsiR3WorkerThread,
2570	virtioScsiR3WorkerWakeUp, 0, RTTHREADTYPE_IO, VIRTQNAME(uVirtqNbr));
2571	if (rc != VINF_SUCCESS)
2572	{
2573	LogRel(("Error creating thread for Virtual Virtq %s: %Rrc\n", VIRTQNAME(uVirtqNbr), rc));
2574	return rc;
2575	}
2576
2577	rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->aWorkers[uVirtqNbr].hEvtProcess);
2578	if (RT_FAILURE(rc))
2579	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2580	N_("DevVirtioSCSI: Failed to create SUP event semaphore"));
2581	}
2582	pThis->afVirtqAttached[uVirtqNbr] = true;
2583	rc = RTCritSectInit(&pThisCC->aWorkers[uVirtqNbr].CritSectVirtq);
2584	if (RT_FAILURE(rc))
2585	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2586	N_("DevVirtioSCSI: Failed to create worker critical section"));
2587	}
2588
2589	/*
2590	* Initialize per device instances (targets).
2591	*/
2592	Log2Func(("Probing %d targets ...\n", pThis->cTargets));
2593
2594	pThisCC->paTargetInstances = (PVIRTIOSCSITARGET)RTMemAllocZ(sizeof(VIRTIOSCSITARGET) * pThis->cTargets);
2595	if (!pThisCC->paTargetInstances)
2596	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to allocate memory for target states"));
2597
2598	for (uint32_t uTarget = 0; uTarget < pThis->cTargets; uTarget++)
2599	{
2600	PVIRTIOSCSITARGET pTarget = &pThisCC->paTargetInstances[uTarget];
2601
2602	if (RTStrAPrintf(&pTarget->pszTargetName, "VSCSI%u", uTarget) < 0)
2603	AssertLogRelFailedReturn(VERR_NO_MEMORY);
2604
2605	/* Initialize static parts of the device. */
2606	pTarget->pDevIns = pDevIns;
2607	pTarget->uTarget = uTarget;
2608
2609	pTarget->IBase.pfnQueryInterface = virtioScsiR3TargetQueryInterface;
2610
2611	/* IMediaPort and IMediaExPort interfaces provide callbacks for VD media and downstream driver access */
2612	pTarget->IMediaPort.pfnQueryDeviceLocation = virtioScsiR3QueryDeviceLocation;
2613	pTarget->IMediaPort.pfnQueryScsiInqStrings = NULL;
2614	pTarget->IMediaExPort.pfnIoReqCompleteNotify = virtioScsiR3IoReqFinish;
2615	pTarget->IMediaExPort.pfnIoReqCopyFromBuf = virtioScsiR3IoReqCopyFromBuf;
2616	pTarget->IMediaExPort.pfnIoReqCopyToBuf = virtioScsiR3IoReqCopyToBuf;
2617	pTarget->IMediaExPort.pfnIoReqStateChanged = virtioScsiR3IoReqStateChanged;
2618	pTarget->IMediaExPort.pfnMediumEjected = virtioScsiR3MediumEjected;
2619	pTarget->IMediaExPort.pfnIoReqQueryBuf = NULL; /* When used avoids copyFromBuf CopyToBuf*/
2620	pTarget->IMediaExPort.pfnIoReqQueryDiscardRanges = NULL;
2621
2622	pTarget->IBase.pfnQueryInterface = virtioScsiR3TargetQueryInterface;
2623	pTarget->ILed.pfnQueryStatusLed = virtioScsiR3TargetQueryStatusLed;
2624	pTarget->led.u32Magic = PDMLED_MAGIC;
2625
2626	LogFunc(("Attaching LUN: %s\n", pTarget->pszTargetName));
2627
2628	AssertReturn(uTarget < pThis->cTargets, VERR_PDM_NO_SUCH_LUN);
2629	rc = PDMDevHlpDriverAttach(pDevIns, uTarget, &pTarget->IBase, &pTarget->pDrvBase, pTarget->pszTargetName);
2630	if (RT_SUCCESS(rc))
2631	{
2632	pTarget->fPresent = true;
2633
2634	pTarget->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pTarget->pDrvBase, PDMIMEDIA);
2635	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMedia),
2636	("virtio-scsi configuration error: LUN#%d missing basic media interface!\n", uTarget),
2637	VERR_PDM_MISSING_INTERFACE);
2638	/* Get the extended media interface. */
2639	pTarget->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pTarget->pDrvBase, PDMIMEDIAEX);
2640	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMediaEx),
2641	("virtio-scsi configuration error: LUN#%d missing extended media interface!\n", uTarget),
2642	VERR_PDM_MISSING_INTERFACE);
2643
2644	rc = pTarget->pDrvMediaEx->pfnIoReqAllocSizeSet(pTarget->pDrvMediaEx, sizeof(VIRTIOSCSIREQ));
2645	AssertMsgReturn(RT_VALID_PTR(pTarget->pDrvMediaEx),
2646	("virtio-scsi configuration error: LUN#%u: Failed to set I/O request size!\n", uTarget),
2647	rc);
2648	}
2649	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2650	{
2651	pTarget->fPresent = false;
2652	pTarget->pDrvBase = NULL;
2653	Log(("virtio-scsi: no driver attached to device %s\n", pTarget->pszTargetName));
2654	rc = VINF_SUCCESS;
2655	}
2656	else
2657	{
2658	AssertLogRelMsgFailed(("virtio-scsi: Failed to attach %s: %Rrc\n", pTarget->pszTargetName, rc));
2659	return rc;
2660	}
2661	}
2662
2663	/*
2664	* Status driver (optional).
2665	*/
2666	PPDMIBASE pUpBase = NULL;
2667	AssertCompile(PDM_STATUS_LUN >= VIRTIOSCSI_MAX_TARGETS);
2668	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pUpBase, "Status Port");
2669	if (RT_FAILURE(rc) && rc != VERR_PDM_NO_ATTACHED_DRIVER)
2670	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the status LUN"));
2671	if (RT_SUCCESS(rc) && pUpBase)
2672	pThisCC->pMediaNotify = PDMIBASE_QUERY_INTERFACE(pUpBase, PDMIMEDIANOTIFY);
2673
2674
2675	/*
2676	* Register saved state.
2677	*/
2678	rc = PDMDevHlpSSMRegister(pDevIns, VIRTIOSCSI_SAVED_STATE_VERSION, sizeof(*pThis),
2679	virtioScsiR3SaveExec, virtioScsiR3LoadExec);
2680	AssertRCReturn(rc, rc);
2681
2682	/*
2683	* Register the debugger info callback (ignore errors).
2684	*/
2685	char szTmp[128];
2686	RTStrPrintf(szTmp, sizeof(szTmp), "%s%u", pDevIns->pReg->szName, pDevIns->iInstance);
2687	PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "virtio-scsi info", virtioScsiR3Info);
2688
2689	return rc;
2690	}
2691
2692	#else /* !IN_RING3 */
2693
2694	/**
2695	* @callback_method_impl{PDMDEVREGR0,pfnConstruct}
2696	*/
2697	static DECLCALLBACK(int) virtioScsiRZConstruct(PPDMDEVINS pDevIns)
2698	{
2699	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2700
2701	PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
2702	PVIRTIOSCSICC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVIRTIOSCSICC);
2703
2704
2705	pThisCC->Virtio.pfnVirtqNotified = virtioScsiNotified;
2706	return virtioCoreRZInit(pDevIns, &pThis->Virtio);
2707	}
2708
2709	#endif /* !IN_RING3 */
2710
2711
2712	/**
2713	* The device registration structure.
2714	*/
2715	const PDMDEVREG g_DeviceVirtioSCSI =
2716	{
2717	/* .u32Version = */ PDM_DEVREG_VERSION,
2718	/* .uReserved0 = */ 0,
2719	/* .szName = */ "virtio-scsi",
2720	/* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS \| PDM_DEVREG_FLAGS_RZ \| PDM_DEVREG_FLAGS_NEW_STYLE
2721	\| PDM_DEVREG_FLAGS_FIRST_SUSPEND_NOTIFICATION
2722	\| PDM_DEVREG_FLAGS_FIRST_POWEROFF_NOTIFICATION,
2723	/* .fClass = */ PDM_DEVREG_CLASS_STORAGE,
2724	/* .cMaxInstances = */ ~0U,
2725	/* .uSharedVersion = */ 42,
2726	/* .cbInstanceShared = */ sizeof(VIRTIOSCSI),
2727	/* .cbInstanceCC = */ sizeof(VIRTIOSCSICC),
2728	/* .cbInstanceRC = */ sizeof(VIRTIOSCSIRC),
2729	/* .cMaxPciDevices = */ 1,
2730	/* .cMaxMsixVectors = */ VBOX_MSIX_MAX_ENTRIES,
2731	/* .pszDescription = */ "Virtio Host SCSI.\n",
2732	#if defined(IN_RING3)
2733	/* .pszRCMod = */ "VBoxDDRC.rc",
2734	/* .pszR0Mod = */ "VBoxDDR0.r0",
2735	/* .pfnConstruct = */ virtioScsiR3Construct,
2736	/* .pfnDestruct = */ virtioScsiR3Destruct,
2737	/* .pfnRelocate = */ NULL,
2738	/* .pfnMemSetup = */ NULL,
2739	/* .pfnPowerOn = */ NULL,
2740	/* .pfnReset = */ virtioScsiR3Reset,
2741	/* .pfnSuspend = */ virtioScsiR3Suspend,
2742	/* .pfnResume = */ virtioScsiR3Resume,
2743	/* .pfnAttach = */ virtioScsiR3Attach,
2744	/* .pfnDetach = */ virtioScsiR3Detach,
2745	/* .pfnQueryInterface = */ NULL,
2746	/* .pfnInitComplete = */ NULL,
2747	/* .pfnPowerOff = */ virtioScsiR3PowerOff,
2748	/* .pfnSoftReset = */ NULL,
2749	/* .pfnReserved0 = */ NULL,
2750	/* .pfnReserved1 = */ NULL,
2751	/* .pfnReserved2 = */ NULL,
2752	/* .pfnReserved3 = */ NULL,
2753	/* .pfnReserved4 = */ NULL,
2754	/* .pfnReserved5 = */ NULL,
2755	/* .pfnReserved6 = */ NULL,
2756	/* .pfnReserved7 = */ NULL,
2757	#elif defined(IN_RING0)
2758	/* .pfnEarlyConstruct = */ NULL,
2759	/* .pfnConstruct = */ virtioScsiRZConstruct,
2760	/* .pfnDestruct = */ NULL,
2761	/* .pfnFinalDestruct = */ NULL,
2762	/* .pfnRequest = */ NULL,
2763	/* .pfnReserved0 = */ NULL,
2764	/* .pfnReserved1 = */ NULL,
2765	/* .pfnReserved2 = */ NULL,
2766	/* .pfnReserved3 = */ NULL,
2767	/* .pfnReserved4 = */ NULL,
2768	/* .pfnReserved5 = */ NULL,
2769	/* .pfnReserved6 = */ NULL,
2770	/* .pfnReserved7 = */ NULL,
2771	#elif defined(IN_RC)
2772	/* .pfnConstruct = */ virtioScsiRZConstruct,
2773	/* .pfnReserved0 = */ NULL,
2774	/* .pfnReserved1 = */ NULL,
2775	/* .pfnReserved2 = */ NULL,
2776	/* .pfnReserved3 = */ NULL,
2777	/* .pfnReserved4 = */ NULL,
2778	/* .pfnReserved5 = */ NULL,
2779	/* .pfnReserved6 = */ NULL,
2780	/* .pfnReserved7 = */ NULL,
2781	#else
2782	# error "Not in IN_RING3, IN_RING0 or IN_RC!"
2783	#endif
2784	/* .u32VersionEnd = */ PDM_DEVREG_VERSION
2785	};
2786

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

source: vbox/trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp@ 102468

Download in other formats: