VirtualBox

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

Last change on this file since 98103 was 98103, checked in by vboxsync, 16 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use