VirtualBox

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

Last change on this file since 56622 was 56292, checked in by vboxsync, 10 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette