DrvRamDisk.cpp@ 105100

Last change on this file since 105100 was 99887, checked in by vboxsync, 19 months ago
Devices/DrvRamDisk: Return VERR_PDM_GEOMETRY_NOT_SET to indicate that the caller has to resort to some other method for deducing the CHS geometry
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.7 KB

Line
1	/* $Id: DrvRamDisk.cpp 99887 2023-05-22 10:33:51Z vboxsync $ */
2	/** @file
3	* VBox storage devices: RAM disk driver.
4	*/
5
6	/*
7	* Copyright (C) 2016-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DRV_DISK_INTEGRITY
33	#include <VBox/vmm/pdmdrv.h>
34	#include <VBox/vmm/pdmstorageifs.h>
35	#include <iprt/assert.h>
36	#include <iprt/string.h>
37	#include <iprt/uuid.h>
38	#include <iprt/avl.h>
39	#include <iprt/list.h>
40	#include <iprt/mem.h>
41	#include <iprt/memcache.h>
42	#include <iprt/message.h>
43	#include <iprt/sg.h>
44	#include <iprt/time.h>
45	#include <iprt/semaphore.h>
46	#include <iprt/asm.h>
47	#include <iprt/req.h>
48	#include <iprt/thread.h>
49
50	#include "VBoxDD.h"
51	#include "IOBufMgmt.h"
52
53
54	/*********************************************************************************************************************************
55	* Structures and Typedefs *
56	*********************************************************************************************************************************/
57
58	/** Pointer to a ramdisk driver instance. */
59	typedef struct DRVRAMDISK *PDRVRAMDISK;
60
61	/**
62	* Disk segment.
63	*/
64	typedef struct DRVDISKSEGMENT
65	{
66	/** AVL core. */
67	AVLRFOFFNODECORE Core;
68	/** Size of the segment */
69	size_t cbSeg;
70	/** Data for this segment */
71	uint8_t *pbSeg;
72	} DRVDISKSEGMENT, *PDRVDISKSEGMENT;
73
74	/**
75	* VD I/O request state.
76	*/
77	typedef enum VDIOREQSTATE
78	{
79	/** Invalid. */
80	VDIOREQSTATE_INVALID = 0,
81	/** The request is not in use and resides on the free list. */
82	VDIOREQSTATE_FREE,
83	/** The request was just allocated and is not active. */
84	VDIOREQSTATE_ALLOCATED,
85	/** The request was allocated and is in use. */
86	VDIOREQSTATE_ACTIVE,
87	/** The request was suspended and is not actively processed. */
88	VDIOREQSTATE_SUSPENDED,
89	/** The request is in the last step of completion and syncs memory. */
90	VDIOREQSTATE_COMPLETING,
91	/** The request completed. */
92	VDIOREQSTATE_COMPLETED,
93	/** The request was aborted but wasn't returned as complete from the storage
94	* layer below us. */
95	VDIOREQSTATE_CANCELED,
96	/** 32bit hack. */
97	VDIOREQSTATE_32BIT_HACK = 0x7fffffff
98	} VDIOREQSTATE;
99
100	/**
101	* VD I/O Request.
102	*/
103	typedef struct PDMMEDIAEXIOREQINT
104	{
105	/** List node for the list of allocated requests. */
106	RTLISTNODE NdAllocatedList;
107	/** List for requests waiting for I/O memory or on the redo list. */
108	RTLISTNODE NdLstWait;
109	/** I/O request type. */
110	PDMMEDIAEXIOREQTYPE enmType;
111	/** Request state. */
112	volatile VDIOREQSTATE enmState;
113	/** I/O request ID. */
114	PDMMEDIAEXIOREQID uIoReqId;
115	/** Pointer to the disk container. */
116	PDRVRAMDISK pDisk;
117	/** Flags. */
118	uint32_t fFlags;
119	/** Timestamp when the request was submitted. */
120	uint64_t tsSubmit;
121	/** Type dependent data. */
122	union
123	{
124	/** Read/Write request sepcific data. */
125	struct
126	{
127	/** Start offset of the request. */
128	uint64_t offStart;
129	/** Size of the request. */
130	size_t cbReq;
131	/** Size left for this request. */
132	size_t cbReqLeft;
133	/** Size of the allocated I/O buffer. */
134	size_t cbIoBuf;
135	/** I/O buffer descriptor. */
136	IOBUFDESC IoBuf;
137	} ReadWrite;
138	/** Discard specific data. */
139	struct
140	{
141	/** Pointer to array of ranges to discard. */
142	PRTRANGE paRanges;
143	/** Number of ranges to discard. */
144	unsigned cRanges;
145	} Discard;
146	};
147	/** Allocator specific memory - variable size. */
148	uint8_t abAlloc[1];
149	} PDMMEDIAEXIOREQINT;
150	/** Pointer to a VD I/O request. */
151	typedef PDMMEDIAEXIOREQINT *PPDMMEDIAEXIOREQINT;
152
153	/**
154	* Structure for holding a list of allocated requests.
155	*/
156	typedef struct VDLSTIOREQALLOC
157	{
158	/** Mutex protecting the table of allocated requests. */
159	RTSEMFASTMUTEX hMtxLstIoReqAlloc;
160	/** List anchor. */
161	RTLISTANCHOR LstIoReqAlloc;
162	} VDLSTIOREQALLOC;
163	typedef VDLSTIOREQALLOC *PVDLSTIOREQALLOC;
164
165	/** Number of bins for allocated requests. */
166	#define DRVVD_VDIOREQ_ALLOC_BINS 8
167
168	/**
169	* Disk integrity driver instance data.
170	*
171	* @implements PDMIMEDIA
172	*/
173	typedef struct DRVRAMDISK
174	{
175	/** Pointer driver instance. */
176	PPDMDRVINS pDrvIns;
177	/** Pointer to the media driver below us.
178	* This is NULL if the media is not mounted. */
179	PPDMIMEDIA pDrvMedia;
180	/** Our media interface */
181	PDMIMEDIA IMedia;
182
183	/** The media port interface above. */
184	PPDMIMEDIAPORT pDrvMediaPort;
185	/** Media port interface */
186	PDMIMEDIAPORT IMediaPort;
187
188	/** Flag whether the RAM disk was pre allocated. */
189	bool fPreallocRamDisk;
190	/** Flag whether to report a non totating medium. */
191	bool fNonRotational;
192	/** AVL tree containing the disk blocks to check. */
193	PAVLRFOFFTREE pTreeSegments;
194	/** Size of the disk. */
195	uint64_t cbDisk;
196	/** Size of one sector. */
197	uint32_t cbSector;
198
199	/** Worker request queue. */
200	RTREQQUEUE hReqQ;
201	/** Worker thread for async requests. */
202	RTTHREAD hThrdWrk;
203
204	/** @name IMEDIAEX interface support specific members.
205	* @{ */
206	/** Pointer to the IMEDIAEXPORT interface above us. */
207	PPDMIMEDIAEXPORT pDrvMediaExPort;
208	/** Our extended media interface. */
209	PDMIMEDIAEX IMediaEx;
210	/** Memory cache for the I/O requests. */
211	RTMEMCACHE hIoReqCache;
212	/** I/O buffer manager. */
213	IOBUFMGR hIoBufMgr;
214	/** Active request counter. */
215	volatile uint32_t cIoReqsActive;
216	/** Bins for allocated requests. */
217	VDLSTIOREQALLOC aIoReqAllocBins[DRVVD_VDIOREQ_ALLOC_BINS];
218	/** List of requests for I/O memory to be available - VDIOREQ::NdLstWait. */
219	RTLISTANCHOR LstIoReqIoBufWait;
220	/** Critical section protecting the list of requests waiting for I/O memory. */
221	RTCRITSECT CritSectIoReqsIoBufWait;
222	/** Number of requests waiting for a I/O buffer. */
223	volatile uint32_t cIoReqsWaiting;
224	/** Flag whether we have to resubmit requests on resume because the
225	* VM was suspended due to a recoverable I/O error.
226	*/
227	volatile bool fRedo;
228	/** List of requests we have to redo. */
229	RTLISTANCHOR LstIoReqRedo;
230	/** Criticial section protecting the list of waiting requests. */
231	RTCRITSECT CritSectIoReqRedo;
232	/** Number of errors logged so far. */
233	unsigned cErrors;
234	/** @} */
235
236	} DRVRAMDISK;
237
238
239	static void drvramdiskMediaExIoReqComplete(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq,
240	int rcReq);
241
242	/**
243	* Record a successful write to the virtual disk.
244	*
245	* @returns VBox status code.
246	* @param pThis Disk integrity driver instance data.
247	* @param pSgBuf The S/G buffer holding the data to write.
248	* @param off Start offset.
249	* @param cbWrite Number of bytes to record.
250	*/
251	static int drvramdiskWriteWorker(PDRVRAMDISK pThis, PRTSGBUF pSgBuf,
252	uint64_t off, size_t cbWrite)
253	{
254	int rc = VINF_SUCCESS;
255
256	LogFlowFunc(("pThis=%#p pSgBuf=%#p off=%llx cbWrite=%u\n",
257	pThis, pSgBuf, off, cbWrite));
258
259	/* Update the segments */
260	size_t cbLeft = cbWrite;
261	RTFOFF offCurr = (RTFOFF)off;
262
263	while (cbLeft)
264	{
265	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offCurr);
266	size_t cbRange = 0;
267	bool fSet = false;
268	unsigned offSeg = 0;
269
270	if (!pSeg)
271	{
272	/* Get next segment */
273	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offCurr, true);
274	if ( !pSeg
275	\|\| offCurr + (RTFOFF)cbLeft <= pSeg->Core.Key)
276	cbRange = cbLeft;
277	else
278	cbRange = pSeg->Core.Key - offCurr;
279
280	Assert(cbRange % 512 == 0);
281
282	/* Create new segment */
283	pSeg = (PDRVDISKSEGMENT)RTMemAllocZ(sizeof(DRVDISKSEGMENT));
284	if (pSeg)
285	{
286	pSeg->Core.Key = offCurr;
287	pSeg->Core.KeyLast = offCurr + (RTFOFF)cbRange - 1;
288	pSeg->cbSeg = cbRange;
289	pSeg->pbSeg = (uint8_t *)RTMemAllocZ(cbRange);
290	if (!pSeg->pbSeg)
291	RTMemFree(pSeg);
292	else
293	{
294	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
295	AssertMsg(fInserted, ("Bug!\n")); RT_NOREF(fInserted);
296	fSet = true;
297	}
298	}
299	}
300	else
301	{
302	fSet = true;
303	offSeg = offCurr - pSeg->Core.Key;
304	cbRange = RT_MIN(cbLeft, (size_t)(pSeg->Core.KeyLast + 1 - offCurr));
305	}
306
307	if (fSet)
308	{
309	AssertPtr(pSeg);
310	size_t cbCopied = RTSgBufCopyToBuf(pSgBuf, pSeg->pbSeg + offSeg, cbRange);
311	Assert(cbCopied == cbRange); RT_NOREF(cbCopied);
312	}
313	else
314	RTSgBufAdvance(pSgBuf, cbRange);
315
316	offCurr += cbRange;
317	cbLeft -= cbRange;
318	}
319
320	return rc;
321	}
322
323	/**
324	* Read data from the ram disk.
325	*
326	* @returns VBox status code.
327	* @param pThis RAM disk driver instance data.
328	* @param pSgBuf The S/G buffer to store the data.
329	* @param off Start offset.
330	* @param cbRead Number of bytes to read.
331	*/
332	static int drvramdiskReadWorker(PDRVRAMDISK pThis, PRTSGBUF pSgBuf,
333	uint64_t off, size_t cbRead)
334	{
335	int rc = VINF_SUCCESS;
336
337	LogFlowFunc(("pThis=%#p pSgBuf=%#p off=%llx cbRead=%u\n",
338	pThis, pSgBuf, off, cbRead));
339
340	Assert(off % 512 == 0);
341	Assert(cbRead % 512 == 0);
342
343	/* Compare read data */
344	size_t cbLeft = cbRead;
345	RTFOFF offCurr = (RTFOFF)off;
346
347	while (cbLeft)
348	{
349	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offCurr);
350	size_t cbRange = 0;
351	bool fCmp = false;
352	unsigned offSeg = 0;
353
354	if (!pSeg)
355	{
356	/* Get next segment */
357	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offCurr, true);
358	if ( !pSeg
359	\|\| offCurr + (RTFOFF)cbLeft <= pSeg->Core.Key)
360	cbRange = cbLeft;
361	else
362	cbRange = pSeg->Core.Key - offCurr;
363
364	/* No segment means everything should be 0 for this part. */
365	RTSgBufSet(pSgBuf, 0, cbRange);
366	}
367	else
368	{
369	fCmp = true;
370	offSeg = offCurr - pSeg->Core.Key;
371	cbRange = RT_MIN(cbLeft, (size_t)(pSeg->Core.KeyLast + 1 - offCurr));
372
373	RTSGSEG Seg;
374	RTSGBUF SgBufSrc;
375
376	Seg.cbSeg = cbRange;
377	Seg.pvSeg = pSeg->pbSeg + offSeg;
378
379	RTSgBufInit(&SgBufSrc, &Seg, 1);
380	RTSgBufCopy(pSgBuf, &SgBufSrc, cbRange);
381	}
382
383	offCurr += cbRange;
384	cbLeft -= cbRange;
385	}
386
387	return rc;
388	}
389
390	/**
391	* Discards the given ranges from the disk.
392	*
393	* @returns VBox status code.
394	* @param pThis Disk integrity driver instance data.
395	* @param paRanges Array of ranges to discard.
396	* @param cRanges Number of ranges in the array.
397	*/
398	static int drvramdiskDiscardRecords(PDRVRAMDISK pThis, PCRTRANGE paRanges, unsigned cRanges)
399	{
400	int rc = VINF_SUCCESS;
401
402	LogFlowFunc(("pThis=%#p paRanges=%#p cRanges=%u\n", pThis, paRanges, cRanges));
403
404	for (unsigned i = 0; i < cRanges; i++)
405	{
406	uint64_t offStart = paRanges[i].offStart;
407	size_t cbLeft = paRanges[i].cbRange;
408
409	LogFlowFunc(("Discarding off=%llu cbRange=%zu\n", offStart, cbLeft));
410
411	while (cbLeft)
412	{
413	size_t cbRange;
414	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offStart);
415
416	if (!pSeg)
417	{
418	/* Get next segment */
419	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offStart, true);
420	if ( !pSeg
421	\|\| (RTFOFF)offStart + (RTFOFF)cbLeft <= pSeg->Core.Key)
422	cbRange = cbLeft;
423	else
424	cbRange = pSeg->Core.Key - offStart;
425
426	Assert(!(cbRange % 512));
427	}
428	else
429	{
430	size_t cbPreLeft, cbPostLeft;
431
432	cbRange = RT_MIN(cbLeft, pSeg->Core.KeyLast - offStart + 1);
433	cbPreLeft = offStart - pSeg->Core.Key;
434	cbPostLeft = pSeg->cbSeg - cbRange - cbPreLeft;
435
436	Assert(!(cbRange % 512));
437	Assert(!(cbPreLeft % 512));
438	Assert(!(cbPostLeft % 512));
439
440	LogFlowFunc(("cbRange=%zu cbPreLeft=%zu cbPostLeft=%zu\n",
441	cbRange, cbPreLeft, cbPostLeft));
442
443	RTAvlrFileOffsetRemove(pThis->pTreeSegments, pSeg->Core.Key);
444
445	if (!cbPreLeft && !cbPostLeft)
446	{
447	/* Just free the whole segment. */
448	LogFlowFunc(("Freeing whole segment pSeg=%#p\n", pSeg));
449	RTMemFree(pSeg->pbSeg);
450	RTMemFree(pSeg);
451	}
452	else if (cbPreLeft && !cbPostLeft)
453	{
454	/* Realloc to new size and insert. */
455	LogFlowFunc(("Realloc segment pSeg=%#p\n", pSeg));
456	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPreLeft);
457	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, sizeof(DRVDISKSEGMENT));
458	pSeg->Core.KeyLast = pSeg->Core.Key + cbPreLeft - 1;
459	pSeg->cbSeg = cbPreLeft;
460	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
461	Assert(fInserted); RT_NOREF(fInserted);
462	}
463	else if (!cbPreLeft && cbPostLeft)
464	{
465	/* Move data to the front and realloc. */
466	LogFlowFunc(("Move data and realloc segment pSeg=%#p\n", pSeg));
467	memmove(pSeg->pbSeg, pSeg->pbSeg + cbRange, cbPostLeft);
468	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, sizeof(DRVDISKSEGMENT));
469	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPostLeft);
470	pSeg->Core.Key += cbRange;
471	pSeg->cbSeg = cbPostLeft;
472	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
473	Assert(fInserted); RT_NOREF(fInserted);
474	}
475	else
476	{
477	/* Split the segment into 2 new segments. */
478	LogFlowFunc(("Split segment pSeg=%#p\n", pSeg));
479	PDRVDISKSEGMENT pSegPost = (PDRVDISKSEGMENT)RTMemAllocZ(sizeof(DRVDISKSEGMENT));
480	if (pSegPost)
481	{
482	pSegPost->Core.Key = pSeg->Core.Key + cbPreLeft + cbRange;
483	pSegPost->Core.KeyLast = pSeg->Core.KeyLast;
484	pSegPost->cbSeg = cbPostLeft;
485	pSegPost->pbSeg = (uint8_t *)RTMemAllocZ(cbPostLeft);
486	if (!pSegPost->pbSeg)
487	RTMemFree(pSegPost);
488	else
489	{
490	memcpy(pSegPost->pbSeg, pSeg->pbSeg + cbPreLeft + cbRange, cbPostLeft);
491	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSegPost->Core);
492	Assert(fInserted); RT_NOREF(fInserted);
493	}
494	}
495
496	/* Shrink the current segment. */
497	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPreLeft);
498	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, sizeof(DRVDISKSEGMENT));
499	pSeg->Core.KeyLast = pSeg->Core.Key + cbPreLeft - 1;
500	pSeg->cbSeg = cbPreLeft;
501	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
502	Assert(fInserted); RT_NOREF(fInserted);
503	} /* if (cbPreLeft && cbPostLeft) */
504	}
505
506	offStart += cbRange;
507	cbLeft -= cbRange;
508	}
509	}
510
511	LogFlowFunc(("returns rc=%Rrc\n", rc));
512	return rc;
513	}
514
515	/* -=-=-=-=- IMedia -=-=-=-=- */
516
517
518	/*********************************************************************************************************************************
519	* Media interface methods *
520	*********************************************************************************************************************************/
521
522	/** @copydoc PDMIMEDIA::pfnRead */
523	static DECLCALLBACK(int) drvramdiskRead(PPDMIMEDIA pInterface,
524	uint64_t off, void *pvBuf, size_t cbRead)
525	{
526	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
527	RTSGSEG Seg;
528	RTSGBUF SgBuf;
529
530	Seg.cbSeg = cbRead;
531	Seg.pvSeg = pvBuf;
532	RTSgBufInit(&SgBuf, &Seg, 1);
533	return drvramdiskReadWorker(pThis, &SgBuf, off, cbRead);
534	}
535
536	/** @copydoc PDMIMEDIA::pfnWrite */
537	static DECLCALLBACK(int) drvramdiskWrite(PPDMIMEDIA pInterface,
538	uint64_t off, const void *pvBuf,
539	size_t cbWrite)
540	{
541	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
542	RTSGSEG Seg;
543	RTSGBUF SgBuf;
544
545	Seg.cbSeg = cbWrite;
546	Seg.pvSeg = (void *)pvBuf;
547	RTSgBufInit(&SgBuf, &Seg, 1);
548	return drvramdiskWriteWorker(pThis, &SgBuf, off, cbWrite);
549	}
550
551	/** @copydoc PDMIMEDIA::pfnFlush */
552	static DECLCALLBACK(int) drvramdiskFlush(PPDMIMEDIA pInterface)
553	{
554	RT_NOREF1(pInterface);
555	/* Nothing to do here. */
556	return VINF_SUCCESS;
557	}
558
559	/** @copydoc PDMIMEDIA::pfnGetSize */
560	static DECLCALLBACK(uint64_t) drvramdiskGetSize(PPDMIMEDIA pInterface)
561	{
562	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
563	return pThis->cbDisk;
564	}
565
566	/** @interface_method_impl{PDMIMEDIA,pfnBiosIsVisible} */
567	static DECLCALLBACK(bool) drvramdiskBiosIsVisible(PPDMIMEDIA pInterface)
568	{
569	RT_NOREF1(pInterface);
570	return false;
571	}
572
573	/** @copydoc PDMIMEDIA::pfnGetType */
574	static DECLCALLBACK(PDMMEDIATYPE) drvramdiskGetType(PPDMIMEDIA pInterface)
575	{
576	RT_NOREF1(pInterface);
577	return PDMMEDIATYPE_HARD_DISK;
578	}
579
580	/** @copydoc PDMIMEDIA::pfnIsReadOnly */
581	static DECLCALLBACK(bool) drvramdiskIsReadOnly(PPDMIMEDIA pInterface)
582	{
583	RT_NOREF1(pInterface);
584	return false; /** @todo */
585	}
586
587	/** @copydoc PDMIMEDIA::pfnBiosGetPCHSGeometry */
588	static DECLCALLBACK(int) drvramdiskBiosGetPCHSGeometry(PPDMIMEDIA pInterface,
589	PPDMMEDIAGEOMETRY pPCHSGeometry)
590	{
591	RT_NOREF2(pInterface, pPCHSGeometry);
592	return VERR_PDM_GEOMETRY_NOT_SET;
593	}
594
595	/** @copydoc PDMIMEDIA::pfnBiosSetPCHSGeometry */
596	static DECLCALLBACK(int) drvramdiskBiosSetPCHSGeometry(PPDMIMEDIA pInterface,
597	PCPDMMEDIAGEOMETRY pPCHSGeometry)
598	{
599	RT_NOREF2(pInterface, pPCHSGeometry);
600	return VERR_NOT_IMPLEMENTED;
601	}
602
603	/** @copydoc PDMIMEDIA::pfnBiosGetLCHSGeometry */
604	static DECLCALLBACK(int) drvramdiskBiosGetLCHSGeometry(PPDMIMEDIA pInterface,
605	PPDMMEDIAGEOMETRY pLCHSGeometry)
606	{
607	RT_NOREF2(pInterface, pLCHSGeometry);
608	return VERR_PDM_GEOMETRY_NOT_SET;
609	}
610
611	/** @copydoc PDMIMEDIA::pfnBiosSetLCHSGeometry */
612	static DECLCALLBACK(int) drvramdiskBiosSetLCHSGeometry(PPDMIMEDIA pInterface,
613	PCPDMMEDIAGEOMETRY pLCHSGeometry)
614	{
615	RT_NOREF2(pInterface, pLCHSGeometry);
616	return VERR_NOT_IMPLEMENTED;
617	}
618
619	/** @copydoc PDMIMEDIA::pfnGetUuid */
620	static DECLCALLBACK(int) drvramdiskGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
621	{
622	RT_NOREF1(pInterface);
623	return RTUuidClear(pUuid);
624	}
625
626	/** @copydoc PDMIMEDIA::pfnGetSectorSize */
627	static DECLCALLBACK(uint32_t) drvramdiskGetSectorSize(PPDMIMEDIA pInterface)
628	{
629	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
630	return pThis->cbSector;
631	}
632
633	/** @copydoc PDMIMEDIA::pfnDiscard */
634	static DECLCALLBACK(int) drvramdiskDiscard(PPDMIMEDIA pInterface, PCRTRANGE paRanges, unsigned cRanges)
635	{
636	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
637	return drvramdiskDiscardRecords(pThis, paRanges, cRanges);
638	}
639
640	/** @copydoc PDMIMEDIA::pfnReadPcBios */
641	static DECLCALLBACK(int) drvramdiskReadPcBios(PPDMIMEDIA pInterface,
642	uint64_t off, void *pvBuf, size_t cbRead)
643	{
644	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
645	RTSGSEG Seg;
646	RTSGBUF SgBuf;
647
648	Seg.cbSeg = cbRead;
649	Seg.pvSeg = pvBuf;
650	RTSgBufInit(&SgBuf, &Seg, 1);
651	return drvramdiskReadWorker(pThis, &SgBuf, off, cbRead);
652	}
653
654	/** @interface_method_impl{PDMIMEDIA,pfnIsNonRotational} */
655	static DECLCALLBACK(bool) drvramdiskIsNonRotational(PPDMIMEDIA pInterface)
656	{
657	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
658	return pThis->fNonRotational;
659	}
660
661	/** @interface_method_impl{PDMIMEDIA,pfnGetRegionCount} */
662	static DECLCALLBACK(uint32_t) drvramdiskGetRegionCount(PPDMIMEDIA pInterface)
663	{
664	RT_NOREF(pInterface);
665	return 1;
666	}
667
668	/** @interface_method_impl{PDMIMEDIA,pfnQueryRegionProperties} */
669	static DECLCALLBACK(int) drvramdiskQueryRegionProperties(PPDMIMEDIA pInterface, uint32_t uRegion, uint64_t *pu64LbaStart,
670	uint64_t pcBlocks, uint64_t pcbBlock,
671	PVDREGIONDATAFORM penmDataForm)
672	{
673	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
674	AssertReturn(uRegion == 0, VERR_INVALID_PARAMETER);
675	if (pu64LbaStart)
676	*pu64LbaStart = 0;
677	if (pcBlocks)
678	*pcBlocks = pThis->cbDisk / pThis->cbSector;
679	if (pcbBlock)
680	*pcbBlock = pThis->cbSector;
681	if (penmDataForm)
682	*penmDataForm = VDREGIONDATAFORM_RAW;
683	return VINF_SUCCESS;
684	}
685
686	/** @interface_method_impl{PDMIMEDIA,pfnQueryRegionPropertiesForLba} */
687	static DECLCALLBACK(int) drvramdiskQueryRegionPropertiesForLba(PPDMIMEDIA pInterface, uint64_t u64LbaStart,
688	uint32_t puRegion, uint64_t pcBlocks,
689	uint64_t *pcbBlock, PVDREGIONDATAFORM penmDataForm)
690	{
691	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMedia);
692	RT_NOREF(u64LbaStart);
693	if (puRegion)
694	*puRegion = 0;
695	if (pcBlocks)
696	*pcBlocks = pThis->cbDisk / pThis->cbSector;
697	if (pcbBlock)
698	*pcbBlock = pThis->cbSector;
699	if (penmDataForm)
700	*penmDataForm = VDREGIONDATAFORM_RAW;
701	return VINF_SUCCESS;
702	}
703
704
705	/*********************************************************************************************************************************
706	* Extended media interface methods *
707	*********************************************************************************************************************************/
708
709	static void drvramdiskMediaExIoReqWarningOutOfMemory(PPDMDRVINS pDrvIns)
710	{
711	int rc;
712	LogRel(("RamDisk#%u: Out of memory\n", pDrvIns->iInstance));
713	rc = PDMDrvHlpVMSetRuntimeError(pDrvIns, VMSETRTERR_FLAGS_SUSPEND \| VMSETRTERR_FLAGS_NO_WAIT, "DrvRamDisk_OOM",
714	N_("There is not enough free memory for the ramdisk"));
715	AssertRC(rc);
716	}
717
718	/**
719	* Checks whether a given status code indicates a recoverable error
720	* suspending the VM if it is.
721	*
722	* @returns Flag indicating whether the status code is a recoverable error
723	* (full disk, broken network connection).
724	* @param pThis VBox disk container instance data.
725	* @param rc Status code to check.
726	*/
727	static bool drvramdiskMediaExIoReqIsRedoSetWarning(PDRVRAMDISK pThis, int rc)
728	{
729	if (rc == VERR_NO_MEMORY)
730	{
731	if (ASMAtomicCmpXchgBool(&pThis->fRedo, true, false))
732	drvramdiskMediaExIoReqWarningOutOfMemory(pThis->pDrvIns);
733	return true;
734	}
735
736	return false;
737	}
738
739	/**
740	* Syncs the memory buffers between the I/O request allocator and the internal buffer.
741	*
742	* @returns VBox status code.
743	* @param pThis VBox disk container instance data.
744	* @param pIoReq I/O request to sync.
745	* @param fToIoBuf Flag indicating the sync direction.
746	* true to copy data from the allocators buffer to our internal buffer.
747	* false for the other direction.
748	*/
749	DECLINLINE(int) drvramdiskMediaExIoReqBufSync(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq, bool fToIoBuf)
750	{
751	int rc = VINF_SUCCESS;
752
753	Assert(pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ \|\| pIoReq->enmType == PDMMEDIAEXIOREQTYPE_WRITE);
754
755	/* Make sure the buffer is reset. */
756	RTSgBufReset(&pIoReq->ReadWrite.IoBuf.SgBuf);
757
758	if (fToIoBuf)
759	rc = pThis->pDrvMediaExPort->pfnIoReqCopyToBuf(pThis->pDrvMediaExPort, pIoReq, &pIoReq->abAlloc[0],
760	(uint32_t)(pIoReq->ReadWrite.cbReq - pIoReq->ReadWrite.cbReqLeft),
761	&pIoReq->ReadWrite.IoBuf.SgBuf,
762	RT_MIN(pIoReq->ReadWrite.cbIoBuf, pIoReq->ReadWrite.cbReqLeft));
763	else
764	rc = pThis->pDrvMediaExPort->pfnIoReqCopyFromBuf(pThis->pDrvMediaExPort, pIoReq, &pIoReq->abAlloc[0],
765	(uint32_t)(pIoReq->ReadWrite.cbReq - pIoReq->ReadWrite.cbReqLeft),
766	&pIoReq->ReadWrite.IoBuf.SgBuf,
767	RT_MIN(pIoReq->ReadWrite.cbIoBuf, pIoReq->ReadWrite.cbReqLeft));
768
769	RTSgBufReset(&pIoReq->ReadWrite.IoBuf.SgBuf);
770	return rc;
771	}
772
773	/**
774	* Hashes the I/O request ID to an index for the allocated I/O request bin.
775	*/
776	DECLINLINE(unsigned) drvramdiskMediaExIoReqIdHash(PDMMEDIAEXIOREQID uIoReqId)
777	{
778	return uIoReqId % DRVVD_VDIOREQ_ALLOC_BINS; /** @todo Find something better? */
779	}
780
781	/**
782	* Inserts the given I/O request in to the list of allocated I/O requests.
783	*
784	* @returns VBox status code.
785	* @param pThis VBox disk container instance data.
786	* @param pIoReq I/O request to insert.
787	*/
788	static int drvramdiskMediaExIoReqInsert(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
789	{
790	int rc = VINF_SUCCESS;
791	unsigned idxBin = drvramdiskMediaExIoReqIdHash(pIoReq->uIoReqId);
792
793	rc = RTSemFastMutexRequest(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
794	if (RT_SUCCESS(rc))
795	{
796	/* Search for conflicting I/O request ID. */
797	PPDMMEDIAEXIOREQINT pIt;
798	RTListForEach(&pThis->aIoReqAllocBins[idxBin].LstIoReqAlloc, pIt, PDMMEDIAEXIOREQINT, NdAllocatedList)
799	{
800	if (RT_UNLIKELY(pIt->uIoReqId == pIoReq->uIoReqId))
801	{
802	rc = VERR_PDM_MEDIAEX_IOREQID_CONFLICT;
803	break;
804	}
805	}
806	if (RT_SUCCESS(rc))
807	RTListAppend(&pThis->aIoReqAllocBins[idxBin].LstIoReqAlloc, &pIoReq->NdAllocatedList);
808	RTSemFastMutexRelease(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
809	}
810
811	return rc;
812	}
813
814	/**
815	* Removes the given I/O request from the list of allocated I/O requests.
816	*
817	* @returns VBox status code.
818	* @param pThis VBox disk container instance data.
819	* @param pIoReq I/O request to insert.
820	*/
821	static int drvramdiskMediaExIoReqRemove(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
822	{
823	int rc = VINF_SUCCESS;
824	unsigned idxBin = drvramdiskMediaExIoReqIdHash(pIoReq->uIoReqId);
825
826	rc = RTSemFastMutexRequest(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
827	if (RT_SUCCESS(rc))
828	{
829	RTListNodeRemove(&pIoReq->NdAllocatedList);
830	RTSemFastMutexRelease(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
831	}
832
833	return rc;
834	}
835
836	/**
837	* I/O request completion worker.
838	*
839	* @returns VBox status code.
840	* @param pThis VBox disk container instance data.
841	* @param pIoReq I/O request to complete.
842	* @param rcReq The status code the request completed with.
843	* @param fUpNotify Flag whether to notify the driver/device above us about the completion.
844	*/
845	static int drvramdiskMediaExIoReqCompleteWorker(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq, int rcReq, bool fUpNotify)
846	{
847	int rc;
848	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_COMPLETING, VDIOREQSTATE_ACTIVE);
849	if (fXchg)
850	ASMAtomicDecU32(&pThis->cIoReqsActive);
851	else
852	{
853	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
854	rcReq = VERR_PDM_MEDIAEX_IOREQ_CANCELED;
855	}
856
857	ASMAtomicXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_COMPLETED);
858
859	/*
860	* Leave a release log entry if the request was active for more than 25 seconds
861	* (30 seconds is the timeout of the guest).
862	*/
863	uint64_t tsNow = RTTimeMilliTS();
864	if (tsNow - pIoReq->tsSubmit >= 25 * 1000)
865	{
866	const char *pcszReq = NULL;
867
868	switch (pIoReq->enmType)
869	{
870	case PDMMEDIAEXIOREQTYPE_READ:
871	pcszReq = "Read";
872	break;
873	case PDMMEDIAEXIOREQTYPE_WRITE:
874	pcszReq = "Write";
875	break;
876	case PDMMEDIAEXIOREQTYPE_FLUSH:
877	pcszReq = "Flush";
878	break;
879	case PDMMEDIAEXIOREQTYPE_DISCARD:
880	pcszReq = "Discard";
881	break;
882	default:
883	pcszReq = "<Invalid>";
884	}
885
886	LogRel(("RamDisk#%u: %s request was active for %llu seconds\n",
887	pThis->pDrvIns->iInstance, pcszReq, (tsNow - pIoReq->tsSubmit) / 1000));
888	}
889
890	if (RT_FAILURE(rcReq))
891	{
892	/* Log the error. */
893	if (pThis->cErrors++ < 100)
894	{
895	if (rcReq == VERR_PDM_MEDIAEX_IOREQ_CANCELED)
896	{
897	if (pIoReq->enmType == PDMMEDIAEXIOREQTYPE_FLUSH)
898	LogRel(("RamDisk#%u: Aborted flush returned rc=%Rrc\n",
899	pThis->pDrvIns->iInstance, rcReq));
900	else
901	LogRel(("RamDisk#%u: Aborted %s (%u bytes left) returned rc=%Rrc\n",
902	pThis->pDrvIns->iInstance,
903	pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ
904	? "read"
905	: "write",
906	pIoReq->ReadWrite.cbReqLeft, rcReq));
907	}
908	else
909	{
910	if (pIoReq->enmType == PDMMEDIAEXIOREQTYPE_FLUSH)
911	LogRel(("RamDisk#%u: Flush returned rc=%Rrc\n",
912	pThis->pDrvIns->iInstance, rcReq));
913	else
914	LogRel(("RamDisk#%u: %s (%u bytes left) returned rc=%Rrc\n",
915	pThis->pDrvIns->iInstance,
916	pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ
917	? "Read"
918	: "Write",
919	pIoReq->ReadWrite.cbReqLeft, rcReq));
920	}
921	}
922	}
923
924	if (fUpNotify)
925	{
926	rc = pThis->pDrvMediaExPort->pfnIoReqCompleteNotify(pThis->pDrvMediaExPort,
927	pIoReq, &pIoReq->abAlloc[0], rcReq);
928	AssertRC(rc);
929	}
930
931	return rcReq;
932	}
933
934	/**
935	* Allocates a memory buffer suitable for I/O for the given request.
936	*
937	* @returns VBox status code.
938	* @retval VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS if there is no I/O memory available to allocate and
939	* the request was placed on a waiting list.
940	* @param pThis VBox disk container instance data.
941	* @param pIoReq I/O request to allocate memory for.
942	* @param cb Size of the buffer.
943	*/
944	DECLINLINE(int) drvramdiskMediaExIoReqBufAlloc(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq, size_t cb)
945	{
946	int rc = IOBUFMgrAllocBuf(pThis->hIoBufMgr, &pIoReq->ReadWrite.IoBuf, cb, &pIoReq->ReadWrite.cbIoBuf);
947	if (rc == VERR_NO_MEMORY)
948	{
949	RTCritSectEnter(&pThis->CritSectIoReqsIoBufWait);
950	RTListAppend(&pThis->LstIoReqIoBufWait, &pIoReq->NdLstWait);
951	RTCritSectLeave(&pThis->CritSectIoReqsIoBufWait);
952	ASMAtomicIncU32(&pThis->cIoReqsWaiting);
953	rc = VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS;
954	}
955
956	return rc;
957	}
958
959	/**
960	* Worker for a read request.
961	*
962	* @returns VBox status code.
963	* @param pThis RAM disk container instance data.
964	* @param pIoReq The read request.
965	*/
966	static DECLCALLBACK(int) drvramdiskIoReqReadWorker(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
967	{
968	size_t cbReqIo = RT_MIN(pIoReq->ReadWrite.cbReqLeft, pIoReq->ReadWrite.cbIoBuf);
969	int rc = drvramdiskReadWorker(pThis, &pIoReq->ReadWrite.IoBuf.SgBuf, pIoReq->ReadWrite.offStart,
970	cbReqIo);
971	drvramdiskMediaExIoReqComplete(pThis, pIoReq, rc);
972	return VINF_SUCCESS;
973	}
974
975	/**
976	* Worker for a read request.
977	*
978	* @returns VBox status code.
979	* @param pThis RAM disk container instance data.
980	* @param pIoReq The read request.
981	*/
982	static DECLCALLBACK(int) drvramdiskIoReqWriteWorker(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
983	{
984	size_t cbReqIo = RT_MIN(pIoReq->ReadWrite.cbReqLeft, pIoReq->ReadWrite.cbIoBuf);
985	int rc = drvramdiskWriteWorker(pThis, &pIoReq->ReadWrite.IoBuf.SgBuf, pIoReq->ReadWrite.offStart,
986	cbReqIo);
987	drvramdiskMediaExIoReqComplete(pThis, pIoReq, rc);
988	return VINF_SUCCESS;
989	}
990
991	/**
992	* Kicks the worker thread out of the loop.
993	*
994	* @returns VBox status code.
995	* @retval VERR_CANCELLED;
996	*/
997	static DECLCALLBACK(int) drvramdiskDestructQueue(void)
998	{
999	return VERR_CANCELLED;
1000	}
1001
1002	/**
1003	* Processes a read/write request.
1004	*
1005	* @returns VBox status code.
1006	* @param pThis VBox disk container instance data.
1007	* @param pIoReq I/O request to process.
1008	* @param fUpNotify Flag whether to notify the driver/device above us about the completion.
1009	*/
1010	static int drvramdiskMediaExIoReqReadWriteProcess(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq, bool fUpNotify)
1011	{
1012	int rc = VINF_SUCCESS;
1013
1014	Assert(pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ \|\| pIoReq->enmType == PDMMEDIAEXIOREQTYPE_WRITE);
1015
1016	while ( pIoReq->ReadWrite.cbReqLeft
1017	&& rc == VINF_SUCCESS)
1018	{
1019	if (pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ)
1020	rc = RTReqQueueCallEx(pThis->hReqQ, NULL, 0, RTREQFLAGS_NO_WAIT,
1021	(PFNRT)drvramdiskIoReqReadWorker, 2, pThis, pIoReq);
1022	else
1023	{
1024	/* Sync memory buffer from the request initiator. */
1025	rc = drvramdiskMediaExIoReqBufSync(pThis, pIoReq, true /* fToIoBuf */);
1026	if (RT_SUCCESS(rc))
1027	rc = RTReqQueueCallEx(pThis->hReqQ, NULL, 0, RTREQFLAGS_NO_WAIT,
1028	(PFNRT)drvramdiskIoReqWriteWorker, 2, pThis, pIoReq);
1029	}
1030
1031	if (rc == VINF_SUCCESS)
1032	rc = VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS;
1033	}
1034
1035	if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
1036	{
1037	Assert(!pIoReq->ReadWrite.cbReqLeft \|\| RT_FAILURE(rc));
1038	rc = drvramdiskMediaExIoReqCompleteWorker(pThis, pIoReq, rc, fUpNotify);
1039	}
1040
1041	return rc;
1042	}
1043
1044
1045	/**
1046	* Frees a I/O memory buffer allocated previously.
1047	*
1048	* @param pThis VBox disk container instance data.
1049	* @param pIoReq I/O request for which to free memory.
1050	*/
1051	DECLINLINE(void) drvramdiskMediaExIoReqBufFree(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
1052	{
1053	if ( pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ
1054	\|\| pIoReq->enmType == PDMMEDIAEXIOREQTYPE_WRITE)
1055	{
1056	IOBUFMgrFreeBuf(&pIoReq->ReadWrite.IoBuf);
1057
1058	if (ASMAtomicReadU32(&pThis->cIoReqsWaiting) > 0)
1059	{
1060	/* Try to process as many requests as possible. */
1061	RTCritSectEnter(&pThis->CritSectIoReqsIoBufWait);
1062	PPDMMEDIAEXIOREQINT pIoReqCur, pIoReqNext;
1063
1064	RTListForEachSafe(&pThis->LstIoReqIoBufWait, pIoReqCur, pIoReqNext, PDMMEDIAEXIOREQINT, NdLstWait)
1065	{
1066	/* Allocate a suitable I/O buffer for this request. */
1067	int rc = IOBUFMgrAllocBuf(pThis->hIoBufMgr, &pIoReqCur->ReadWrite.IoBuf, pIoReqCur->ReadWrite.cbReq,
1068	&pIoReqCur->ReadWrite.cbIoBuf);
1069	if (rc == VINF_SUCCESS)
1070	{
1071	ASMAtomicDecU32(&pThis->cIoReqsWaiting);
1072	RTListNodeRemove(&pIoReqCur->NdLstWait);
1073
1074	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReqCur->enmState, VDIOREQSTATE_ACTIVE, VDIOREQSTATE_ALLOCATED);
1075	if (RT_UNLIKELY(!fXchg))
1076	{
1077	/* Must have been canceled inbetween. */
1078	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1079	drvramdiskMediaExIoReqCompleteWorker(pThis, pIoReqCur, VERR_PDM_MEDIAEX_IOREQ_CANCELED, true /* fUpNotify */);
1080	}
1081	ASMAtomicIncU32(&pThis->cIoReqsActive);
1082	rc = drvramdiskMediaExIoReqReadWriteProcess(pThis, pIoReqCur, true /* fUpNotify */);
1083	}
1084	else
1085	{
1086	Assert(rc == VERR_NO_MEMORY);
1087	break;
1088	}
1089	}
1090	RTCritSectLeave(&pThis->CritSectIoReqsIoBufWait);
1091	}
1092	}
1093	}
1094
1095
1096	/**
1097	* Returns whether the VM is in a running state.
1098	*
1099	* @returns Flag indicating whether the VM is currently in a running state.
1100	* @param pThis VBox disk container instance data.
1101	*/
1102	DECLINLINE(bool) drvramdiskMediaExIoReqIsVmRunning(PDRVRAMDISK pThis)
1103	{
1104	VMSTATE enmVmState = PDMDrvHlpVMState(pThis->pDrvIns);
1105	if ( enmVmState == VMSTATE_RESUMING
1106	\|\| enmVmState == VMSTATE_RUNNING
1107	\|\| enmVmState == VMSTATE_RUNNING_LS
1108	\|\| enmVmState == VMSTATE_RESETTING
1109	\|\| enmVmState == VMSTATE_RESETTING_LS
1110	\|\| enmVmState == VMSTATE_SOFT_RESETTING
1111	\|\| enmVmState == VMSTATE_SOFT_RESETTING_LS
1112	\|\| enmVmState == VMSTATE_SUSPENDING
1113	\|\| enmVmState == VMSTATE_SUSPENDING_LS
1114	\|\| enmVmState == VMSTATE_SUSPENDING_EXT_LS)
1115	return true;
1116
1117	return false;
1118	}
1119
1120	/**
1121	* @copydoc FNVDASYNCTRANSFERCOMPLETE
1122	*/
1123	static void drvramdiskMediaExIoReqComplete(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq,
1124	int rcReq)
1125	{
1126	/*
1127	* For a read we need to sync the memory before continuing to process
1128	* the request further.
1129	*/
1130	if ( RT_SUCCESS(rcReq)
1131	&& pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ)
1132	rcReq = drvramdiskMediaExIoReqBufSync(pThis, pIoReq, false /* fToIoBuf */);
1133
1134	/*
1135	* When the request owner instructs us to handle recoverable errors like full disks
1136	* do it. Mark the request as suspended, notify the owner and put the request on the
1137	* redo list.
1138	*/
1139	if ( RT_FAILURE(rcReq)
1140	&& (pIoReq->fFlags & PDMIMEDIAEX_F_SUSPEND_ON_RECOVERABLE_ERR)
1141	&& drvramdiskMediaExIoReqIsRedoSetWarning(pThis, rcReq))
1142	{
1143	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_SUSPENDED, VDIOREQSTATE_ACTIVE);
1144	if (fXchg)
1145	{
1146	/* Put on redo list and adjust active request counter. */
1147	RTCritSectEnter(&pThis->CritSectIoReqRedo);
1148	RTListAppend(&pThis->LstIoReqRedo, &pIoReq->NdLstWait);
1149	RTCritSectLeave(&pThis->CritSectIoReqRedo);
1150	ASMAtomicDecU32(&pThis->cIoReqsActive);
1151	pThis->pDrvMediaExPort->pfnIoReqStateChanged(pThis->pDrvMediaExPort, pIoReq, &pIoReq->abAlloc[0],
1152	PDMMEDIAEXIOREQSTATE_SUSPENDED);
1153	}
1154	else
1155	{
1156	/* Request was canceled inbetween, so don't care and notify the owner about the completed request. */
1157	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1158	drvramdiskMediaExIoReqCompleteWorker(pThis, pIoReq, rcReq, true /* fUpNotify */);
1159	}
1160	}
1161	else
1162	{
1163	/* Adjust the remaining amount to transfer. */
1164	size_t cbReqIo = RT_MIN(pIoReq->ReadWrite.cbReqLeft, pIoReq->ReadWrite.cbIoBuf);
1165	pIoReq->ReadWrite.offStart += cbReqIo;
1166	pIoReq->ReadWrite.cbReqLeft -= cbReqIo;
1167
1168	if ( RT_FAILURE(rcReq)
1169	\|\| !pIoReq->ReadWrite.cbReqLeft
1170	\|\| ( pIoReq->enmType != PDMMEDIAEXIOREQTYPE_READ
1171	&& pIoReq->enmType != PDMMEDIAEXIOREQTYPE_WRITE))
1172	drvramdiskMediaExIoReqCompleteWorker(pThis, pIoReq, rcReq, true /* fUpNotify */);
1173	else
1174	drvramdiskMediaExIoReqReadWriteProcess(pThis, pIoReq, true /* fUpNotify */);
1175	}
1176	}
1177
1178	/**
1179	* Worker for a flush request.
1180	*
1181	* @returns VBox status code.
1182	* @param pThis RAM disk container instance data.
1183	* @param pIoReq The flush request.
1184	*/
1185	static DECLCALLBACK(int) drvramdiskIoReqFlushWorker(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
1186	{
1187	/* Nothing to do for a ram disk. */
1188	drvramdiskMediaExIoReqComplete(pThis, pIoReq, VINF_SUCCESS);
1189	return VINF_SUCCESS;
1190	}
1191
1192	/**
1193	* Worker for a discard request.
1194	*
1195	* @returns VBox status code.
1196	* @param pThis RAM disk container instance data.
1197	* @param pIoReq The discard request.
1198	*/
1199	static DECLCALLBACK(int) drvramdiskIoReqDiscardWorker(PDRVRAMDISK pThis, PPDMMEDIAEXIOREQINT pIoReq)
1200	{
1201	int rc = drvramdiskDiscardRecords(pThis, pIoReq->Discard.paRanges, pIoReq->Discard.cRanges);
1202	drvramdiskMediaExIoReqComplete(pThis, pIoReq, rc);
1203	return VINF_SUCCESS;
1204	}
1205
1206	/**
1207	* @interface_method_impl{PDMIMEDIAEX,pfnQueryFeatures}
1208	*/
1209	static DECLCALLBACK(int) drvramdiskQueryFeatures(PPDMIMEDIAEX pInterface, uint32_t *pfFeatures)
1210	{
1211	RT_NOREF1(pInterface);
1212	*pfFeatures = PDMIMEDIAEX_FEATURE_F_ASYNC \| PDMIMEDIAEX_FEATURE_F_DISCARD;
1213	return VINF_SUCCESS;
1214	}
1215
1216
1217	/**
1218	* @interface_method_impl{PDMIMEDIAEX,pfnNotifySuspend}
1219	*/
1220	static DECLCALLBACK(void) drvramdiskNotifySuspend(PPDMIMEDIAEX pInterface)
1221	{
1222	RT_NOREF(pInterface);
1223	}
1224
1225
1226	/**
1227	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqAllocSizeSet}
1228	*/
1229	static DECLCALLBACK(int) drvramdiskIoReqAllocSizeSet(PPDMIMEDIAEX pInterface, size_t cbIoReqAlloc)
1230	{
1231	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1232
1233	if (RT_UNLIKELY(pThis->hIoReqCache != NIL_RTMEMCACHE))
1234	return VERR_INVALID_STATE;
1235
1236	return RTMemCacheCreate(&pThis->hIoReqCache, sizeof(PDMMEDIAEXIOREQINT) + cbIoReqAlloc, 0, UINT32_MAX,
1237	NULL, NULL, NULL, 0);
1238	}
1239
1240	/**
1241	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqAlloc}
1242	*/
1243	static DECLCALLBACK(int) drvramdiskIoReqAlloc(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc,
1244	PDMMEDIAEXIOREQID uIoReqId, uint32_t fFlags)
1245	{
1246	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1247
1248	AssertReturn(!(fFlags & ~PDMIMEDIAEX_F_VALID), VERR_INVALID_PARAMETER);
1249
1250	PPDMMEDIAEXIOREQINT pIoReq = (PPDMMEDIAEXIOREQINT)RTMemCacheAlloc(pThis->hIoReqCache);
1251
1252	if (RT_UNLIKELY(!pIoReq))
1253	return VERR_NO_MEMORY;
1254
1255	pIoReq->uIoReqId = uIoReqId;
1256	pIoReq->fFlags = fFlags;
1257	pIoReq->pDisk = pThis;
1258	pIoReq->enmState = VDIOREQSTATE_ALLOCATED;
1259	pIoReq->enmType = PDMMEDIAEXIOREQTYPE_INVALID;
1260
1261	int rc = drvramdiskMediaExIoReqInsert(pThis, pIoReq);
1262	if (RT_SUCCESS(rc))
1263	{
1264	*phIoReq = pIoReq;
1265	*ppvIoReqAlloc = &pIoReq->abAlloc[0];
1266	}
1267	else
1268	RTMemCacheFree(pThis->hIoReqCache, pIoReq);
1269
1270	return rc;
1271	}
1272
1273	/**
1274	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqFree}
1275	*/
1276	static DECLCALLBACK(int) drvramdiskIoReqFree(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
1277	{
1278	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1279	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1280
1281	if ( pIoReq->enmState != VDIOREQSTATE_COMPLETED
1282	&& pIoReq->enmState != VDIOREQSTATE_ALLOCATED)
1283	return VERR_PDM_MEDIAEX_IOREQ_INVALID_STATE;
1284
1285	/* Remove from allocated list. */
1286	int rc = drvramdiskMediaExIoReqRemove(pThis, pIoReq);
1287	if (RT_FAILURE(rc))
1288	return rc;
1289
1290	/* Free any associated I/O memory. */
1291	drvramdiskMediaExIoReqBufFree(pThis, pIoReq);
1292
1293	/* For discard request discard the range array. */
1294	if ( pIoReq->enmType == PDMMEDIAEXIOREQTYPE_DISCARD
1295	&& pIoReq->Discard.paRanges)
1296	{
1297	RTMemFree(pIoReq->Discard.paRanges);
1298	pIoReq->Discard.paRanges = NULL;
1299	}
1300
1301	pIoReq->enmState = VDIOREQSTATE_FREE;
1302	RTMemCacheFree(pThis->hIoReqCache, pIoReq);
1303	return VINF_SUCCESS;
1304	}
1305
1306	/**
1307	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQueryResidual}
1308	*/
1309	static DECLCALLBACK(int) drvramdiskIoReqQueryResidual(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, size_t *pcbResidual)
1310	{
1311	RT_NOREF2(pInterface, hIoReq);
1312
1313	*pcbResidual = 0;
1314	return VINF_SUCCESS;
1315	}
1316
1317	/**
1318	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQueryXferSize}
1319	*/
1320	static DECLCALLBACK(int) drvramdiskIoReqQueryXferSize(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, size_t *pcbXfer)
1321	{
1322	RT_NOREF1(pInterface);
1323	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1324
1325	if ( pIoReq->enmType == PDMMEDIAEXIOREQTYPE_READ
1326	\|\| pIoReq->enmType == PDMMEDIAEXIOREQTYPE_WRITE)
1327	*pcbXfer = pIoReq->ReadWrite.cbReq;
1328	else
1329	*pcbXfer = 0;
1330
1331	return VINF_SUCCESS;
1332	}
1333
1334	/**
1335	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancelAll}
1336	*/
1337	static DECLCALLBACK(int) drvramdiskIoReqCancelAll(PPDMIMEDIAEX pInterface)
1338	{
1339	RT_NOREF1(pInterface);
1340	return VINF_SUCCESS; /** @todo */
1341	}
1342
1343	/**
1344	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancel}
1345	*/
1346	static DECLCALLBACK(int) drvramdiskIoReqCancel(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQID uIoReqId)
1347	{
1348	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1349	unsigned idxBin = drvramdiskMediaExIoReqIdHash(uIoReqId);
1350
1351	int rc = RTSemFastMutexRequest(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
1352	if (RT_SUCCESS(rc))
1353	{
1354	/* Search for I/O request with ID. */
1355	PPDMMEDIAEXIOREQINT pIt;
1356	rc = VERR_PDM_MEDIAEX_IOREQID_NOT_FOUND;
1357
1358	RTListForEach(&pThis->aIoReqAllocBins[idxBin].LstIoReqAlloc, pIt, PDMMEDIAEXIOREQINT, NdAllocatedList)
1359	{
1360	if (pIt->uIoReqId == uIoReqId)
1361	{
1362	bool fXchg = true;
1363	VDIOREQSTATE enmStateOld = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIt->enmState);
1364
1365	/*
1366	* We might have to try canceling the request multiple times if it transitioned from
1367	* ALLOCATED to ACTIVE or to SUSPENDED between reading the state and trying to change it.
1368	*/
1369	while ( ( enmStateOld == VDIOREQSTATE_ALLOCATED
1370	\|\| enmStateOld == VDIOREQSTATE_ACTIVE
1371	\|\| enmStateOld == VDIOREQSTATE_SUSPENDED)
1372	&& !fXchg)
1373	{
1374	fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIt->enmState, VDIOREQSTATE_CANCELED, enmStateOld);
1375	if (!fXchg)
1376	enmStateOld = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIt->enmState);
1377	}
1378
1379	if (fXchg)
1380	{
1381	ASMAtomicDecU32(&pThis->cIoReqsActive);
1382	rc = VINF_SUCCESS;
1383	}
1384	break;
1385	}
1386	}
1387	RTSemFastMutexRelease(pThis->aIoReqAllocBins[idxBin].hMtxLstIoReqAlloc);
1388	}
1389
1390	return rc;
1391	}
1392
1393	/**
1394	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqRead}
1395	*/
1396	static DECLCALLBACK(int) drvramdiskIoReqRead(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbRead)
1397	{
1398	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1399	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1400	VDIOREQSTATE enmState = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIoReq->enmState);
1401
1402	if (RT_UNLIKELY(enmState == VDIOREQSTATE_CANCELED))
1403	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1404
1405	if (RT_UNLIKELY(enmState != VDIOREQSTATE_ALLOCATED))
1406	return VERR_PDM_MEDIAEX_IOREQ_INVALID_STATE;
1407
1408	pIoReq->enmType = PDMMEDIAEXIOREQTYPE_READ;
1409	pIoReq->tsSubmit = RTTimeMilliTS();
1410	pIoReq->ReadWrite.offStart = off;
1411	pIoReq->ReadWrite.cbReq = cbRead;
1412	pIoReq->ReadWrite.cbReqLeft = cbRead;
1413	/* Allocate a suitable I/O buffer for this request. */
1414	int rc = drvramdiskMediaExIoReqBufAlloc(pThis, pIoReq, cbRead);
1415	if (rc == VINF_SUCCESS)
1416	{
1417	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_ACTIVE, VDIOREQSTATE_ALLOCATED);
1418	if (RT_UNLIKELY(!fXchg))
1419	{
1420	/* Must have been canceled inbetween. */
1421	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1422	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1423	}
1424	ASMAtomicIncU32(&pThis->cIoReqsActive);
1425
1426	rc = drvramdiskMediaExIoReqReadWriteProcess(pThis, pIoReq, false /* fUpNotify */);
1427	}
1428
1429	return rc;
1430	}
1431
1432	/**
1433	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqWrite}
1434	*/
1435	static DECLCALLBACK(int) drvramdiskIoReqWrite(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbWrite)
1436	{
1437	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1438	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1439	VDIOREQSTATE enmState = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIoReq->enmState);
1440
1441	if (RT_UNLIKELY(enmState == VDIOREQSTATE_CANCELED))
1442	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1443
1444	if (RT_UNLIKELY(enmState != VDIOREQSTATE_ALLOCATED))
1445	return VERR_PDM_MEDIAEX_IOREQ_INVALID_STATE;
1446
1447	pIoReq->enmType = PDMMEDIAEXIOREQTYPE_WRITE;
1448	pIoReq->tsSubmit = RTTimeMilliTS();
1449	pIoReq->ReadWrite.offStart = off;
1450	pIoReq->ReadWrite.cbReq = cbWrite;
1451	pIoReq->ReadWrite.cbReqLeft = cbWrite;
1452	/* Allocate a suitable I/O buffer for this request. */
1453	int rc = drvramdiskMediaExIoReqBufAlloc(pThis, pIoReq, cbWrite);
1454	if (rc == VINF_SUCCESS)
1455	{
1456	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_ACTIVE, VDIOREQSTATE_ALLOCATED);
1457	if (RT_UNLIKELY(!fXchg))
1458	{
1459	/* Must have been canceled inbetween. */
1460	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1461	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1462	}
1463	ASMAtomicIncU32(&pThis->cIoReqsActive);
1464
1465	rc = drvramdiskMediaExIoReqReadWriteProcess(pThis, pIoReq, false /* fUpNotify */);
1466	}
1467
1468	return rc;
1469	}
1470
1471	/**
1472	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqFlush}
1473	*/
1474	static DECLCALLBACK(int) drvramdiskIoReqFlush(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
1475	{
1476	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1477	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1478	VDIOREQSTATE enmState = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIoReq->enmState);
1479
1480	if (RT_UNLIKELY(enmState == VDIOREQSTATE_CANCELED))
1481	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1482
1483	if (RT_UNLIKELY(enmState != VDIOREQSTATE_ALLOCATED))
1484	return VERR_PDM_MEDIAEX_IOREQ_INVALID_STATE;
1485
1486	pIoReq->enmType = PDMMEDIAEXIOREQTYPE_FLUSH;
1487	pIoReq->tsSubmit = RTTimeMilliTS();
1488	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_ACTIVE, VDIOREQSTATE_ALLOCATED);
1489	if (RT_UNLIKELY(!fXchg))
1490	{
1491	/* Must have been canceled inbetween. */
1492	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1493	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1494	}
1495
1496	ASMAtomicIncU32(&pThis->cIoReqsActive);
1497	return RTReqQueueCallEx(pThis->hReqQ, NULL, 0, RTREQFLAGS_NO_WAIT,
1498	(PFNRT)drvramdiskIoReqFlushWorker, 2, pThis, pIoReq);
1499	}
1500
1501	/**
1502	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqDiscard}
1503	*/
1504	static DECLCALLBACK(int) drvramdiskIoReqDiscard(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, unsigned cRangesMax)
1505	{
1506	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1507	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1508	VDIOREQSTATE enmState = (VDIOREQSTATE)ASMAtomicReadU32((volatile uint32_t *)&pIoReq->enmState);
1509
1510	if (RT_UNLIKELY(enmState == VDIOREQSTATE_CANCELED))
1511	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1512
1513	if (RT_UNLIKELY(enmState != VDIOREQSTATE_ALLOCATED))
1514	return VERR_PDM_MEDIAEX_IOREQ_INVALID_STATE;
1515
1516	/* Copy the ranges over now, this can be optimized in the future. */
1517	pIoReq->Discard.paRanges = (PRTRANGE)RTMemAllocZ(cRangesMax * sizeof(RTRANGE));
1518	if (RT_UNLIKELY(!pIoReq->Discard.paRanges))
1519	return VERR_NO_MEMORY;
1520
1521	int rc = pThis->pDrvMediaExPort->pfnIoReqQueryDiscardRanges(pThis->pDrvMediaExPort, pIoReq, &pIoReq->abAlloc[0],
1522	0, cRangesMax, pIoReq->Discard.paRanges,
1523	&pIoReq->Discard.cRanges);
1524	if (RT_SUCCESS(rc))
1525	{
1526	pIoReq->enmType = PDMMEDIAEXIOREQTYPE_DISCARD;
1527	pIoReq->tsSubmit = RTTimeMilliTS();
1528
1529	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pIoReq->enmState, VDIOREQSTATE_ACTIVE, VDIOREQSTATE_ALLOCATED);
1530	if (RT_UNLIKELY(!fXchg))
1531	{
1532	/* Must have been canceled inbetween. */
1533	Assert(pIoReq->enmState == VDIOREQSTATE_CANCELED);
1534	return VERR_PDM_MEDIAEX_IOREQ_CANCELED;
1535	}
1536
1537	ASMAtomicIncU32(&pThis->cIoReqsActive);
1538
1539	rc = RTReqQueueCallEx(pThis->hReqQ, NULL, 0, RTREQFLAGS_NO_WAIT,
1540	(PFNRT)drvramdiskIoReqDiscardWorker, 2, pThis, pIoReq);
1541	if (rc == VINF_SUCCESS)
1542	rc = VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS;
1543	}
1544
1545	return rc;
1546	}
1547
1548	/**
1549	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetActiveCount}
1550	*/
1551	static DECLCALLBACK(uint32_t) drvramdiskIoReqGetActiveCount(PPDMIMEDIAEX pInterface)
1552	{
1553	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1554	return ASMAtomicReadU32(&pThis->cIoReqsActive);
1555	}
1556
1557	/**
1558	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetSuspendedCount}
1559	*/
1560	static DECLCALLBACK(uint32_t) drvramdiskIoReqGetSuspendedCount(PPDMIMEDIAEX pInterface)
1561	{
1562	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1563
1564	AssertReturn(!drvramdiskMediaExIoReqIsVmRunning(pThis), 0);
1565
1566	uint32_t cIoReqSuspended = 0;
1567	PPDMMEDIAEXIOREQINT pIoReq;
1568	RTCritSectEnter(&pThis->CritSectIoReqRedo);
1569	RTListForEach(&pThis->LstIoReqRedo, pIoReq, PDMMEDIAEXIOREQINT, NdLstWait)
1570	{
1571	cIoReqSuspended++;
1572	}
1573	RTCritSectLeave(&pThis->CritSectIoReqRedo);
1574
1575	return cIoReqSuspended;
1576	}
1577
1578	/**
1579	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedStart}
1580	*/
1581	static DECLCALLBACK(int) drvramdiskIoReqQuerySuspendedStart(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq,
1582	void **ppvIoReqAlloc)
1583	{
1584	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1585
1586	AssertReturn(!drvramdiskMediaExIoReqIsVmRunning(pThis), VERR_INVALID_STATE);
1587	AssertReturn(!RTListIsEmpty(&pThis->LstIoReqRedo), VERR_NOT_FOUND);
1588
1589	RTCritSectEnter(&pThis->CritSectIoReqRedo);
1590	PPDMMEDIAEXIOREQINT pIoReq = RTListGetFirst(&pThis->LstIoReqRedo, PDMMEDIAEXIOREQINT, NdLstWait);
1591	*phIoReq = pIoReq;
1592	*ppvIoReqAlloc = &pIoReq->abAlloc[0];
1593	RTCritSectLeave(&pThis->CritSectIoReqRedo);
1594
1595	return VINF_SUCCESS;
1596	}
1597
1598	/**
1599	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedNext}
1600	*/
1601	static DECLCALLBACK(int) drvramdiskIoReqQuerySuspendedNext(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
1602	PPDMMEDIAEXIOREQ phIoReqNext, void **ppvIoReqAllocNext)
1603	{
1604	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1605	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1606
1607	AssertReturn(!drvramdiskMediaExIoReqIsVmRunning(pThis), VERR_INVALID_STATE);
1608	AssertPtrReturn(pIoReq, VERR_INVALID_HANDLE);
1609	AssertReturn(!RTListNodeIsLast(&pThis->LstIoReqRedo, &pIoReq->NdLstWait), VERR_NOT_FOUND);
1610
1611	RTCritSectEnter(&pThis->CritSectIoReqRedo);
1612	PPDMMEDIAEXIOREQINT pIoReqNext = RTListNodeGetNext(&pIoReq->NdLstWait, PDMMEDIAEXIOREQINT, NdLstWait);
1613	*phIoReqNext = pIoReqNext;
1614	*ppvIoReqAllocNext = &pIoReqNext->abAlloc[0];
1615	RTCritSectLeave(&pThis->CritSectIoReqRedo);
1616
1617	return VINF_SUCCESS;
1618	}
1619
1620	/**
1621	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedSave}
1622	*/
1623	static DECLCALLBACK(int) drvramdiskIoReqSuspendedSave(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1624	{
1625	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1626	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1627
1628	RT_NOREF1(pSSM);
1629
1630	AssertReturn(!drvramdiskMediaExIoReqIsVmRunning(pThis), VERR_INVALID_STATE);
1631	AssertPtrReturn(pIoReq, VERR_INVALID_HANDLE);
1632	AssertReturn(pIoReq->enmState == VDIOREQSTATE_SUSPENDED, VERR_INVALID_STATE);
1633
1634	return VERR_NOT_IMPLEMENTED;
1635	}
1636
1637	/**
1638	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedLoad}
1639	*/
1640	static DECLCALLBACK(int) drvramdiskIoReqSuspendedLoad(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1641	{
1642	PDRVRAMDISK pThis = RT_FROM_MEMBER(pInterface, DRVRAMDISK, IMediaEx);
1643	PPDMMEDIAEXIOREQINT pIoReq = hIoReq;
1644
1645	RT_NOREF1(pSSM);
1646
1647	AssertReturn(!drvramdiskMediaExIoReqIsVmRunning(pThis), VERR_INVALID_STATE);
1648	AssertPtrReturn(pIoReq, VERR_INVALID_HANDLE);
1649	AssertReturn(pIoReq->enmState == VDIOREQSTATE_ALLOCATED, VERR_INVALID_STATE);
1650
1651	return VERR_NOT_IMPLEMENTED;
1652	}
1653
1654	static DECLCALLBACK(int) drvramdiskIoReqWorker(RTTHREAD hThrdSelf, void *pvUser)
1655	{
1656	int rc = VINF_SUCCESS;
1657	PDRVRAMDISK pThis = (PDRVRAMDISK)pvUser;
1658
1659	RT_NOREF1(hThrdSelf);
1660
1661	do
1662	{
1663	rc = RTReqQueueProcess(pThis->hReqQ, RT_INDEFINITE_WAIT);
1664	} while (RT_SUCCESS(rc));
1665
1666	return VINF_SUCCESS;
1667	}
1668
1669	/* -=-=-=-=- IBase -=-=-=-=- */
1670
1671	/**
1672	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1673	*/
1674	static DECLCALLBACK(void ) drvramdiskQueryInterface(PPDMIBASE pInterface, const char pszIID)
1675	{
1676	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1677	PDRVRAMDISK pThis = PDMINS_2_DATA(pDrvIns, PDRVRAMDISK);
1678
1679	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1680	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, &pThis->IMedia);
1681	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEX, &pThis->IMediaEx);
1682
1683	return NULL;
1684	}
1685
1686
1687	/* -=-=-=-=- driver interface -=-=-=-=- */
1688
1689	static DECLCALLBACK(int) drvramdiskTreeDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
1690	{
1691	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)pNode;
1692
1693	RT_NOREF1(pvUser);
1694
1695	RTMemFree(pSeg->pbSeg);
1696	RTMemFree(pSeg);
1697	return VINF_SUCCESS;
1698	}
1699
1700	/**
1701	* @copydoc FNPDMDRVDESTRUCT
1702	*/
1703	static DECLCALLBACK(void) drvramdiskDestruct(PPDMDRVINS pDrvIns)
1704	{
1705	PDRVRAMDISK pThis = PDMINS_2_DATA(pDrvIns, PDRVRAMDISK);
1706
1707	PRTREQ pReq = NULL;
1708	int rc = RTReqQueueCallEx(pThis->hReqQ, &pReq, RT_INDEFINITE_WAIT, RTREQFLAGS_IPRT_STATUS,
1709	(PFNRT)drvramdiskDestructQueue, 0);
1710	AssertRC(rc);
1711	RTReqRelease(pReq);
1712
1713	if (pThis->pTreeSegments)
1714	{
1715	RTAvlrFileOffsetDestroy(pThis->pTreeSegments, drvramdiskTreeDestroy, NULL);
1716	RTMemFree(pThis->pTreeSegments);
1717	}
1718	if (pThis->hIoBufMgr)
1719	IOBUFMgrDestroy(pThis->hIoBufMgr);
1720
1721	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aIoReqAllocBins); i++)
1722	if (pThis->aIoReqAllocBins[i].hMtxLstIoReqAlloc != NIL_RTSEMFASTMUTEX)
1723	RTSemFastMutexDestroy(pThis->aIoReqAllocBins[i].hMtxLstIoReqAlloc);
1724
1725	if (RTCritSectIsInitialized(&pThis->CritSectIoReqsIoBufWait))
1726	RTCritSectDelete(&pThis->CritSectIoReqsIoBufWait);
1727
1728	if (RTCritSectIsInitialized(&pThis->CritSectIoReqRedo))
1729	RTCritSectDelete(&pThis->CritSectIoReqRedo);
1730
1731	if (pThis->hIoReqCache != NIL_RTMEMCACHE)
1732	RTMemCacheDestroy(pThis->hIoReqCache);
1733
1734	RTReqQueueDestroy(pThis->hReqQ);
1735	}
1736
1737	/**
1738	* Construct a disk integrity driver instance.
1739	*
1740	* @copydoc FNPDMDRVCONSTRUCT
1741	*/
1742	static DECLCALLBACK(int) drvramdiskConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1743	{
1744	RT_NOREF1(fFlags);
1745	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1746	PDRVRAMDISK pThis = PDMINS_2_DATA(pDrvIns, PDRVRAMDISK);
1747	PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
1748
1749	LogFlow(("drvdiskintConstruct: iInstance=%d\n", pDrvIns->iInstance));
1750
1751	/*
1752	* Initialize most of the data members.
1753	*/
1754	pThis->pDrvIns = pDrvIns;
1755
1756	/* IBase. */
1757	pDrvIns->IBase.pfnQueryInterface = drvramdiskQueryInterface;
1758
1759	/* IMedia */
1760	pThis->IMedia.pfnRead = drvramdiskRead;
1761	pThis->IMedia.pfnWrite = drvramdiskWrite;
1762	pThis->IMedia.pfnFlush = drvramdiskFlush;
1763	pThis->IMedia.pfnGetSize = drvramdiskGetSize;
1764	pThis->IMedia.pfnBiosIsVisible = drvramdiskBiosIsVisible;
1765	pThis->IMedia.pfnGetType = drvramdiskGetType;
1766	pThis->IMedia.pfnIsReadOnly = drvramdiskIsReadOnly;
1767	pThis->IMedia.pfnBiosGetPCHSGeometry = drvramdiskBiosGetPCHSGeometry;
1768	pThis->IMedia.pfnBiosSetPCHSGeometry = drvramdiskBiosSetPCHSGeometry;
1769	pThis->IMedia.pfnBiosGetLCHSGeometry = drvramdiskBiosGetLCHSGeometry;
1770	pThis->IMedia.pfnBiosSetLCHSGeometry = drvramdiskBiosSetLCHSGeometry;
1771	pThis->IMedia.pfnGetUuid = drvramdiskGetUuid;
1772	pThis->IMedia.pfnGetSectorSize = drvramdiskGetSectorSize;
1773	pThis->IMedia.pfnReadPcBios = drvramdiskReadPcBios;
1774	pThis->IMedia.pfnDiscard = drvramdiskDiscard;
1775	pThis->IMedia.pfnIsNonRotational = drvramdiskIsNonRotational;
1776	pThis->IMedia.pfnSendCmd = NULL;
1777	pThis->IMedia.pfnGetRegionCount = drvramdiskGetRegionCount;
1778	pThis->IMedia.pfnQueryRegionProperties = drvramdiskQueryRegionProperties;
1779	pThis->IMedia.pfnQueryRegionPropertiesForLba = drvramdiskQueryRegionPropertiesForLba;
1780
1781	/* IMediaEx */
1782	pThis->IMediaEx.pfnQueryFeatures = drvramdiskQueryFeatures;
1783	pThis->IMediaEx.pfnNotifySuspend = drvramdiskNotifySuspend;
1784	pThis->IMediaEx.pfnIoReqAllocSizeSet = drvramdiskIoReqAllocSizeSet;
1785	pThis->IMediaEx.pfnIoReqAlloc = drvramdiskIoReqAlloc;
1786	pThis->IMediaEx.pfnIoReqFree = drvramdiskIoReqFree;
1787	pThis->IMediaEx.pfnIoReqQueryResidual = drvramdiskIoReqQueryResidual;
1788	pThis->IMediaEx.pfnIoReqQueryXferSize = drvramdiskIoReqQueryXferSize;
1789	pThis->IMediaEx.pfnIoReqCancelAll = drvramdiskIoReqCancelAll;
1790	pThis->IMediaEx.pfnIoReqCancel = drvramdiskIoReqCancel;
1791	pThis->IMediaEx.pfnIoReqRead = drvramdiskIoReqRead;
1792	pThis->IMediaEx.pfnIoReqWrite = drvramdiskIoReqWrite;
1793	pThis->IMediaEx.pfnIoReqFlush = drvramdiskIoReqFlush;
1794	pThis->IMediaEx.pfnIoReqDiscard = drvramdiskIoReqDiscard;
1795	pThis->IMediaEx.pfnIoReqGetActiveCount = drvramdiskIoReqGetActiveCount;
1796	pThis->IMediaEx.pfnIoReqGetSuspendedCount = drvramdiskIoReqGetSuspendedCount;
1797	pThis->IMediaEx.pfnIoReqQuerySuspendedStart = drvramdiskIoReqQuerySuspendedStart;
1798	pThis->IMediaEx.pfnIoReqQuerySuspendedNext = drvramdiskIoReqQuerySuspendedNext;
1799	pThis->IMediaEx.pfnIoReqSuspendedSave = drvramdiskIoReqSuspendedSave;
1800	pThis->IMediaEx.pfnIoReqSuspendedLoad = drvramdiskIoReqSuspendedLoad;
1801
1802	/*
1803	* Validate configuration.
1804	*/
1805	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "Size"
1806	"\|PreAlloc"
1807	"\|IoBufMax"
1808	"\|SectorSize"
1809	"\|NonRotational",
1810	"");
1811
1812	int rc = pHlp->pfnCFGMQueryU64(pCfg, "Size", &pThis->cbDisk);
1813	if (RT_FAILURE(rc))
1814	return PDMDRV_SET_ERROR(pDrvIns, rc,
1815	N_("RamDisk: Error querying the media size"));
1816	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "PreAlloc", &pThis->fPreallocRamDisk, false);
1817	if (RT_FAILURE(rc))
1818	return PDMDRV_SET_ERROR(pDrvIns, rc,
1819	N_("RamDisk: Error querying \"PreAlloc\""));
1820	rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "NonRotational", &pThis->fNonRotational, true);
1821	if (RT_FAILURE(rc))
1822	return PDMDRV_SET_ERROR(pDrvIns, rc,
1823	N_("RamDisk: Error querying \"NonRotational\""));
1824
1825	uint32_t cbIoBufMax;
1826	rc = pHlp->pfnCFGMQueryU32Def(pCfg, "IoBufMax", &cbIoBufMax, 5 * _1M);
1827	if (RT_FAILURE(rc))
1828	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"IoBufMax\" from the config"));
1829	rc = pHlp->pfnCFGMQueryU32Def(pCfg, "SectorSize", &pThis->cbSector, 512);
1830	if (RT_FAILURE(rc))
1831	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Failed to query \"SectorSize\" from the config"));
1832
1833	/* Query the media port interface above us. */
1834	pThis->pDrvMediaPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAPORT);
1835	if (!pThis->pDrvMediaPort)
1836	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW,
1837	N_("No media port interface above"));
1838
1839	/* Try to attach extended media port interface above.*/
1840	pThis->pDrvMediaExPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAEXPORT);
1841	if (pThis->pDrvMediaExPort)
1842	{
1843	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aIoReqAllocBins); i++)
1844	{
1845	rc = RTSemFastMutexCreate(&pThis->aIoReqAllocBins[i].hMtxLstIoReqAlloc);
1846	if (RT_FAILURE(rc))
1847	break;
1848	RTListInit(&pThis->aIoReqAllocBins[i].LstIoReqAlloc);
1849	}
1850
1851	if (RT_SUCCESS(rc))
1852	rc = RTCritSectInit(&pThis->CritSectIoReqsIoBufWait);
1853
1854	if (RT_SUCCESS(rc))
1855	rc = RTCritSectInit(&pThis->CritSectIoReqRedo);
1856
1857	if (RT_FAILURE(rc))
1858	return PDMDRV_SET_ERROR(pDrvIns, rc, N_("Creating Mutex failed"));
1859
1860	RTListInit(&pThis->LstIoReqIoBufWait);
1861	RTListInit(&pThis->LstIoReqRedo);
1862	}
1863
1864	/* Create the AVL tree. */
1865	pThis->pTreeSegments = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
1866	if (!pThis->pTreeSegments)
1867	rc = VERR_NO_MEMORY;
1868
1869	if (pThis->pDrvMediaExPort)
1870	{
1871	rc = RTReqQueueCreate(&pThis->hReqQ);
1872	if (RT_SUCCESS(rc))
1873	{
1874	/* Spin up the worker thread. */
1875	rc = RTThreadCreate(&pThis->hThrdWrk, drvramdiskIoReqWorker, pThis, 0,
1876	RTTHREADTYPE_IO, 0, "RAMDSK");
1877	}
1878	}
1879
1880	if (pThis->pDrvMediaExPort)
1881	rc = IOBUFMgrCreate(&pThis->hIoBufMgr, cbIoBufMax, IOBUFMGR_F_DEFAULT);
1882
1883	/* Read in all data before the start if requested. */
1884	if ( RT_SUCCESS(rc)
1885	&& pThis->fPreallocRamDisk)
1886	{
1887	LogRel(("RamDisk: Preallocating RAM disk...\n"));
1888	return VERR_NOT_IMPLEMENTED;
1889	}
1890
1891	return rc;
1892	}
1893
1894
1895	/**
1896	* Block driver registration record.
1897	*/
1898	const PDMDRVREG g_DrvRamDisk =
1899	{
1900	/* u32Version */
1901	PDM_DRVREG_VERSION,
1902	/* szName */
1903	"RamDisk",
1904	/* szRCMod */
1905	"",
1906	/* szR0Mod */
1907	"",
1908	/* pszDescription */
1909	"RAM disk driver.",
1910	/* fFlags */
1911	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1912	/* fClass. */
1913	PDM_DRVREG_CLASS_BLOCK,
1914	/* cMaxInstances */
1915	~0U,
1916	/* cbInstance */
1917	sizeof(DRVRAMDISK),
1918	/* pfnConstruct */
1919	drvramdiskConstruct,
1920	/* pfnDestruct */
1921	drvramdiskDestruct,
1922	/* pfnRelocate */
1923	NULL,
1924	/* pfnIOCtl */
1925	NULL,
1926	/* pfnPowerOn */
1927	NULL,
1928	/* pfnReset */
1929	NULL,
1930	/* pfnSuspend */
1931	NULL,
1932	/* pfnResume */
1933	NULL,
1934	/* pfnAttach */
1935	NULL,
1936	/* pfnDetach */
1937	NULL,
1938	/* pfnPowerOff */
1939	NULL,
1940	/* pfnSoftReset */
1941	NULL,
1942	/* u32EndVersion */
1943	PDM_DRVREG_VERSION
1944	};
1945

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

source: vbox/trunk/src/VBox/Devices/Storage/DrvRamDisk.cpp@ 105100

Download in other formats: