DrvDiskIntegrity.cpp@ 64209

Last change on this file since 64209 was 64019, checked in by vboxsync, 8 years ago
Storage: Get rid of PDMIMEDIA::pfnIoBufAllocate and PDMIMEDIA::pfnIoBufFree, was only used by AHCI anyway and is superseded by the I/O buffer management in PDMIMEDIAEX now
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.4 KB

Line
1	/* $Id: DrvDiskIntegrity.cpp 64019 2016-09-26 16:32:53Z vboxsync $ */
2	/** @file
3	* VBox storage devices: Disk integrity check.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DRV_DISK_INTEGRITY
23	#include <VBox/vmm/pdmdrv.h>
24	#include <VBox/vmm/pdmstorageifs.h>
25	#include <VBox/vddbg.h>
26	#include <iprt/assert.h>
27	#include <iprt/string.h>
28	#include <iprt/uuid.h>
29	#include <iprt/avl.h>
30	#include <iprt/mem.h>
31	#include <iprt/message.h>
32	#include <iprt/sg.h>
33	#include <iprt/time.h>
34	#include <iprt/semaphore.h>
35	#include <iprt/asm.h>
36
37	#include "VBoxDD.h"
38
39
40	/*********************************************************************************************************************************
41	* Structures and Typedefs *
42	*********************************************************************************************************************************/
43
44	/**
45	* Transfer direction.
46	*/
47	typedef enum DRVDISKAIOTXDIR
48	{
49	/** Invalid. */
50	DRVDISKAIOTXDIR_INVALID = 0,
51	/** Read */
52	DRVDISKAIOTXDIR_READ,
53	/** Write */
54	DRVDISKAIOTXDIR_WRITE,
55	/** Flush */
56	DRVDISKAIOTXDIR_FLUSH,
57	/** Discard */
58	DRVDISKAIOTXDIR_DISCARD,
59	/** Read after write for immediate verification. */
60	DRVDISKAIOTXDIR_READ_AFTER_WRITE
61	} DRVDISKAIOTXDIR;
62
63	/**
64	* async I/O request.
65	*/
66	typedef struct DRVDISKAIOREQ
67	{
68	/** Transfer direction. */
69	DRVDISKAIOTXDIR enmTxDir;
70	/** Start offset. */
71	uint64_t off;
72	/** Transfer size. */
73	size_t cbTransfer;
74	/** Segment array. */
75	PCRTSGSEG paSeg;
76	/** Number of array entries. */
77	unsigned cSeg;
78	/** User argument */
79	void *pvUser;
80	/** Slot in the array. */
81	unsigned iSlot;
82	/** Start timestamp */
83	uint64_t tsStart;
84	/** Completion timestamp. */
85	uint64_t tsComplete;
86	/** I/O log entry if configured. */
87	VDIOLOGENT hIoLogEntry;
88	/** Ranges to discard. */
89	PCRTRANGE paRanges;
90	/** Number of ranges. */
91	unsigned cRanges;
92	/** I/O segment for the extended media interface
93	* to hold the data. */
94	RTSGSEG IoSeg;
95	} DRVDISKAIOREQ, *PDRVDISKAIOREQ;
96
97	/**
98	* I/O log entry.
99	*/
100	typedef struct IOLOGENT
101	{
102	/** Start offset */
103	uint64_t off;
104	/** Write size */
105	size_t cbWrite;
106	/** Number of references to this entry. */
107	unsigned cRefs;
108	} IOLOGENT, *PIOLOGENT;
109
110	/**
111	* Disk segment.
112	*/
113	typedef struct DRVDISKSEGMENT
114	{
115	/** AVL core. */
116	AVLRFOFFNODECORE Core;
117	/** Size of the segment */
118	size_t cbSeg;
119	/** Data for this segment */
120	uint8_t *pbSeg;
121	/** Number of entries in the I/O array. */
122	unsigned cIoLogEntries;
123	/** Array of I/O log references. */
124	PIOLOGENT apIoLog[1];
125	} DRVDISKSEGMENT, *PDRVDISKSEGMENT;
126
127	/**
128	* Active requests list entry.
129	*/
130	typedef struct DRVDISKAIOREQACTIVE
131	{
132	/** Pointer to the request. */
133	volatile PDRVDISKAIOREQ pIoReq;
134	/** Start timestamp. */
135	uint64_t tsStart;
136	} DRVDISKAIOREQACTIVE, *PDRVDISKAIOREQACTIVE;
137
138	/**
139	* Disk integrity driver instance data.
140	*
141	* @implements PDMIMEDIA
142	*/
143	typedef struct DRVDISKINTEGRITY
144	{
145	/** Pointer driver instance. */
146	PPDMDRVINS pDrvIns;
147	/** Pointer to the media driver below us.
148	* This is NULL if the media is not mounted. */
149	PPDMIMEDIA pDrvMedia;
150	/** Our media interface */
151	PDMIMEDIA IMedia;
152
153	/** The media port interface above. */
154	PPDMIMEDIAPORT pDrvMediaPort;
155	/** Media port interface */
156	PDMIMEDIAPORT IMediaPort;
157
158	/** The extended media port interface above. */
159	PPDMIMEDIAEXPORT pDrvMediaExPort;
160	/** Our extended media port interface */
161	PDMIMEDIAEXPORT IMediaExPort;
162
163	/** The extended media interface below. */
164	PPDMIMEDIAEX pDrvMediaEx;
165	/** Our extended media interface */
166	PDMIMEDIAEX IMediaEx;
167
168	/** Flag whether consistency checks are enabled. */
169	bool fCheckConsistency;
170	/** Flag whether the RAM disk was prepopulated. */
171	bool fPrepopulateRamDisk;
172	/** AVL tree containing the disk blocks to check. */
173	PAVLRFOFFTREE pTreeSegments;
174
175	/** Flag whether async request tracing is enabled. */
176	bool fTraceRequests;
177	/** Interval the thread should check for expired requests (milliseconds). */
178	uint32_t uCheckIntervalMs;
179	/** Expire timeout for a request (milliseconds). */
180	uint32_t uExpireIntervalMs;
181	/** Thread which checks for lost requests. */
182	RTTHREAD hThread;
183	/** Event semaphore */
184	RTSEMEVENT SemEvent;
185	/** Flag whether the thread should run. */
186	bool fRunning;
187	/** Array containing active requests. */
188	DRVDISKAIOREQACTIVE apReqActive[128];
189	/** Next free slot in the array */
190	volatile unsigned iNextFreeSlot;
191
192	/** Flag whether we check for requests completing twice. */
193	bool fCheckDoubleCompletion;
194	/** Number of requests we go back. */
195	unsigned cEntries;
196	/** Array of completed but still observed requests. */
197	PDRVDISKAIOREQ *papIoReq;
198	/** Current entry in the array. */
199	unsigned iEntry;
200
201	/** Flag whether to do a immediate read after write for verification. */
202	bool fReadAfterWrite;
203	/** Flag whether to record the data to write before the write completed successfully.
204	* Useful in case the data is modified in place later on (encryption for instance). */
205	bool fRecordWriteBeforeCompletion;
206	/** Flag whether to validate memory buffers when the extended media interface is used. */
207	bool fValidateMemBufs;
208
209	/** I/O logger to use if enabled. */
210	VDIOLOGGER hIoLogger;
211	/** Size of the opaque handle until our tracking structure starts in bytes. */
212	size_t cbIoReqOpaque;
213	} DRVDISKINTEGRITY, *PDRVDISKINTEGRITY;
214
215
216	static void drvdiskintIoReqCheckForDoubleCompletion(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq,
217	bool fMediaEx)
218	{
219	/* Search if the I/O request completed already. */
220	for (unsigned i = 0; i < pThis->cEntries; i++)
221	{
222	if (RT_UNLIKELY(pThis->papIoReq[i] == pIoReq))
223	{
224	RTMsgError("Request %#p completed already!\n", pIoReq);
225	if (!fMediaEx)
226	RTMsgError("Start timestamp %llu Completion timestamp %llu (completed after %llu ms)\n",
227	pIoReq->tsStart, pIoReq->tsComplete, pIoReq->tsComplete - pIoReq->tsStart);
228	RTAssertDebugBreak();
229	}
230	}
231
232	pIoReq->tsComplete = RTTimeSystemMilliTS();
233	Assert(!pThis->papIoReq[pThis->iEntry]);
234	pThis->papIoReq[pThis->iEntry] = pIoReq;
235
236	pThis->iEntry = (pThis->iEntry+1) % pThis->cEntries;
237	if (pThis->papIoReq[pThis->iEntry])
238	{
239	if (!fMediaEx)
240	RTMemFree(pThis->papIoReq[pThis->iEntry]);
241	pThis->papIoReq[pThis->iEntry] = NULL;
242	}
243	}
244
245	static void drvdiskintIoLogEntryRelease(PIOLOGENT pIoLogEnt)
246	{
247	pIoLogEnt->cRefs--;
248	if (!pIoLogEnt->cRefs)
249	RTMemFree(pIoLogEnt);
250	}
251
252	/**
253	* Record a successful write to the virtual disk.
254	*
255	* @returns VBox status code.
256	* @param pThis Disk integrity driver instance data.
257	* @param paSeg Segment array of the write to record.
258	* @param cSeg Number of segments.
259	* @param off Start offset.
260	* @param cbWrite Number of bytes to record.
261	*/
262	static int drvdiskintWriteRecord(PDRVDISKINTEGRITY pThis, PCRTSGSEG paSeg, unsigned cSeg,
263	uint64_t off, size_t cbWrite)
264	{
265	int rc = VINF_SUCCESS;
266
267	LogFlowFunc(("pThis=%#p paSeg=%#p cSeg=%u off=%llx cbWrite=%u\n",
268	pThis, paSeg, cSeg, off, cbWrite));
269
270	/* Update the segments */
271	size_t cbLeft = cbWrite;
272	RTFOFF offCurr = (RTFOFF)off;
273	RTSGBUF SgBuf;
274	PIOLOGENT pIoLogEnt = (PIOLOGENT)RTMemAllocZ(sizeof(IOLOGENT));
275	if (!pIoLogEnt)
276	return VERR_NO_MEMORY;
277
278	pIoLogEnt->off = off;
279	pIoLogEnt->cbWrite = cbWrite;
280	pIoLogEnt->cRefs = 0;
281
282	RTSgBufInit(&SgBuf, paSeg, cSeg);
283
284	while (cbLeft)
285	{
286	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offCurr);
287	size_t cbRange = 0;
288	bool fSet = false;
289	unsigned offSeg = 0;
290
291	if (!pSeg)
292	{
293	/* Get next segment */
294	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offCurr, true);
295	if ( !pSeg
296	\|\| offCurr + (RTFOFF)cbLeft <= pSeg->Core.Key)
297	cbRange = cbLeft;
298	else
299	cbRange = pSeg->Core.Key - offCurr;
300
301	Assert(cbRange % 512 == 0);
302
303	/* Create new segment */
304	pSeg = (PDRVDISKSEGMENT)RTMemAllocZ(RT_OFFSETOF(DRVDISKSEGMENT, apIoLog[cbRange / 512]));
305	if (pSeg)
306	{
307	pSeg->Core.Key = offCurr;
308	pSeg->Core.KeyLast = offCurr + (RTFOFF)cbRange - 1;
309	pSeg->cbSeg = cbRange;
310	pSeg->pbSeg = (uint8_t *)RTMemAllocZ(cbRange);
311	pSeg->cIoLogEntries = cbRange / 512;
312	if (!pSeg->pbSeg)
313	RTMemFree(pSeg);
314	else
315	{
316	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
317	AssertMsg(fInserted, ("Bug!\n")); RT_NOREF(fInserted);
318	fSet = true;
319	}
320	}
321	}
322	else
323	{
324	fSet = true;
325	offSeg = offCurr - pSeg->Core.Key;
326	cbRange = RT_MIN(cbLeft, (size_t)(pSeg->Core.KeyLast + 1 - offCurr));
327	}
328
329	if (fSet)
330	{
331	AssertPtr(pSeg);
332	size_t cbCopied = RTSgBufCopyToBuf(&SgBuf, pSeg->pbSeg + offSeg, cbRange);
333	Assert(cbCopied == cbRange); RT_NOREF(cbCopied);
334
335	/* Update the I/O log pointers */
336	Assert(offSeg % 512 == 0);
337	Assert(cbRange % 512 == 0);
338	while (offSeg < cbRange)
339	{
340	uint32_t uSector = offSeg / 512;
341	PIOLOGENT pIoLogOld = NULL;
342
343	AssertMsg(uSector < pSeg->cIoLogEntries, ("Internal bug!\n"));
344
345	pIoLogOld = pSeg->apIoLog[uSector];
346	if (pIoLogOld)
347	{
348	pIoLogOld->cRefs--;
349	if (!pIoLogOld->cRefs)
350	RTMemFree(pIoLogOld);
351	}
352
353	pSeg->apIoLog[uSector] = pIoLogEnt;
354	pIoLogEnt->cRefs++;
355
356	offSeg += 512;
357	}
358	}
359	else
360	RTSgBufAdvance(&SgBuf, cbRange);
361
362	offCurr += cbRange;
363	cbLeft -= cbRange;
364	}
365
366	return rc;
367	}
368
369	/**
370	* Verifies a read request.
371	*
372	* @returns VBox status code.
373	* @param pThis Disk integrity driver instance data.
374	* @param paSeg Segment array of the containing the data buffers to verify.
375	* @param cSeg Number of segments.
376	* @param off Start offset.
377	* @param cbWrite Number of bytes to verify.
378	*/
379	static int drvdiskintReadVerify(PDRVDISKINTEGRITY pThis, PCRTSGSEG paSeg, unsigned cSeg,
380	uint64_t off, size_t cbRead)
381	{
382	int rc = VINF_SUCCESS;
383
384	LogFlowFunc(("pThis=%#p paSeg=%#p cSeg=%u off=%llx cbRead=%u\n",
385	pThis, paSeg, cSeg, off, cbRead));
386
387	Assert(off % 512 == 0);
388	Assert(cbRead % 512 == 0);
389
390	/* Compare read data */
391	size_t cbLeft = cbRead;
392	RTFOFF offCurr = (RTFOFF)off;
393	RTSGBUF SgBuf;
394
395	RTSgBufInit(&SgBuf, paSeg, cSeg);
396
397	while (cbLeft)
398	{
399	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offCurr);
400	size_t cbRange = 0;
401	bool fCmp = false;
402	unsigned offSeg = 0;
403
404	if (!pSeg)
405	{
406	/* Get next segment */
407	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offCurr, true);
408	if (!pSeg)
409	{
410	/* No data in the tree for this read. Assume everything is ok. */
411	cbRange = cbLeft;
412	}
413	else if (offCurr + (RTFOFF)cbLeft <= pSeg->Core.Key)
414	cbRange = cbLeft;
415	else
416	cbRange = pSeg->Core.Key - offCurr;
417
418	if (pThis->fPrepopulateRamDisk)
419	{
420	/* No segment means everything should be 0 for this part. */
421	if (!RTSgBufIsZero(&SgBuf, cbRange))
422	{
423	RTMsgError("Corrupted disk at offset %llu (expected everything to be 0)!\n",
424	offCurr);
425	RTAssertDebugBreak();
426	}
427	}
428	}
429	else
430	{
431	fCmp = true;
432	offSeg = offCurr - pSeg->Core.Key;
433	cbRange = RT_MIN(cbLeft, (size_t)(pSeg->Core.KeyLast + 1 - offCurr));
434	}
435
436	if (fCmp)
437	{
438	RTSGSEG Seg;
439	RTSGBUF SgBufCmp;
440	size_t cbOff = 0;
441
442	Seg.cbSeg = cbRange;
443	Seg.pvSeg = pSeg->pbSeg + offSeg;
444
445	RTSgBufInit(&SgBufCmp, &Seg, 1);
446	if (RTSgBufCmpEx(&SgBuf, &SgBufCmp, cbRange, &cbOff, true))
447	{
448	/* Corrupted disk, print I/O log entry of the last write which accessed this range. */
449	uint32_t cSector = (offSeg + cbOff) / 512;
450	AssertMsg(cSector < pSeg->cIoLogEntries, ("Internal bug!\n"));
451
452	RTMsgError("Corrupted disk at offset %llu (%u bytes in the current read buffer)!\n",
453	offCurr + cbOff, cbOff);
454	RTMsgError("Last write to this sector started at offset %llu with %u bytes (%u references to this log entry)\n",
455	pSeg->apIoLog[cSector]->off,
456	pSeg->apIoLog[cSector]->cbWrite,
457	pSeg->apIoLog[cSector]->cRefs);
458	RTAssertDebugBreak();
459	}
460	}
461	else
462	RTSgBufAdvance(&SgBuf, cbRange);
463
464	offCurr += cbRange;
465	cbLeft -= cbRange;
466	}
467
468	return rc;
469	}
470
471	/**
472	* Discards the given ranges from the disk.
473	*
474	* @returns VBox status code.
475	* @param pThis Disk integrity driver instance data.
476	* @param paRanges Array of ranges to discard.
477	* @param cRanges Number of ranges in the array.
478	*/
479	static int drvdiskintDiscardRecords(PDRVDISKINTEGRITY pThis, PCRTRANGE paRanges, unsigned cRanges)
480	{
481	int rc = VINF_SUCCESS;
482
483	LogFlowFunc(("pThis=%#p paRanges=%#p cRanges=%u\n", pThis, paRanges, cRanges));
484
485	for (unsigned i = 0; i < cRanges; i++)
486	{
487	uint64_t offStart = paRanges[i].offStart;
488	size_t cbLeft = paRanges[i].cbRange;
489
490	LogFlowFunc(("Discarding off=%llu cbRange=%zu\n", offStart, cbLeft));
491
492	while (cbLeft)
493	{
494	size_t cbRange;
495	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetRangeGet(pThis->pTreeSegments, offStart);
496
497	if (!pSeg)
498	{
499	/* Get next segment */
500	pSeg = (PDRVDISKSEGMENT)RTAvlrFileOffsetGetBestFit(pThis->pTreeSegments, offStart, true);
501	if ( !pSeg
502	\|\| (RTFOFF)offStart + (RTFOFF)cbLeft <= pSeg->Core.Key)
503	cbRange = cbLeft;
504	else
505	cbRange = pSeg->Core.Key - offStart;
506
507	Assert(!(cbRange % 512));
508	}
509	else
510	{
511	size_t cbPreLeft, cbPostLeft;
512
513	cbRange = RT_MIN(cbLeft, pSeg->Core.KeyLast - offStart + 1);
514	cbPreLeft = offStart - pSeg->Core.Key;
515	cbPostLeft = pSeg->cbSeg - cbRange - cbPreLeft;
516
517	Assert(!(cbRange % 512));
518	Assert(!(cbPreLeft % 512));
519	Assert(!(cbPostLeft % 512));
520
521	LogFlowFunc(("cbRange=%zu cbPreLeft=%zu cbPostLeft=%zu\n",
522	cbRange, cbPreLeft, cbPostLeft));
523
524	RTAvlrFileOffsetRemove(pThis->pTreeSegments, pSeg->Core.Key);
525
526	if (!cbPreLeft && !cbPostLeft)
527	{
528	/* Just free the whole segment. */
529	LogFlowFunc(("Freeing whole segment pSeg=%#p\n", pSeg));
530	RTMemFree(pSeg->pbSeg);
531	for (unsigned idx = 0; idx < pSeg->cIoLogEntries; idx++)
532	drvdiskintIoLogEntryRelease(pSeg->apIoLog[idx]);
533	RTMemFree(pSeg);
534	}
535	else if (cbPreLeft && !cbPostLeft)
536	{
537	/* Realloc to new size and insert. */
538	LogFlowFunc(("Realloc segment pSeg=%#p\n", pSeg));
539	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPreLeft);
540	for (unsigned idx = cbPreLeft / 512; idx < pSeg->cIoLogEntries; idx++)
541	drvdiskintIoLogEntryRelease(pSeg->apIoLog[idx]);
542	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, RT_OFFSETOF(DRVDISKSEGMENT, apIoLog[cbPreLeft / 512]));
543	pSeg->Core.KeyLast = pSeg->Core.Key + cbPreLeft - 1;
544	pSeg->cbSeg = cbPreLeft;
545	pSeg->cIoLogEntries = cbPreLeft / 512;
546	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
547	Assert(fInserted); RT_NOREF(fInserted);
548	}
549	else if (!cbPreLeft && cbPostLeft)
550	{
551	/* Move data to the front and realloc. */
552	LogFlowFunc(("Move data and realloc segment pSeg=%#p\n", pSeg));
553	memmove(pSeg->pbSeg, pSeg->pbSeg + cbRange, cbPostLeft);
554	for (unsigned idx = 0; idx < cbRange / 512; idx++)
555	drvdiskintIoLogEntryRelease(pSeg->apIoLog[idx]);
556	for (unsigned idx = 0; idx < cbPostLeft /512; idx++)
557	pSeg->apIoLog[idx] = pSeg->apIoLog[(cbRange / 512) + idx];
558	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, RT_OFFSETOF(DRVDISKSEGMENT, apIoLog[cbPostLeft / 512]));
559	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPostLeft);
560	pSeg->Core.Key += cbRange;
561	pSeg->cbSeg = cbPostLeft;
562	pSeg->cIoLogEntries = cbPostLeft / 512;
563	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
564	Assert(fInserted); RT_NOREF(fInserted);
565	}
566	else
567	{
568	/* Split the segment into 2 new segments. */
569	LogFlowFunc(("Split segment pSeg=%#p\n", pSeg));
570	PDRVDISKSEGMENT pSegPost = (PDRVDISKSEGMENT)RTMemAllocZ(RT_OFFSETOF(DRVDISKSEGMENT, apIoLog[cbPostLeft / 512]));
571	if (pSegPost)
572	{
573	pSegPost->Core.Key = pSeg->Core.Key + cbPreLeft + cbRange;
574	pSegPost->Core.KeyLast = pSeg->Core.KeyLast;
575	pSegPost->cbSeg = cbPostLeft;
576	pSegPost->pbSeg = (uint8_t *)RTMemAllocZ(cbPostLeft);
577	pSegPost->cIoLogEntries = cbPostLeft / 512;
578	if (!pSegPost->pbSeg)
579	RTMemFree(pSegPost);
580	else
581	{
582	memcpy(pSegPost->pbSeg, pSeg->pbSeg + cbPreLeft + cbRange, cbPostLeft);
583	for (unsigned idx = 0; idx < cbPostLeft / 512; idx++)
584	pSegPost->apIoLog[idx] = pSeg->apIoLog[((cbPreLeft + cbRange) / 512) + idx];
585
586	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSegPost->Core);
587	Assert(fInserted); RT_NOREF(fInserted);
588	}
589	}
590
591	/* Shrink the current segment. */
592	pSeg->pbSeg = (uint8_t *)RTMemRealloc(pSeg->pbSeg, cbPreLeft);
593	for (unsigned idx = cbPreLeft / 512; idx < (cbPreLeft + cbRange) / 512; idx++)
594	drvdiskintIoLogEntryRelease(pSeg->apIoLog[idx]);
595	pSeg = (PDRVDISKSEGMENT)RTMemRealloc(pSeg, RT_OFFSETOF(DRVDISKSEGMENT, apIoLog[cbPreLeft / 512]));
596	pSeg->Core.KeyLast = pSeg->Core.Key + cbPreLeft - 1;
597	pSeg->cbSeg = cbPreLeft;
598	pSeg->cIoLogEntries = cbPreLeft / 512;
599	bool fInserted = RTAvlrFileOffsetInsert(pThis->pTreeSegments, &pSeg->Core);
600	Assert(fInserted); RT_NOREF(fInserted);
601	} /* if (cbPreLeft && cbPostLeft) */
602	}
603
604	offStart += cbRange;
605	cbLeft -= cbRange;
606	}
607	}
608
609	LogFlowFunc(("returns rc=%Rrc\n", rc));
610	return rc;
611	}
612
613	/**
614	* Adds a request to the active list.
615	*
616	* @returns nothing.
617	* @param pThis The driver instance data.
618	* @param pIoReq The request to add.
619	*/
620	static void drvdiskintIoReqAdd(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq)
621	{
622	PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[pThis->iNextFreeSlot];
623
624	Assert(!pReqActive->pIoReq);
625	pReqActive->tsStart = pIoReq->tsStart;
626	pReqActive->pIoReq = pIoReq;
627	pIoReq->iSlot = pThis->iNextFreeSlot;
628
629	/* Search for the next one. */
630	while (pThis->apReqActive[pThis->iNextFreeSlot].pIoReq)
631	pThis->iNextFreeSlot = (pThis->iNextFreeSlot+1) % RT_ELEMENTS(pThis->apReqActive);
632	}
633
634	/**
635	* Removes a request from the active list.
636	*
637	* @returns nothing.
638	* @param pThis The driver instance data.
639	* @param pIoReq The request to remove.
640	*/
641	static void drvdiskintIoReqRemove(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq)
642	{
643	PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[pIoReq->iSlot];
644
645	Assert(pReqActive->pIoReq == pIoReq);
646
647	ASMAtomicWriteNullPtr(&pReqActive->pIoReq);
648	}
649
650	/**
651	* Thread checking for expired requests.
652	*
653	* @returns IPRT status code.
654	* @param pThread Thread handle.
655	* @param pvUser Opaque user data.
656	*/
657	static DECLCALLBACK(int) drvdiskIntIoReqExpiredCheck(RTTHREAD pThread, void *pvUser)
658	{
659	PDRVDISKINTEGRITY pThis = (PDRVDISKINTEGRITY)pvUser;
660
661	RT_NOREF(pThread);
662
663	while (pThis->fRunning)
664	{
665	int rc = RTSemEventWait(pThis->SemEvent, pThis->uCheckIntervalMs);
666
667	if (!pThis->fRunning)
668	break;
669
670	Assert(rc == VERR_TIMEOUT); RT_NOREF(rc);
671
672	/* Get current timestamp for comparison. */
673	uint64_t tsCurr = RTTimeSystemMilliTS();
674
675	/* Go through the array and check for expired requests. */
676	for (unsigned i = 0; i < RT_ELEMENTS(pThis->apReqActive); i++)
677	{
678	PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[i];
679	PDRVDISKAIOREQ pIoReq = ASMAtomicReadPtrT(&pReqActive->pIoReq, PDRVDISKAIOREQ);
680
681	if ( pIoReq
682	&& (tsCurr > pReqActive->tsStart)
683	&& (tsCurr - pReqActive->tsStart) >= pThis->uExpireIntervalMs)
684	{
685	RTMsgError("Request %#p expired (active for %llu ms already)\n",
686	pIoReq, tsCurr - pReqActive->tsStart);
687	RTAssertDebugBreak();
688	}
689	}
690	}
691
692	return VINF_SUCCESS;
693	}
694
695	/**
696	* Verify a completed read after write request.
697	*
698	* @returns VBox status code.
699	* @param pThis The driver instance data.
700	* @param pIoReq The request to be verified.
701	*/
702	static int drvdiskintReadAfterWriteVerify(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq)
703	{
704	int rc = VINF_SUCCESS;
705
706	if (pThis->fCheckConsistency)
707	rc = drvdiskintReadVerify(pThis, pIoReq->paSeg, pIoReq->cSeg, pIoReq->off, pIoReq->cbTransfer);
708	else /** @todo Implement read after write verification without a memory based image of the disk. */
709	AssertMsgFailed(("TODO\n"));
710
711	return rc;
712	}
713
714	/* -=-=-=-=- IMedia -=-=-=-=- */
715
716	/** Makes a PDRVDISKINTEGRITY out of a PPDMIMEDIA. */
717	#define PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface) ( (PDRVDISKINTEGRITY)((uintptr_t)pInterface - RT_OFFSETOF(DRVDISKINTEGRITY, IMedia)) )
718
719
720	/*********************************************************************************************************************************
721	* Media interface methods *
722	*********************************************************************************************************************************/
723
724	/** @interface_method_impl{PDMIMEDIA,pfnRead} */
725	static DECLCALLBACK(int) drvdiskintRead(PPDMIMEDIA pInterface,
726	uint64_t off, void *pvBuf, size_t cbRead)
727	{
728	int rc = VINF_SUCCESS;
729	VDIOLOGENT hIoLogEntry;
730	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
731
732	if (pThis->hIoLogger)
733	{
734	rc = VDDbgIoLogStart(pThis->hIoLogger, false, VDDBGIOLOGREQ_READ, off,
735	cbRead, NULL, &hIoLogEntry);
736	AssertRC(rc);
737	}
738
739	rc = pThis->pDrvMedia->pfnRead(pThis->pDrvMedia, off, pvBuf, cbRead);
740
741	if (pThis->hIoLogger)
742	{
743	RTSGSEG Seg;
744	RTSGBUF SgBuf;
745
746	Seg.pvSeg = pvBuf;
747	Seg.cbSeg = cbRead;
748	RTSgBufInit(&SgBuf, &Seg, 1);
749
750	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, hIoLogEntry, rc, &SgBuf);
751	AssertRC(rc2);
752	}
753
754	if (RT_FAILURE(rc))
755	return rc;
756
757	if (pThis->fCheckConsistency)
758	{
759	/* Verify the read. */
760	RTSGSEG Seg;
761	Seg.cbSeg = cbRead;
762	Seg.pvSeg = pvBuf;
763	rc = drvdiskintReadVerify(pThis, &Seg, 1, off, cbRead);
764	}
765
766	return rc;
767	}
768
769	/** @interface_method_impl{PDMIMEDIA,pfnWrite} */
770	static DECLCALLBACK(int) drvdiskintWrite(PPDMIMEDIA pInterface,
771	uint64_t off, const void *pvBuf,
772	size_t cbWrite)
773	{
774	int rc = VINF_SUCCESS;
775	VDIOLOGENT hIoLogEntry;
776	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
777
778	if (pThis->hIoLogger)
779	{
780	RTSGSEG Seg;
781	RTSGBUF SgBuf;
782
783	Seg.pvSeg = (void *)pvBuf;
784	Seg.cbSeg = cbWrite;
785	RTSgBufInit(&SgBuf, &Seg, 1);
786
787	rc = VDDbgIoLogStart(pThis->hIoLogger, false, VDDBGIOLOGREQ_WRITE, off,
788	cbWrite, &SgBuf, &hIoLogEntry);
789	AssertRC(rc);
790	}
791
792	if (pThis->fRecordWriteBeforeCompletion)
793	{
794	RTSGSEG Seg;
795	Seg.cbSeg = cbWrite;
796	Seg.pvSeg = (void *)pvBuf;
797
798	rc = drvdiskintWriteRecord(pThis, &Seg, 1, off, cbWrite);
799	if (RT_FAILURE(rc))
800	return rc;
801	}
802
803	rc = pThis->pDrvMedia->pfnWrite(pThis->pDrvMedia, off, pvBuf, cbWrite);
804
805	if (pThis->hIoLogger)
806	{
807	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, hIoLogEntry, rc, NULL);
808	AssertRC(rc2);
809	}
810
811	if (RT_FAILURE(rc))
812	return rc;
813
814	if ( pThis->fCheckConsistency
815	&& !pThis->fRecordWriteBeforeCompletion)
816	{
817	/* Record the write. */
818	RTSGSEG Seg;
819	Seg.cbSeg = cbWrite;
820	Seg.pvSeg = (void *)pvBuf;
821	rc = drvdiskintWriteRecord(pThis, &Seg, 1, off, cbWrite);
822	}
823
824	return rc;
825	}
826
827	/** @interface_method_impl{PDMIMEDIA,pfnFlush} */
828	static DECLCALLBACK(int) drvdiskintFlush(PPDMIMEDIA pInterface)
829	{
830	int rc = VINF_SUCCESS;
831	VDIOLOGENT hIoLogEntry;
832	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
833
834	if (pThis->hIoLogger)
835	{
836	rc = VDDbgIoLogStart(pThis->hIoLogger, false, VDDBGIOLOGREQ_FLUSH, 0,
837	0, NULL, &hIoLogEntry);
838	AssertRC(rc);
839	}
840
841	rc = pThis->pDrvMedia->pfnFlush(pThis->pDrvMedia);
842
843	if (pThis->hIoLogger)
844	{
845	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, hIoLogEntry, rc, NULL);
846	AssertRC(rc2);
847	}
848
849	return rc;
850	}
851
852	/** @interface_method_impl{PDMIMEDIA,pfnGetSize} */
853	static DECLCALLBACK(uint64_t) drvdiskintGetSize(PPDMIMEDIA pInterface)
854	{
855	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
856	return pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia);
857	}
858
859	/** @interface_method_impl{PDMIMEDIA,pfnIsReadOnly} */
860	static DECLCALLBACK(bool) drvdiskintIsReadOnly(PPDMIMEDIA pInterface)
861	{
862	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
863	return pThis->pDrvMedia->pfnIsReadOnly(pThis->pDrvMedia);
864	}
865
866	/** @interface_method_impl{PDMIMEDIA,pfnBiosIsVisible} */
867	static DECLCALLBACK(bool) drvdiskintBiosIsVisible(PPDMIMEDIA pInterface)
868	{
869	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
870	return pThis->pDrvMedia->pfnBiosIsVisible(pInterface);
871	}
872
873	/** @interface_method_impl{PDMIMEDIA,pfnGetType} */
874	static DECLCALLBACK(PDMMEDIATYPE) drvdiskintGetType(PPDMIMEDIA pInterface)
875	{
876	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
877	return pThis->pDrvMedia->pfnGetType(pThis->pDrvMedia);
878	}
879
880	/** @interface_method_impl{PDMIMEDIA,pfnBiosGetPCHSGeometry} */
881	static DECLCALLBACK(int) drvdiskintBiosGetPCHSGeometry(PPDMIMEDIA pInterface,
882	PPDMMEDIAGEOMETRY pPCHSGeometry)
883	{
884	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
885	return pThis->pDrvMedia->pfnBiosGetPCHSGeometry(pThis->pDrvMedia, pPCHSGeometry);
886	}
887
888	/** @interface_method_impl{PDMIMEDIA,pfnBiosSetPCHSGeometry} */
889	static DECLCALLBACK(int) drvdiskintBiosSetPCHSGeometry(PPDMIMEDIA pInterface,
890	PCPDMMEDIAGEOMETRY pPCHSGeometry)
891	{
892	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
893	return pThis->pDrvMedia->pfnBiosSetPCHSGeometry(pThis->pDrvMedia, pPCHSGeometry);
894	}
895
896	/** @interface_method_impl{PDMIMEDIA,pfnBiosGetLCHSGeometry} */
897	static DECLCALLBACK(int) drvdiskintBiosGetLCHSGeometry(PPDMIMEDIA pInterface,
898	PPDMMEDIAGEOMETRY pLCHSGeometry)
899	{
900	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
901	return pThis->pDrvMedia->pfnBiosGetLCHSGeometry(pThis->pDrvMedia, pLCHSGeometry);
902	}
903
904	/** @interface_method_impl{PDMIMEDIA,pfnBiosSetLCHSGeometry} */
905	static DECLCALLBACK(int) drvdiskintBiosSetLCHSGeometry(PPDMIMEDIA pInterface,
906	PCPDMMEDIAGEOMETRY pLCHSGeometry)
907	{
908	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
909	return pThis->pDrvMedia->pfnBiosSetLCHSGeometry(pThis->pDrvMedia, pLCHSGeometry);
910	}
911
912	/** @interface_method_impl{PDMIMEDIA,pfnGetUuid} */
913	static DECLCALLBACK(int) drvdiskintGetUuid(PPDMIMEDIA pInterface, PRTUUID pUuid)
914	{
915	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
916	return pThis->pDrvMedia->pfnGetUuid(pThis->pDrvMedia, pUuid);
917	}
918
919	/** @interface_method_impl{PDMIMEDIA,pfnGetSectorSize} */
920	static DECLCALLBACK(uint32_t) drvdiskintGetSectorSize(PPDMIMEDIA pInterface)
921	{
922	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
923	return pThis->pDrvMedia->pfnGetSectorSize(pThis->pDrvMedia);
924	}
925
926	/** @interface_method_impl{PDMIMEDIA,pfnDiscard} */
927	static DECLCALLBACK(int) drvdiskintDiscard(PPDMIMEDIA pInterface, PCRTRANGE paRanges, unsigned cRanges)
928	{
929	int rc = VINF_SUCCESS;
930	VDIOLOGENT hIoLogEntry;
931	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
932
933	if (pThis->hIoLogger)
934	{
935	rc = VDDbgIoLogStartDiscard(pThis->hIoLogger, false, paRanges, cRanges, &hIoLogEntry);
936	AssertRC(rc);
937	}
938
939	rc = pThis->pDrvMedia->pfnDiscard(pThis->pDrvMedia, paRanges, cRanges);
940
941	if (pThis->hIoLogger)
942	{
943	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, hIoLogEntry, rc, NULL);
944	AssertRC(rc2);
945	}
946
947	if (pThis->fCheckConsistency)
948	rc = drvdiskintDiscardRecords(pThis, paRanges, cRanges);
949
950	return rc;
951	}
952
953	/** @interface_method_impl{PDMIMEDIA,pfnReadPcBios} */
954	static DECLCALLBACK(int) drvdiskintReadPcBios(PPDMIMEDIA pInterface,
955	uint64_t off, void *pvBuf, size_t cbRead)
956	{
957	LogFlowFunc(("\n"));
958	PDRVDISKINTEGRITY pThis = PDMIMEDIA_2_DRVDISKINTEGRITY(pInterface);
959
960	return pThis->pDrvMedia->pfnReadPcBios(pThis->pDrvMedia, off, pvBuf, cbRead);
961	}
962
963	/* -=-=-=-=- IMediaPort -=-=-=-=- */
964
965	/** Makes a PDRVBLOCK out of a PPDMIMEDIAPORT. */
966	#define PDMIMEDIAPORT_2_DRVDISKINTEGRITY(pInterface) ( (PDRVDISKINTEGRITY((uintptr_t)pInterface - RT_OFFSETOF(DRVDISKINTEGRITY, IMediaPort))) )
967
968	/**
969	* @interface_method_impl{PDMIMEDIAPORT,pfnQueryDeviceLocation}
970	*/
971	static DECLCALLBACK(int) drvdiskintQueryDeviceLocation(PPDMIMEDIAPORT pInterface, const char **ppcszController,
972	uint32_t piInstance, uint32_t piLUN)
973	{
974	PDRVDISKINTEGRITY pThis = PDMIMEDIAPORT_2_DRVDISKINTEGRITY(pInterface);
975
976	return pThis->pDrvMediaPort->pfnQueryDeviceLocation(pThis->pDrvMediaPort, ppcszController,
977	piInstance, piLUN);
978	}
979
980	/* -=-=-=-=- IMediaExPort -=-=-=-=- */
981
982	/**
983	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
984	*/
985	static DECLCALLBACK(int) drvdiskintIoReqCompleteNotify(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
986	void *pvIoReqAlloc, int rcReq)
987	{
988	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaExPort);
989	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)pvIoReqAlloc;
990	int rc = VINF_SUCCESS;
991
992	LogFlowFunc(("pIoReq=%#p\n", pIoReq));
993
994	/* Remove from the active list. */
995	if (pThis->fTraceRequests)
996	drvdiskintIoReqRemove(pThis, pIoReq);
997
998	if (RT_SUCCESS(rcReq) && pThis->fCheckConsistency)
999	{
1000	if (pIoReq->enmTxDir == DRVDISKAIOTXDIR_READ)
1001	rc = drvdiskintReadVerify(pThis, &pIoReq->IoSeg, 1, pIoReq->off, pIoReq->cbTransfer);
1002	else if ( pIoReq->enmTxDir == DRVDISKAIOTXDIR_WRITE
1003	&& !pThis->fRecordWriteBeforeCompletion)
1004	rc = drvdiskintWriteRecord(pThis, &pIoReq->IoSeg, 1, pIoReq->off, pIoReq->cbTransfer);
1005	else if (pIoReq->enmTxDir == DRVDISKAIOTXDIR_DISCARD)
1006	rc = drvdiskintDiscardRecords(pThis, pIoReq->paRanges, pIoReq->cRanges);
1007	else if (pIoReq->enmTxDir == DRVDISKAIOTXDIR_READ_AFTER_WRITE)
1008	rc = drvdiskintReadAfterWriteVerify(pThis, pIoReq);
1009	else
1010	AssertMsg( pIoReq->enmTxDir == DRVDISKAIOTXDIR_FLUSH
1011	\|\| ( pIoReq->enmTxDir == DRVDISKAIOTXDIR_WRITE
1012	&& pThis->fRecordWriteBeforeCompletion), ("Huh?\n"));
1013
1014	AssertRC(rc);
1015	}
1016
1017	if ( RT_SUCCESS(rcReq)
1018	&& pThis->fValidateMemBufs
1019	&& pIoReq->enmTxDir == DRVDISKAIOTXDIR_READ)
1020	{
1021	/* Check that the guest memory buffer matches what was written. */
1022	RTSGSEG SegCmp;
1023	SegCmp.pvSeg = RTMemAlloc(pIoReq->cbTransfer);
1024	SegCmp.cbSeg = pIoReq->cbTransfer;
1025
1026	RTSGBUF SgBufCmp;
1027	RTSgBufInit(&SgBufCmp, &SegCmp, 1);
1028	rc = pThis->pDrvMediaExPort->pfnIoReqCopyToBuf(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1,
1029	0, &SgBufCmp, pIoReq->cbTransfer);
1030	AssertRC(rc);
1031
1032	RTSGBUF SgBuf;
1033	RTSgBufInit(&SgBuf, &pIoReq->IoSeg, 1);
1034	if (RTSgBufCmp(&SgBuf, &SgBufCmp, pIoReq->cbTransfer))
1035	{
1036	RTMsgError("Corrupted memory buffer at offset %llu!\n", 0);
1037	RTAssertDebugBreak();
1038	}
1039
1040	RTMemFree(SegCmp.pvSeg);
1041	}
1042
1043	if (pThis->hIoLogger)
1044	{
1045	RTSGBUF SgBuf;
1046
1047	if (pIoReq->enmTxDir == DRVDISKAIOTXDIR_READ)
1048	RTSgBufInit(&SgBuf, &pIoReq->IoSeg, 1);
1049
1050	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, pIoReq->hIoLogEntry, rc, &SgBuf);
1051	AssertRC(rc2);
1052	}
1053
1054	if ( pThis->fReadAfterWrite
1055	&& pIoReq->enmTxDir == DRVDISKAIOTXDIR_WRITE)
1056	{
1057	#if 0 /** @todo */
1058	pIoReq->enmTxDir = DRVDISKAIOTXDIR_READ_AFTER_WRITE;
1059
1060	/* Add again because it was removed above. */
1061	if (pThis->fTraceRequests)
1062	drvdiskintIoReqAdd(pThis, pIoReq);
1063
1064	rc = pThis->pDrvMediaAsync->pfnStartRead(pThis->pDrvMediaAsync, pIoReq->off, pIoReq->paSeg, pIoReq->cSeg,
1065	pIoReq->cbTransfer, pIoReq);
1066	if (rc == VINF_VD_ASYNC_IO_FINISHED)
1067	{
1068	rc = drvdiskintReadAfterWriteVerify(pThis, pIoReq);
1069
1070	if (pThis->fTraceRequests)
1071	drvdiskintIoReqRemove(pThis, pIoReq);
1072	RTMemFree(pIoReq);
1073	}
1074	else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1075	rc = VINF_SUCCESS;
1076	else if (RT_FAILURE(rc))
1077	RTMemFree(pIoReq);
1078	#endif
1079	}
1080	else
1081	{
1082	rc = pThis->pDrvMediaExPort->pfnIoReqCompleteNotify(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, rcReq);
1083	/* Put on the watch list. */
1084	if (pThis->fCheckDoubleCompletion)
1085	drvdiskintIoReqCheckForDoubleCompletion(pThis, pIoReq, true /* fMediaEx */);
1086	}
1087
1088	return rc;
1089	}
1090
1091	/**
1092	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyFromBuf}
1093	*/
1094	static DECLCALLBACK(int) drvdiskintIoReqCopyFromBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1095	void *pvIoReqAlloc, uint32_t offDst, PRTSGBUF pSgBuf,
1096	size_t cbCopy)
1097	{
1098	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaExPort);
1099	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)pvIoReqAlloc;
1100	RTSGBUF SgBuf;
1101
1102	RTSgBufClone(&SgBuf, pSgBuf);
1103
1104	int rc = pThis->pDrvMediaExPort->pfnIoReqCopyFromBuf(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, offDst,
1105	pSgBuf, cbCopy);
1106	if ( RT_SUCCESS(rc)
1107	&& pIoReq->IoSeg.pvSeg)
1108	{
1109	/* Update our copy. */
1110	RTSgBufCopyToBuf(&SgBuf, (uint8_t *)pIoReq->IoSeg.pvSeg + offDst, cbCopy);
1111	}
1112
1113	return rc;
1114	}
1115
1116	/**
1117	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCopyToBuf}
1118	*/
1119	static DECLCALLBACK(int) drvdiskintIoReqCopyToBuf(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1120	void *pvIoReqAlloc, uint32_t offSrc, PRTSGBUF pSgBuf,
1121	size_t cbCopy)
1122	{
1123	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaExPort);
1124	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)pvIoReqAlloc;
1125	RTSGBUF SgBuf;
1126
1127	RTSgBufClone(&SgBuf, pSgBuf);
1128
1129	int rc = pThis->pDrvMediaExPort->pfnIoReqCopyToBuf(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, offSrc,
1130	pSgBuf, cbCopy);
1131	if ( RT_SUCCESS(rc)
1132	&& pIoReq->IoSeg.pvSeg)
1133	{
1134	if (pThis->fValidateMemBufs)
1135	{
1136	/* Make sure what the caller requested matches what we got earlier. */
1137	RTSGBUF SgBufCmp;
1138	RTSgBufInit(&SgBufCmp, &pIoReq->IoSeg, 1);
1139	RTSgBufAdvance(&SgBufCmp, offSrc);
1140
1141	if (RTSgBufCmp(&SgBuf, &SgBufCmp, cbCopy))
1142	{
1143	RTMsgError("Corrupted memory buffer at offset %llu!\n", offSrc);
1144	RTAssertDebugBreak();
1145	}
1146	}
1147	else
1148	{
1149	/* Update our copy. */
1150	RTSgBufCopyToBuf(&SgBuf, (uint8_t *)pIoReq->IoSeg.pvSeg + offSrc, cbCopy);
1151	}
1152	}
1153
1154	return rc;
1155	}
1156
1157	/**
1158	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqQueryDiscardRanges}
1159	*/
1160	static DECLCALLBACK(int) drvdiskintIoReqQueryDiscardRanges(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1161	void *pvIoReqAlloc, uint32_t idxRangeStart,
1162	uint32_t cRanges, PRTRANGE paRanges,
1163	uint32_t *pcRanges)
1164	{
1165	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaExPort);
1166	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)pvIoReqAlloc;
1167
1168	return pThis->pDrvMediaExPort->pfnIoReqQueryDiscardRanges(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, idxRangeStart,
1169	cRanges, paRanges, pcRanges);
1170	}
1171
1172	/**
1173	* @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqStateChanged}
1174	*/
1175	static DECLCALLBACK(void) drvdiskintIoReqStateChanged(PPDMIMEDIAEXPORT pInterface, PDMMEDIAEXIOREQ hIoReq,
1176	void *pvIoReqAlloc, PDMMEDIAEXIOREQSTATE enmState)
1177	{
1178	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaExPort);
1179	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)pvIoReqAlloc;
1180
1181	pThis->pDrvMediaExPort->pfnIoReqStateChanged(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, enmState);
1182	}
1183
1184	/* -=-=-=-=- IMediaEx -=-=-=-=- */
1185
1186	/**
1187	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqAllocSizeSet}
1188	*/
1189	static DECLCALLBACK(int) drvdiskintIoReqAllocSizeSet(PPDMIMEDIAEX pInterface, size_t cbIoReqAlloc)
1190	{
1191	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1192
1193	/* Increase the amount by our private tracking structure. */
1194	cbIoReqAlloc += sizeof(DRVDISKAIOREQ);
1195
1196	pThis->fCheckDoubleCompletion = false;
1197
1198	return pThis->pDrvMediaEx->pfnIoReqAllocSizeSet(pThis->pDrvMediaEx, cbIoReqAlloc);
1199	}
1200
1201	/**
1202	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqAlloc}
1203	*/
1204	static DECLCALLBACK(int) drvdiskintIoReqAlloc(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc,
1205	PDMMEDIAEXIOREQID uIoReqId, uint32_t fFlags)
1206	{
1207	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1208	PDRVDISKAIOREQ pIoReq = NULL;
1209
1210	int rc = pThis->pDrvMediaEx->pfnIoReqAlloc(pThis->pDrvMediaEx, phIoReq, (void **)&pIoReq, uIoReqId, fFlags);
1211	if RT_SUCCESS(rc)
1212	{
1213	pIoReq->enmTxDir = DRVDISKAIOTXDIR_INVALID;
1214	pIoReq->off = 0;
1215	pIoReq->cbTransfer = 0;
1216	pIoReq->paSeg = NULL;
1217	pIoReq->cSeg = 0;
1218	pIoReq->pvUser = NULL;
1219	pIoReq->iSlot = 0;
1220	pIoReq->tsStart = 0;
1221	pIoReq->tsComplete = 0;
1222	pIoReq->hIoLogEntry = NULL;
1223	pIoReq->IoSeg.pvSeg = NULL;
1224	pIoReq->IoSeg.cbSeg = 0;
1225
1226	/*
1227	* Store the size off the start of our tracking structure because it is
1228	* required to access it for the read/write callbacks.
1229	*
1230	* ASSUMPTION that the offset is constant.
1231	*/
1232	if (!pThis->cbIoReqOpaque)
1233	pThis->cbIoReqOpaque = (uintptr_t)pIoReq - (uintptr_t)*phIoReq;
1234	else
1235	Assert(pThis->cbIoReqOpaque == (uintptr_t)pIoReq - (uintptr_t)*phIoReq);
1236
1237	*ppvIoReqAlloc = pIoReq + 1;
1238	}
1239
1240	return rc;
1241	}
1242
1243	/**
1244	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqFree}
1245	*/
1246	static DECLCALLBACK(int) drvdiskintIoReqFree(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
1247	{
1248	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1249	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)((uintptr_t)hIoReq + pThis->cbIoReqOpaque);
1250
1251	if (pIoReq->IoSeg.pvSeg)
1252	RTMemFree(pIoReq->IoSeg.pvSeg);
1253
1254	return pThis->pDrvMediaEx->pfnIoReqFree(pThis->pDrvMediaEx, hIoReq);
1255	}
1256
1257	/**
1258	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqCancel}
1259	*/
1260	static DECLCALLBACK(int) drvdiskintIoReqCancel(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQID uIoReqId)
1261	{
1262	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1263	return pThis->pDrvMediaEx->pfnIoReqCancel(pThis->pDrvMediaEx, uIoReqId);
1264	}
1265
1266	/**
1267	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqRead}
1268	*/
1269	static DECLCALLBACK(int) drvdiskintIoReqRead(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbRead)
1270	{
1271	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1272	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)((uintptr_t)hIoReq + pThis->cbIoReqOpaque);
1273
1274	pIoReq->enmTxDir = DRVDISKAIOTXDIR_READ;
1275	pIoReq->off = off;
1276	pIoReq->cbTransfer = cbRead;
1277
1278	/* Allocate a I/O buffer if the I/O is verified.*/
1279	if (pThis->fCheckConsistency)
1280	{
1281	pIoReq->IoSeg.pvSeg = RTMemAlloc(cbRead);
1282	pIoReq->IoSeg.cbSeg = cbRead;
1283	}
1284
1285	if (pThis->fTraceRequests)
1286	drvdiskintIoReqAdd(pThis, pIoReq);
1287
1288	if (pThis->hIoLogger)
1289	{
1290	int rc2 = VDDbgIoLogStart(pThis->hIoLogger, true, VDDBGIOLOGREQ_READ, off,
1291	cbRead, NULL, &pIoReq->hIoLogEntry);
1292	AssertRC(rc2);
1293	}
1294
1295	int rc = pThis->pDrvMediaEx->pfnIoReqRead(pThis->pDrvMediaEx, hIoReq, off, cbRead);
1296	if (rc == VINF_SUCCESS)
1297	{
1298	/* Verify the read now. */
1299	if (pThis->fCheckConsistency)
1300	{
1301	int rc2 = drvdiskintReadVerify(pThis, &pIoReq->IoSeg, 1, off, cbRead);
1302	AssertRC(rc2);
1303	}
1304
1305	if (pThis->hIoLogger)
1306	{
1307	RTSGBUF SgBuf;
1308
1309	RTSgBufInit(&SgBuf, &pIoReq->IoSeg, 1);
1310
1311	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, pIoReq->hIoLogEntry, VINF_SUCCESS, &SgBuf);
1312	AssertRC(rc2);
1313	}
1314
1315	if (pThis->fTraceRequests)
1316	drvdiskintIoReqRemove(pThis, pIoReq);
1317	}
1318
1319	LogFlowFunc(("returns %Rrc\n", rc));
1320	return rc;
1321	}
1322
1323	/**
1324	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqWrite}
1325	*/
1326	static DECLCALLBACK(int) drvdiskintIoReqWrite(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint64_t off, size_t cbWrite)
1327	{
1328	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1329	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)((uintptr_t)hIoReq + pThis->cbIoReqOpaque);
1330
1331	pIoReq->enmTxDir = DRVDISKAIOTXDIR_WRITE;
1332	pIoReq->off = off;
1333	pIoReq->cbTransfer = cbWrite;
1334
1335	/* Allocate a I/O buffer if the I/O is verified.*/
1336	if ( pThis->fCheckConsistency
1337	\|\| pThis->fValidateMemBufs
1338	\|\| pThis->hIoLogger
1339	\|\| pThis->fRecordWriteBeforeCompletion)
1340	{
1341	pIoReq->IoSeg.pvSeg = RTMemAlloc(cbWrite);
1342	pIoReq->IoSeg.cbSeg = cbWrite;
1343
1344	/* Sync the memory buffer over if we should validate it. */
1345	if ( pThis->fValidateMemBufs
1346	\|\| pThis->hIoLogger
1347	\|\| pThis->fRecordWriteBeforeCompletion)
1348	{
1349	RTSGBUF SgBuf;
1350
1351	RTSgBufInit(&SgBuf, &pIoReq->IoSeg, 1);
1352	int rc2 = pThis->pDrvMediaExPort->pfnIoReqCopyToBuf(pThis->pDrvMediaExPort, hIoReq, pIoReq + 1, 0,
1353	&SgBuf, cbWrite);
1354	AssertRC(rc2);
1355	}
1356	}
1357
1358	if (pThis->fTraceRequests)
1359	drvdiskintIoReqAdd(pThis, pIoReq);
1360
1361	if (pThis->hIoLogger)
1362	{
1363	RTSGBUF SgBuf;
1364
1365	RTSgBufInit(&SgBuf, &pIoReq->IoSeg, 1);
1366	int rc2 = VDDbgIoLogStart(pThis->hIoLogger, true, VDDBGIOLOGREQ_WRITE, off,
1367	cbWrite, &SgBuf, &pIoReq->hIoLogEntry);
1368	AssertRC(rc2);
1369	}
1370
1371	if (pThis->fRecordWriteBeforeCompletion)
1372	{
1373
1374	int rc2 = drvdiskintWriteRecord(pThis, &pIoReq->IoSeg, 1, off, cbWrite);
1375	AssertRC(rc2);
1376	}
1377
1378	int rc = pThis->pDrvMediaEx->pfnIoReqWrite(pThis->pDrvMediaEx, hIoReq, off, cbWrite);
1379	if (rc == VINF_SUCCESS)
1380	{
1381	/* Record the write. */
1382	if ( pThis->fCheckConsistency
1383	&& !pThis->fRecordWriteBeforeCompletion)
1384	{
1385	int rc2 = drvdiskintWriteRecord(pThis, &pIoReq->IoSeg, 1, off, cbWrite);
1386	AssertRC(rc2);
1387	}
1388
1389	if (pThis->hIoLogger)
1390	{
1391	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, pIoReq->hIoLogEntry, VINF_SUCCESS, NULL);
1392	AssertRC(rc2);
1393	}
1394
1395	if (pThis->fTraceRequests)
1396	drvdiskintIoReqRemove(pThis, pIoReq);
1397	}
1398
1399	LogFlowFunc(("returns %Rrc\n", rc));
1400	return rc;
1401	}
1402
1403	/**
1404	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqFlush}
1405	*/
1406	static DECLCALLBACK(int) drvdiskintIoReqFlush(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq)
1407	{
1408	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1409	PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)((uintptr_t)hIoReq + pThis->cbIoReqOpaque);
1410
1411	pIoReq->enmTxDir = DRVDISKAIOTXDIR_FLUSH;
1412	pIoReq->off = 0;
1413	pIoReq->cbTransfer = 0;
1414
1415	if (pThis->fTraceRequests)
1416	drvdiskintIoReqAdd(pThis, pIoReq);
1417
1418	if (pThis->hIoLogger)
1419	{
1420	int rc2 = VDDbgIoLogStart(pThis->hIoLogger, true, VDDBGIOLOGREQ_FLUSH, 0,
1421	0, NULL, &pIoReq->hIoLogEntry);
1422	AssertRC(rc2);
1423	}
1424
1425	int rc = pThis->pDrvMediaEx->pfnIoReqFlush(pThis->pDrvMediaEx, hIoReq);
1426	if (rc == VINF_SUCCESS)
1427	{
1428	if (pThis->hIoLogger)
1429	{
1430	int rc2 = VDDbgIoLogComplete(pThis->hIoLogger, pIoReq->hIoLogEntry, VINF_SUCCESS, NULL);
1431	AssertRC(rc2);
1432	}
1433	}
1434
1435	LogFlowFunc(("returns %Rrc\n", rc));
1436	return rc;
1437	}
1438
1439	/**
1440	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqDiscard}
1441	*/
1442	static DECLCALLBACK(int) drvdiskintIoReqDiscard(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, unsigned cRangesMax)
1443	{
1444	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1445	return pThis->pDrvMediaEx->pfnIoReqDiscard(pThis->pDrvMediaEx, hIoReq, cRangesMax);
1446	}
1447
1448	/**
1449	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetActiveCount}
1450	*/
1451	static DECLCALLBACK(uint32_t) drvdiskintIoReqGetActiveCount(PPDMIMEDIAEX pInterface)
1452	{
1453	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1454	return pThis->pDrvMediaEx->pfnIoReqGetActiveCount(pThis->pDrvMediaEx);
1455	}
1456
1457	/**
1458	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqGetSuspendedCount}
1459	*/
1460	static DECLCALLBACK(uint32_t) drvdiskintIoReqGetSuspendedCount(PPDMIMEDIAEX pInterface)
1461	{
1462	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1463	return pThis->pDrvMediaEx->pfnIoReqGetSuspendedCount(pThis->pDrvMediaEx);
1464	}
1465
1466	/**
1467	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedStart}
1468	*/
1469	static DECLCALLBACK(int) drvdiskintIoReqQuerySuspendedStart(PPDMIMEDIAEX pInterface, PPDMMEDIAEXIOREQ phIoReq, void **ppvIoReqAlloc)
1470	{
1471	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1472	return pThis->pDrvMediaEx->pfnIoReqQuerySuspendedStart(pThis->pDrvMediaEx, phIoReq, ppvIoReqAlloc);
1473	}
1474
1475	/**
1476	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqQuerySuspendedNext}
1477	*/
1478	static DECLCALLBACK(int) drvdiskintIoReqQuerySuspendedNext(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
1479	PPDMMEDIAEXIOREQ phIoReqNext, void **ppvIoReqAllocNext)
1480	{
1481	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1482	return pThis->pDrvMediaEx->pfnIoReqQuerySuspendedNext(pThis->pDrvMediaEx, hIoReq, phIoReqNext, ppvIoReqAllocNext);
1483	}
1484
1485	/**
1486	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedSave}
1487	*/
1488	static DECLCALLBACK(int) drvdiskintIoReqSuspendedSave(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1489	{
1490	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1491	return pThis->pDrvMediaEx->pfnIoReqSuspendedSave(pThis->pDrvMediaEx, pSSM, hIoReq);
1492	}
1493
1494	/**
1495	* @interface_method_impl{PDMIMEDIAEX,pfnIoReqSuspendedLoad}
1496	*/
1497	static DECLCALLBACK(int) drvdiskintIoReqSuspendedLoad(PPDMIMEDIAEX pInterface, PSSMHANDLE pSSM, PDMMEDIAEXIOREQ hIoReq)
1498	{
1499	PDRVDISKINTEGRITY pThis = RT_FROM_MEMBER(pInterface, DRVDISKINTEGRITY, IMediaEx);
1500	return pThis->pDrvMediaEx->pfnIoReqSuspendedLoad(pThis->pDrvMediaEx, pSSM, hIoReq);
1501	}
1502
1503	/* -=-=-=-=- IBase -=-=-=-=- */
1504
1505	/**
1506	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
1507	*/
1508	static DECLCALLBACK(void ) drvdiskintQueryInterface(PPDMIBASE pInterface, const char pszIID)
1509	{
1510	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1511	PDRVDISKINTEGRITY pThis = PDMINS_2_DATA(pDrvIns, PDRVDISKINTEGRITY);
1512
1513	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1514	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIA, &pThis->IMedia);
1515	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAPORT, &pThis->IMediaPort);
1516	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEXPORT, &pThis->IMediaExPort);
1517	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIAEX, pThis->pDrvMediaEx ? &pThis->IMediaEx : NULL);
1518	return NULL;
1519	}
1520
1521
1522	/* -=-=-=-=- driver interface -=-=-=-=- */
1523
1524	static DECLCALLBACK(int) drvdiskintTreeDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
1525	{
1526	PDRVDISKSEGMENT pSeg = (PDRVDISKSEGMENT)pNode;
1527
1528	RT_NOREF(pvUser);
1529
1530	RTMemFree(pSeg->pbSeg);
1531	RTMemFree(pSeg);
1532	return VINF_SUCCESS;
1533	}
1534
1535	/**
1536	* @copydoc FNPDMDRVDESTRUCT
1537	*/
1538	static DECLCALLBACK(void) drvdiskintDestruct(PPDMDRVINS pDrvIns)
1539	{
1540	PDRVDISKINTEGRITY pThis = PDMINS_2_DATA(pDrvIns, PDRVDISKINTEGRITY);
1541
1542	if (pThis->pTreeSegments)
1543	{
1544	RTAvlrFileOffsetDestroy(pThis->pTreeSegments, drvdiskintTreeDestroy, NULL);
1545	RTMemFree(pThis->pTreeSegments);
1546	}
1547
1548	if (pThis->fTraceRequests)
1549	{
1550	pThis->fRunning = false;
1551	RTSemEventSignal(pThis->SemEvent);
1552	RTSemEventDestroy(pThis->SemEvent);
1553	}
1554
1555	if (pThis->fCheckDoubleCompletion)
1556	{
1557	/* Free all requests */
1558	while (pThis->papIoReq[pThis->iEntry])
1559	{
1560	RTMemFree(pThis->papIoReq[pThis->iEntry]);
1561	pThis->papIoReq[pThis->iEntry] = NULL;
1562	pThis->iEntry = (pThis->iEntry+1) % pThis->cEntries;
1563	}
1564	}
1565
1566	if (pThis->hIoLogger)
1567	VDDbgIoLogDestroy(pThis->hIoLogger);
1568	}
1569
1570	/**
1571	* Construct a disk integrity driver instance.
1572	*
1573	* @copydoc FNPDMDRVCONSTRUCT
1574	*/
1575	static DECLCALLBACK(int) drvdiskintConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1576	{
1577	int rc = VINF_SUCCESS;
1578	PDRVDISKINTEGRITY pThis = PDMINS_2_DATA(pDrvIns, PDRVDISKINTEGRITY);
1579	LogFlow(("drvdiskintConstruct: iInstance=%d\n", pDrvIns->iInstance));
1580	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1581
1582	/*
1583	* Validate configuration.
1584	*/
1585	if (!CFGMR3AreValuesValid(pCfg, "CheckConsistency\0"
1586	"TraceRequests\0"
1587	"CheckIntervalMs\0"
1588	"ExpireIntervalMs\0"
1589	"CheckDoubleCompletions\0"
1590	"HistorySize\0"
1591	"IoLog\0"
1592	"PrepopulateRamDisk\0"
1593	"ReadAfterWrite\0"
1594	"RecordWriteBeforeCompletion\0"
1595	"ValidateMemoryBuffers\0"))
1596	return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
1597
1598	rc = CFGMR3QueryBoolDef(pCfg, "CheckConsistency", &pThis->fCheckConsistency, false);
1599	AssertRC(rc);
1600	rc = CFGMR3QueryBoolDef(pCfg, "TraceRequests", &pThis->fTraceRequests, false);
1601	AssertRC(rc);
1602	rc = CFGMR3QueryU32Def(pCfg, "CheckIntervalMs", &pThis->uCheckIntervalMs, 5000); /* 5 seconds */
1603	AssertRC(rc);
1604	rc = CFGMR3QueryU32Def(pCfg, "ExpireIntervalMs", &pThis->uExpireIntervalMs, 20000); /* 20 seconds */
1605	AssertRC(rc);
1606	rc = CFGMR3QueryBoolDef(pCfg, "CheckDoubleCompletions", &pThis->fCheckDoubleCompletion, false);
1607	AssertRC(rc);
1608	rc = CFGMR3QueryU32Def(pCfg, "HistorySize", &pThis->cEntries, 512);
1609	AssertRC(rc);
1610	rc = CFGMR3QueryBoolDef(pCfg, "PrepopulateRamDisk", &pThis->fPrepopulateRamDisk, false);
1611	AssertRC(rc);
1612	rc = CFGMR3QueryBoolDef(pCfg, "ReadAfterWrite", &pThis->fReadAfterWrite, false);
1613	AssertRC(rc);
1614	rc = CFGMR3QueryBoolDef(pCfg, "RecordWriteBeforeCompletion", &pThis->fRecordWriteBeforeCompletion, false);
1615	AssertRC(rc);
1616	rc = CFGMR3QueryBoolDef(pCfg, "ValidateMemoryBuffers", &pThis->fValidateMemBufs, true);
1617	AssertRC(rc);
1618
1619	char *pszIoLogFilename = NULL;
1620	rc = CFGMR3QueryStringAlloc(pCfg, "IoLog", &pszIoLogFilename);
1621	Assert(RT_SUCCESS(rc) \|\| rc == VERR_CFGM_VALUE_NOT_FOUND);
1622
1623	/*
1624	* Initialize most of the data members.
1625	*/
1626	pThis->pDrvIns = pDrvIns;
1627
1628	/* IBase. */
1629	pDrvIns->IBase.pfnQueryInterface = drvdiskintQueryInterface;
1630
1631	/* IMedia */
1632	pThis->IMedia.pfnRead = drvdiskintRead;
1633	pThis->IMedia.pfnWrite = drvdiskintWrite;
1634	pThis->IMedia.pfnFlush = drvdiskintFlush;
1635	pThis->IMedia.pfnGetSize = drvdiskintGetSize;
1636	pThis->IMedia.pfnIsReadOnly = drvdiskintIsReadOnly;
1637	pThis->IMedia.pfnBiosIsVisible = drvdiskintBiosIsVisible;
1638	pThis->IMedia.pfnBiosGetPCHSGeometry = drvdiskintBiosGetPCHSGeometry;
1639	pThis->IMedia.pfnBiosSetPCHSGeometry = drvdiskintBiosSetPCHSGeometry;
1640	pThis->IMedia.pfnBiosGetLCHSGeometry = drvdiskintBiosGetLCHSGeometry;
1641	pThis->IMedia.pfnBiosSetLCHSGeometry = drvdiskintBiosSetLCHSGeometry;
1642	pThis->IMedia.pfnGetUuid = drvdiskintGetUuid;
1643	pThis->IMedia.pfnGetSectorSize = drvdiskintGetSectorSize;
1644	pThis->IMedia.pfnGetType = drvdiskintGetType;
1645	pThis->IMedia.pfnReadPcBios = drvdiskintReadPcBios;
1646
1647	/* IMediaEx. */
1648	pThis->IMediaEx.pfnIoReqAllocSizeSet = drvdiskintIoReqAllocSizeSet;
1649	pThis->IMediaEx.pfnIoReqAlloc = drvdiskintIoReqAlloc;
1650	pThis->IMediaEx.pfnIoReqFree = drvdiskintIoReqFree;
1651	pThis->IMediaEx.pfnIoReqCancel = drvdiskintIoReqCancel;
1652	pThis->IMediaEx.pfnIoReqRead = drvdiskintIoReqRead;
1653	pThis->IMediaEx.pfnIoReqWrite = drvdiskintIoReqWrite;
1654	pThis->IMediaEx.pfnIoReqFlush = drvdiskintIoReqFlush;
1655	pThis->IMediaEx.pfnIoReqDiscard = drvdiskintIoReqDiscard;
1656	pThis->IMediaEx.pfnIoReqGetActiveCount = drvdiskintIoReqGetActiveCount;
1657	pThis->IMediaEx.pfnIoReqGetSuspendedCount = drvdiskintIoReqGetSuspendedCount;
1658	pThis->IMediaEx.pfnIoReqQuerySuspendedStart = drvdiskintIoReqQuerySuspendedStart;
1659	pThis->IMediaEx.pfnIoReqQuerySuspendedNext = drvdiskintIoReqQuerySuspendedNext;
1660	pThis->IMediaEx.pfnIoReqSuspendedSave = drvdiskintIoReqSuspendedSave;
1661	pThis->IMediaEx.pfnIoReqSuspendedLoad = drvdiskintIoReqSuspendedLoad;
1662
1663	/* IMediaPort. */
1664	pThis->IMediaPort.pfnQueryDeviceLocation = drvdiskintQueryDeviceLocation;
1665
1666	/* IMediaExPort. */
1667	pThis->IMediaExPort.pfnIoReqCompleteNotify = drvdiskintIoReqCompleteNotify;
1668	pThis->IMediaExPort.pfnIoReqCopyFromBuf = drvdiskintIoReqCopyFromBuf;
1669	pThis->IMediaExPort.pfnIoReqCopyToBuf = drvdiskintIoReqCopyToBuf;
1670	pThis->IMediaExPort.pfnIoReqQueryDiscardRanges = drvdiskintIoReqQueryDiscardRanges;
1671	pThis->IMediaExPort.pfnIoReqStateChanged = drvdiskintIoReqStateChanged;
1672
1673	/* Query the media port interface above us. */
1674	pThis->pDrvMediaPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAPORT);
1675	if (!pThis->pDrvMediaPort)
1676	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW,
1677	N_("No media port inrerface above"));
1678
1679	/* Try to attach extended media port interface above.*/
1680	pThis->pDrvMediaExPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAEXPORT);
1681
1682	/*
1683	* Try attach driver below and query it's media interface.
1684	*/
1685	PPDMIBASE pBase;
1686	rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBase);
1687	if (RT_FAILURE(rc))
1688	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1689	N_("Failed to attach driver below us! %Rrc"), rc);
1690
1691	pThis->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
1692	if (!pThis->pDrvMedia)
1693	return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW,
1694	N_("No media or async media interface below"));
1695
1696	pThis->pDrvMediaEx = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIAEX);
1697
1698	if (pThis->pDrvMedia->pfnDiscard)
1699	pThis->IMedia.pfnDiscard = drvdiskintDiscard;
1700
1701	if (pThis->fCheckConsistency)
1702	{
1703	/* Create the AVL tree. */
1704	pThis->pTreeSegments = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
1705	if (!pThis->pTreeSegments)
1706	rc = VERR_NO_MEMORY;
1707	}
1708
1709	if (pThis->fTraceRequests)
1710	{
1711	for (unsigned i = 0; i < RT_ELEMENTS(pThis->apReqActive); i++)
1712	{
1713	pThis->apReqActive[i].pIoReq = NULL;
1714	pThis->apReqActive[i].tsStart = 0;
1715	}
1716
1717	pThis->iNextFreeSlot = 0;
1718
1719	/* Init event semaphore. */
1720	rc = RTSemEventCreate(&pThis->SemEvent);
1721	AssertRC(rc);
1722	pThis->fRunning = true;
1723	rc = RTThreadCreate(&pThis->hThread, drvdiskIntIoReqExpiredCheck, pThis,
1724	0, RTTHREADTYPE_INFREQUENT_POLLER, 0, "DiskIntegrity");
1725	AssertRC(rc);
1726	}
1727
1728	if (pThis->fCheckDoubleCompletion)
1729	{
1730	pThis->iEntry = 0;
1731	pThis->papIoReq = (PDRVDISKAIOREQ )RTMemAllocZ(pThis->cEntries sizeof(PDRVDISKAIOREQ));
1732	AssertPtr(pThis->papIoReq);
1733	}
1734
1735	if (pszIoLogFilename)
1736	{
1737	rc = VDDbgIoLogCreate(&pThis->hIoLogger, pszIoLogFilename, VDDBG_IOLOG_LOG_DATA);
1738	MMR3HeapFree(pszIoLogFilename);
1739	}
1740
1741	/* Read in all data before the start if requested. */
1742	if (pThis->fPrepopulateRamDisk)
1743	{
1744	uint64_t cbDisk = 0;
1745
1746	LogRel(("DiskIntegrity: Prepopulating RAM disk, this will take some time...\n"));
1747
1748	cbDisk = pThis->pDrvMedia->pfnGetSize(pThis->pDrvMedia);
1749	if (cbDisk)
1750	{
1751	uint64_t off = 0;
1752	uint8_t abBuffer[_64K];
1753	RTSGSEG Seg;
1754
1755	Seg.pvSeg = abBuffer;
1756
1757	while (cbDisk)
1758	{
1759	size_t cbThisRead = RT_MIN(cbDisk, sizeof(abBuffer));
1760
1761	rc = pThis->pDrvMedia->pfnRead(pThis->pDrvMedia, off, abBuffer, cbThisRead);
1762	if (RT_FAILURE(rc))
1763	break;
1764
1765	if (ASMBitFirstSet(abBuffer, sizeof(abBuffer) * 8) != -1)
1766	{
1767	Seg.cbSeg = cbThisRead;
1768	rc = drvdiskintWriteRecord(pThis, &Seg, 1,
1769	off, cbThisRead);
1770	if (RT_FAILURE(rc))
1771	break;
1772	}
1773
1774	cbDisk -= cbThisRead;
1775	off += cbThisRead;
1776	}
1777
1778	LogRel(("DiskIntegrity: Prepopulating RAM disk finished with %Rrc\n", rc));
1779	}
1780	else
1781	return PDMDRV_SET_ERROR(pDrvIns, VERR_INTERNAL_ERROR,
1782	N_("DiskIntegrity: Error querying the media size below"));
1783	}
1784
1785	return rc;
1786	}
1787
1788
1789	/**
1790	* Block driver registration record.
1791	*/
1792	const PDMDRVREG g_DrvDiskIntegrity =
1793	{
1794	/* u32Version */
1795	PDM_DRVREG_VERSION,
1796	/* szName */
1797	"DiskIntegrity",
1798	/* szRCMod */
1799	"",
1800	/* szR0Mod */
1801	"",
1802	/* pszDescription */
1803	"Disk integrity driver.",
1804	/* fFlags */
1805	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1806	/* fClass. */
1807	PDM_DRVREG_CLASS_BLOCK,
1808	/* cMaxInstances */
1809	~0U,
1810	/* cbInstance */
1811	sizeof(DRVDISKINTEGRITY),
1812	/* pfnConstruct */
1813	drvdiskintConstruct,
1814	/* pfnDestruct */
1815	drvdiskintDestruct,
1816	/* pfnRelocate */
1817	NULL,
1818	/* pfnIOCtl */
1819	NULL,
1820	/* pfnPowerOn */
1821	NULL,
1822	/* pfnReset */
1823	NULL,
1824	/* pfnSuspend */
1825	NULL,
1826	/* pfnResume */
1827	NULL,
1828	/* pfnAttach */
1829	NULL,
1830	/* pfnDetach */
1831	NULL,
1832	/* pfnPowerOff */
1833	NULL,
1834	/* pfnSoftReset */
1835	NULL,
1836	/* u32EndVersion */
1837	PDM_DRVREG_VERSION
1838	};
1839

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

source: vbox/trunk/src/VBox/Devices/Storage/DrvDiskIntegrity.cpp@ 64209

Download in other formats: