VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/PDMBlkCache.cpp@ 87766

Last change on this file since 87766 was 87766, checked in by vboxsync, 4 years ago

VMM/TM,VMM/*: Refactored the TM timer APIs to use 'handles' and take a pVM parameter. Only internal callbacks have been updated with a hTimer parameter, so far. bugref:9943
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 100.0 KB
Line 
1/* $Id: PDMBlkCache.cpp 87766 2021-02-16 14:27:43Z vboxsync $ */
2/** @file
3 * PDM Block Cache.
4 */
5
6/*
7 * Copyright (C) 2006-2020 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/** @page pg_pdm_block_cache PDM Block Cache - The I/O cache
19 * This component implements an I/O cache based on the 2Q cache algorithm.
20 */
21
22
23/*********************************************************************************************************************************
24* Header Files *
25*********************************************************************************************************************************/
26#define LOG_GROUP LOG_GROUP_PDM_BLK_CACHE
27#include "PDMInternal.h"
28#include <iprt/asm.h>
29#include <iprt/mem.h>
30#include <iprt/path.h>
31#include <iprt/string.h>
32#include <iprt/trace.h>
33#include <VBox/log.h>
34#include <VBox/vmm/stam.h>
35#include <VBox/vmm/uvm.h>
36#include <VBox/vmm/vm.h>
37
38#include "PDMBlkCacheInternal.h"
39
40
41/*********************************************************************************************************************************
42* Defined Constants And Macros *
43*********************************************************************************************************************************/
44#ifdef VBOX_STRICT
45# define PDMACFILECACHE_IS_CRITSECT_OWNER(Cache) \
46 do \
47 { \
48 AssertMsg(RTCritSectIsOwner(&Cache->CritSect), \
49 ("Thread does not own critical section\n"));\
50 } while (0)
51
52# define PDMACFILECACHE_EP_IS_SEMRW_WRITE_OWNER(pEpCache) \
53 do \
54 { \
55 AssertMsg(RTSemRWIsWriteOwner(pEpCache->SemRWEntries), \
56 ("Thread is not exclusive owner of the per endpoint RW semaphore\n")); \
57 } while (0)
58
59# define PDMACFILECACHE_EP_IS_SEMRW_READ_OWNER(pEpCache) \
60 do \
61 { \
62 AssertMsg(RTSemRWIsReadOwner(pEpCache->SemRWEntries), \
63 ("Thread is not read owner of the per endpoint RW semaphore\n")); \
64 } while (0)
65
66#else
67# define PDMACFILECACHE_IS_CRITSECT_OWNER(Cache) do { } while (0)
68# define PDMACFILECACHE_EP_IS_SEMRW_WRITE_OWNER(pEpCache) do { } while (0)
69# define PDMACFILECACHE_EP_IS_SEMRW_READ_OWNER(pEpCache) do { } while (0)
70#endif
71
72#define PDM_BLK_CACHE_SAVED_STATE_VERSION 1
73
74/* Enable to enable some tracing in the block cache code for investigating issues. */
75/*#define VBOX_BLKCACHE_TRACING 1*/
76
77
78/*********************************************************************************************************************************
79* Internal Functions *
80*********************************************************************************************************************************/
81
82static PPDMBLKCACHEENTRY pdmBlkCacheEntryAlloc(PPDMBLKCACHE pBlkCache,
83 uint64_t off, size_t cbData, uint8_t *pbBuffer);
84static bool pdmBlkCacheAddDirtyEntry(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEENTRY pEntry);
85
86
87/**
88 * Add message to the VM trace buffer.
89 *
90 * @returns nothing.
91 * @param pBlkCache The block cache.
92 * @param pszFmt The format string.
93 * @param ... Additional parameters for the string formatter.
94 */
95DECLINLINE(void) pdmBlkCacheR3TraceMsgF(PPDMBLKCACHE pBlkCache, const char *pszFmt, ...)
96{
97#if defined(VBOX_BLKCACHE_TRACING)
98 va_list va;
99 va_start(va, pszFmt);
100 RTTraceBufAddMsgV(pBlkCache->pCache->pVM->CTX_SUFF(hTraceBuf), pszFmt, va);
101 va_end(va);
102#else
103 RT_NOREF2(pBlkCache, pszFmt);
104#endif
105}
106
107/**
108 * Decrement the reference counter of the given cache entry.
109 *
110 * @returns nothing.
111 * @param pEntry The entry to release.
112 */
113DECLINLINE(void) pdmBlkCacheEntryRelease(PPDMBLKCACHEENTRY pEntry)
114{
115 AssertMsg(pEntry->cRefs > 0, ("Trying to release a not referenced entry\n"));
116 ASMAtomicDecU32(&pEntry->cRefs);
117}
118
119/**
120 * Increment the reference counter of the given cache entry.
121 *
122 * @returns nothing.
123 * @param pEntry The entry to reference.
124 */
125DECLINLINE(void) pdmBlkCacheEntryRef(PPDMBLKCACHEENTRY pEntry)
126{
127 ASMAtomicIncU32(&pEntry->cRefs);
128}
129
130#ifdef VBOX_STRICT
131static void pdmBlkCacheValidate(PPDMBLKCACHEGLOBAL pCache)
132{
133 /* Amount of cached data should never exceed the maximum amount. */
134 AssertMsg(pCache->cbCached <= pCache->cbMax,
135 ("Current amount of cached data exceeds maximum\n"));
136
137 /* The amount of cached data in the LRU and FRU list should match cbCached */
138 AssertMsg(pCache->LruRecentlyUsedIn.cbCached + pCache->LruFrequentlyUsed.cbCached == pCache->cbCached,
139 ("Amount of cached data doesn't match\n"));
140
141 AssertMsg(pCache->LruRecentlyUsedOut.cbCached <= pCache->cbRecentlyUsedOutMax,
142 ("Paged out list exceeds maximum\n"));
143}
144#endif
145
146DECLINLINE(void) pdmBlkCacheLockEnter(PPDMBLKCACHEGLOBAL pCache)
147{
148 RTCritSectEnter(&pCache->CritSect);
149#ifdef VBOX_STRICT
150 pdmBlkCacheValidate(pCache);
151#endif
152}
153
154DECLINLINE(void) pdmBlkCacheLockLeave(PPDMBLKCACHEGLOBAL pCache)
155{
156#ifdef VBOX_STRICT
157 pdmBlkCacheValidate(pCache);
158#endif
159 RTCritSectLeave(&pCache->CritSect);
160}
161
162DECLINLINE(void) pdmBlkCacheSub(PPDMBLKCACHEGLOBAL pCache, uint32_t cbAmount)
163{
164 PDMACFILECACHE_IS_CRITSECT_OWNER(pCache);
165 pCache->cbCached -= cbAmount;
166}
167
168DECLINLINE(void) pdmBlkCacheAdd(PPDMBLKCACHEGLOBAL pCache, uint32_t cbAmount)
169{
170 PDMACFILECACHE_IS_CRITSECT_OWNER(pCache);
171 pCache->cbCached += cbAmount;
172}
173
174DECLINLINE(void) pdmBlkCacheListAdd(PPDMBLKLRULIST pList, uint32_t cbAmount)
175{
176 pList->cbCached += cbAmount;
177}
178
179DECLINLINE(void) pdmBlkCacheListSub(PPDMBLKLRULIST pList, uint32_t cbAmount)
180{
181 pList->cbCached -= cbAmount;
182}
183
184#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
185/**
186 * Checks consistency of a LRU list.
187 *
188 * @returns nothing
189 * @param pList The LRU list to check.
190 * @param pNotInList Element which is not allowed to occur in the list.
191 */
192static void pdmBlkCacheCheckList(PPDMBLKLRULIST pList, PPDMBLKCACHEENTRY pNotInList)
193{
194 PPDMBLKCACHEENTRY pCurr = pList->pHead;
195
196 /* Check that there are no double entries and no cycles in the list. */
197 while (pCurr)
198 {
199 PPDMBLKCACHEENTRY pNext = pCurr->pNext;
200
201 while (pNext)
202 {
203 AssertMsg(pCurr != pNext,
204 ("Entry %#p is at least two times in list %#p or there is a cycle in the list\n",
205 pCurr, pList));
206 pNext = pNext->pNext;
207 }
208
209 AssertMsg(pCurr != pNotInList, ("Not allowed entry %#p is in list\n", pCurr));
210
211 if (!pCurr->pNext)
212 AssertMsg(pCurr == pList->pTail, ("End of list reached but last element is not list tail\n"));
213
214 pCurr = pCurr->pNext;
215 }
216}
217#endif
218
219/**
220 * Unlinks a cache entry from the LRU list it is assigned to.
221 *
222 * @returns nothing.
223 * @param pEntry The entry to unlink.
224 */
225static void pdmBlkCacheEntryRemoveFromList(PPDMBLKCACHEENTRY pEntry)
226{
227 PPDMBLKLRULIST pList = pEntry->pList;
228 PPDMBLKCACHEENTRY pPrev, pNext;
229
230 LogFlowFunc((": Deleting entry %#p from list %#p\n", pEntry, pList));
231
232 AssertPtr(pList);
233
234#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
235 pdmBlkCacheCheckList(pList, NULL);
236#endif
237
238 pPrev = pEntry->pPrev;
239 pNext = pEntry->pNext;
240
241 AssertMsg(pEntry != pPrev, ("Entry links to itself as previous element\n"));
242 AssertMsg(pEntry != pNext, ("Entry links to itself as next element\n"));
243
244 if (pPrev)
245 pPrev->pNext = pNext;
246 else
247 {
248 pList->pHead = pNext;
249
250 if (pNext)
251 pNext->pPrev = NULL;
252 }
253
254 if (pNext)
255 pNext->pPrev = pPrev;
256 else
257 {
258 pList->pTail = pPrev;
259
260 if (pPrev)
261 pPrev->pNext = NULL;
262 }
263
264 pEntry->pList = NULL;
265 pEntry->pPrev = NULL;
266 pEntry->pNext = NULL;
267 pdmBlkCacheListSub(pList, pEntry->cbData);
268#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
269 pdmBlkCacheCheckList(pList, pEntry);
270#endif
271}
272
273/**
274 * Adds a cache entry to the given LRU list unlinking it from the currently
275 * assigned list if needed.
276 *
277 * @returns nothing.
278 * @param pList List to the add entry to.
279 * @param pEntry Entry to add.
280 */
281static void pdmBlkCacheEntryAddToList(PPDMBLKLRULIST pList, PPDMBLKCACHEENTRY pEntry)
282{
283 LogFlowFunc((": Adding entry %#p to list %#p\n", pEntry, pList));
284#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
285 pdmBlkCacheCheckList(pList, NULL);
286#endif
287
288 /* Remove from old list if needed */
289 if (pEntry->pList)
290 pdmBlkCacheEntryRemoveFromList(pEntry);
291
292 pEntry->pNext = pList->pHead;
293 if (pList->pHead)
294 pList->pHead->pPrev = pEntry;
295 else
296 {
297 Assert(!pList->pTail);
298 pList->pTail = pEntry;
299 }
300
301 pEntry->pPrev = NULL;
302 pList->pHead = pEntry;
303 pdmBlkCacheListAdd(pList, pEntry->cbData);
304 pEntry->pList = pList;
305#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
306 pdmBlkCacheCheckList(pList, NULL);
307#endif
308}
309
310/**
311 * Destroys a LRU list freeing all entries.
312 *
313 * @returns nothing
314 * @param pList Pointer to the LRU list to destroy.
315 *
316 * @note The caller must own the critical section of the cache.
317 */
318static void pdmBlkCacheDestroyList(PPDMBLKLRULIST pList)
319{
320 while (pList->pHead)
321 {
322 PPDMBLKCACHEENTRY pEntry = pList->pHead;
323
324 pList->pHead = pEntry->pNext;
325
326 AssertMsg(!(pEntry->fFlags & (PDMBLKCACHE_ENTRY_IO_IN_PROGRESS | PDMBLKCACHE_ENTRY_IS_DIRTY)),
327 ("Entry is dirty and/or still in progress fFlags=%#x\n", pEntry->fFlags));
328
329 RTMemPageFree(pEntry->pbData, pEntry->cbData);
330 RTMemFree(pEntry);
331 }
332}
333
334/**
335 * Tries to remove the given amount of bytes from a given list in the cache
336 * moving the entries to one of the given ghosts lists
337 *
338 * @returns Amount of data which could be freed.
339 * @param pCache Pointer to the global cache data.
340 * @param cbData The amount of the data to free.
341 * @param pListSrc The source list to evict data from.
342 * @param pGhostListDst Where the ghost list removed entries should be
343 * moved to, NULL if the entry should be freed.
344 * @param fReuseBuffer Flag whether a buffer should be reused if it has
345 * the same size
346 * @param ppbBuffer Where to store the address of the buffer if an
347 * entry with the same size was found and
348 * fReuseBuffer is true.
349 *
350 * @note This function may return fewer bytes than requested because entries
351 * may be marked as non evictable if they are used for I/O at the
352 * moment.
353 */
354static size_t pdmBlkCacheEvictPagesFrom(PPDMBLKCACHEGLOBAL pCache, size_t cbData,
355 PPDMBLKLRULIST pListSrc, PPDMBLKLRULIST pGhostListDst,
356 bool fReuseBuffer, uint8_t **ppbBuffer)
357{
358 size_t cbEvicted = 0;
359
360 PDMACFILECACHE_IS_CRITSECT_OWNER(pCache);
361
362 AssertMsg(cbData > 0, ("Evicting 0 bytes not possible\n"));
363 AssertMsg( !pGhostListDst
364 || (pGhostListDst == &pCache->LruRecentlyUsedOut),
365 ("Destination list must be NULL or the recently used but paged out list\n"));
366
367 if (fReuseBuffer)
368 {
369 AssertPtr(ppbBuffer);
370 *ppbBuffer = NULL;
371 }
372
373 /* Start deleting from the tail. */
374 PPDMBLKCACHEENTRY pEntry = pListSrc->pTail;
375
376 while ((cbEvicted < cbData) && pEntry)
377 {
378 PPDMBLKCACHEENTRY pCurr = pEntry;
379
380 pEntry = pEntry->pPrev;
381
382 /* We can't evict pages which are currently in progress or dirty but not in progress */
383 if ( !(pCurr->fFlags & PDMBLKCACHE_NOT_EVICTABLE)
384 && (ASMAtomicReadU32(&pCurr->cRefs) == 0))
385 {
386 /* Ok eviction candidate. Grab the endpoint semaphore and check again
387 * because somebody else might have raced us. */
388 PPDMBLKCACHE pBlkCache = pCurr->pBlkCache;
389 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
390
391 if (!(pCurr->fFlags & PDMBLKCACHE_NOT_EVICTABLE)
392 && (ASMAtomicReadU32(&pCurr->cRefs) == 0))
393 {
394 LogFlow(("Evicting entry %#p (%u bytes)\n", pCurr, pCurr->cbData));
395
396 if (fReuseBuffer && pCurr->cbData == cbData)
397 {
398 STAM_COUNTER_INC(&pCache->StatBuffersReused);
399 *ppbBuffer = pCurr->pbData;
400 }
401 else if (pCurr->pbData)
402 RTMemPageFree(pCurr->pbData, pCurr->cbData);
403
404 pCurr->pbData = NULL;
405 cbEvicted += pCurr->cbData;
406
407 pdmBlkCacheEntryRemoveFromList(pCurr);
408 pdmBlkCacheSub(pCache, pCurr->cbData);
409
410 if (pGhostListDst)
411 {
412 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
413
414 PPDMBLKCACHEENTRY pGhostEntFree = pGhostListDst->pTail;
415
416 /* We have to remove the last entries from the paged out list. */
417 while ( pGhostListDst->cbCached + pCurr->cbData > pCache->cbRecentlyUsedOutMax
418 && pGhostEntFree)
419 {
420 PPDMBLKCACHEENTRY pFree = pGhostEntFree;
421 PPDMBLKCACHE pBlkCacheFree = pFree->pBlkCache;
422
423 pGhostEntFree = pGhostEntFree->pPrev;
424
425 RTSemRWRequestWrite(pBlkCacheFree->SemRWEntries, RT_INDEFINITE_WAIT);
426
427 if (ASMAtomicReadU32(&pFree->cRefs) == 0)
428 {
429 pdmBlkCacheEntryRemoveFromList(pFree);
430
431 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
432 RTAvlrU64Remove(pBlkCacheFree->pTree, pFree->Core.Key);
433 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
434
435 RTMemFree(pFree);
436 }
437
438 RTSemRWReleaseWrite(pBlkCacheFree->SemRWEntries);
439 }
440
441 if (pGhostListDst->cbCached + pCurr->cbData > pCache->cbRecentlyUsedOutMax)
442 {
443 /* Couldn't remove enough entries. Delete */
444 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
445 RTAvlrU64Remove(pCurr->pBlkCache->pTree, pCurr->Core.Key);
446 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
447
448 RTMemFree(pCurr);
449 }
450 else
451 pdmBlkCacheEntryAddToList(pGhostListDst, pCurr);
452 }
453 else
454 {
455 /* Delete the entry from the AVL tree it is assigned to. */
456 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
457 RTAvlrU64Remove(pCurr->pBlkCache->pTree, pCurr->Core.Key);
458 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
459
460 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
461 RTMemFree(pCurr);
462 }
463 }
464
465 }
466 else
467 LogFlow(("Entry %#p (%u bytes) is still in progress and can't be evicted\n", pCurr, pCurr->cbData));
468 }
469
470 return cbEvicted;
471}
472
473static bool pdmBlkCacheReclaim(PPDMBLKCACHEGLOBAL pCache, size_t cbData, bool fReuseBuffer, uint8_t **ppbBuffer)
474{
475 size_t cbRemoved = 0;
476
477 if ((pCache->cbCached + cbData) < pCache->cbMax)
478 return true;
479 else if ((pCache->LruRecentlyUsedIn.cbCached + cbData) > pCache->cbRecentlyUsedInMax)
480 {
481 /* Try to evict as many bytes as possible from A1in */
482 cbRemoved = pdmBlkCacheEvictPagesFrom(pCache, cbData, &pCache->LruRecentlyUsedIn,
483 &pCache->LruRecentlyUsedOut, fReuseBuffer, ppbBuffer);
484
485 /*
486 * If it was not possible to remove enough entries
487 * try the frequently accessed cache.
488 */
489 if (cbRemoved < cbData)
490 {
491 Assert(!fReuseBuffer || !*ppbBuffer); /* It is not possible that we got a buffer with the correct size but we didn't freed enough data. */
492
493 /*
494 * If we removed something we can't pass the reuse buffer flag anymore because
495 * we don't need to evict that much data
496 */
497 if (!cbRemoved)
498 cbRemoved += pdmBlkCacheEvictPagesFrom(pCache, cbData, &pCache->LruFrequentlyUsed,
499 NULL, fReuseBuffer, ppbBuffer);
500 else
501 cbRemoved += pdmBlkCacheEvictPagesFrom(pCache, cbData - cbRemoved, &pCache->LruFrequentlyUsed,
502 NULL, false, NULL);
503 }
504 }
505 else
506 {
507 /* We have to remove entries from frequently access list. */
508 cbRemoved = pdmBlkCacheEvictPagesFrom(pCache, cbData, &pCache->LruFrequentlyUsed,
509 NULL, fReuseBuffer, ppbBuffer);
510 }
511
512 LogFlowFunc((": removed %u bytes, requested %u\n", cbRemoved, cbData));
513 return (cbRemoved >= cbData);
514}
515
516DECLINLINE(int) pdmBlkCacheEnqueue(PPDMBLKCACHE pBlkCache, uint64_t off, size_t cbXfer, PPDMBLKCACHEIOXFER pIoXfer)
517{
518 int rc = VINF_SUCCESS;
519
520 LogFlowFunc(("%s: Enqueuing hIoXfer=%#p enmXferDir=%d\n",
521 __FUNCTION__, pIoXfer, pIoXfer->enmXferDir));
522
523 ASMAtomicIncU32(&pBlkCache->cIoXfersActive);
524 pdmBlkCacheR3TraceMsgF(pBlkCache, "BlkCache: I/O req %#p (%RTbool , %d) queued (%u now active)",
525 pIoXfer, pIoXfer->fIoCache, pIoXfer->enmXferDir, pBlkCache->cIoXfersActive);
526
527 switch (pBlkCache->enmType)
528 {
529 case PDMBLKCACHETYPE_DEV:
530 {
531 rc = pBlkCache->u.Dev.pfnXferEnqueue(pBlkCache->u.Dev.pDevIns,
532 pIoXfer->enmXferDir,
533 off, cbXfer,
534 &pIoXfer->SgBuf, pIoXfer);
535 break;
536 }
537 case PDMBLKCACHETYPE_DRV:
538 {
539 rc = pBlkCache->u.Drv.pfnXferEnqueue(pBlkCache->u.Drv.pDrvIns,
540 pIoXfer->enmXferDir,
541 off, cbXfer,
542 &pIoXfer->SgBuf, pIoXfer);
543 break;
544 }
545 case PDMBLKCACHETYPE_USB:
546 {
547 rc = pBlkCache->u.Usb.pfnXferEnqueue(pBlkCache->u.Usb.pUsbIns,
548 pIoXfer->enmXferDir,
549 off, cbXfer,
550 &pIoXfer->SgBuf, pIoXfer);
551 break;
552 }
553 case PDMBLKCACHETYPE_INTERNAL:
554 {
555 rc = pBlkCache->u.Int.pfnXferEnqueue(pBlkCache->u.Int.pvUser,
556 pIoXfer->enmXferDir,
557 off, cbXfer,
558 &pIoXfer->SgBuf, pIoXfer);
559 break;
560 }
561 default:
562 AssertMsgFailed(("Unknown block cache type!\n"));
563 }
564
565 if (RT_FAILURE(rc))
566 {
567 pdmBlkCacheR3TraceMsgF(pBlkCache, "BlkCache: Queueing I/O req %#p failed %Rrc", pIoXfer, rc);
568 ASMAtomicDecU32(&pBlkCache->cIoXfersActive);
569 }
570
571 LogFlowFunc(("%s: returns rc=%Rrc\n", __FUNCTION__, rc));
572 return rc;
573}
574
575/**
576 * Initiates a read I/O task for the given entry.
577 *
578 * @returns VBox status code.
579 * @param pEntry The entry to fetch the data to.
580 */
581static int pdmBlkCacheEntryReadFromMedium(PPDMBLKCACHEENTRY pEntry)
582{
583 PPDMBLKCACHE pBlkCache = pEntry->pBlkCache;
584 LogFlowFunc((": Reading data into cache entry %#p\n", pEntry));
585
586 /* Make sure no one evicts the entry while it is accessed. */
587 pEntry->fFlags |= PDMBLKCACHE_ENTRY_IO_IN_PROGRESS;
588
589 PPDMBLKCACHEIOXFER pIoXfer = (PPDMBLKCACHEIOXFER)RTMemAllocZ(sizeof(PDMBLKCACHEIOXFER));
590 if (RT_UNLIKELY(!pIoXfer))
591 return VERR_NO_MEMORY;
592
593 AssertMsg(pEntry->pbData, ("Entry is in ghost state\n"));
594
595 pIoXfer->fIoCache = true;
596 pIoXfer->pEntry = pEntry;
597 pIoXfer->SgSeg.pvSeg = pEntry->pbData;
598 pIoXfer->SgSeg.cbSeg = pEntry->cbData;
599 pIoXfer->enmXferDir = PDMBLKCACHEXFERDIR_READ;
600 RTSgBufInit(&pIoXfer->SgBuf, &pIoXfer->SgSeg, 1);
601
602 return pdmBlkCacheEnqueue(pBlkCache, pEntry->Core.Key, pEntry->cbData, pIoXfer);
603}
604
605/**
606 * Initiates a write I/O task for the given entry.
607 *
608 * @returns nothing.
609 * @param pEntry The entry to read the data from.
610 */
611static int pdmBlkCacheEntryWriteToMedium(PPDMBLKCACHEENTRY pEntry)
612{
613 PPDMBLKCACHE pBlkCache = pEntry->pBlkCache;
614 LogFlowFunc((": Writing data from cache entry %#p\n", pEntry));
615
616 /* Make sure no one evicts the entry while it is accessed. */
617 pEntry->fFlags |= PDMBLKCACHE_ENTRY_IO_IN_PROGRESS;
618
619 PPDMBLKCACHEIOXFER pIoXfer = (PPDMBLKCACHEIOXFER)RTMemAllocZ(sizeof(PDMBLKCACHEIOXFER));
620 if (RT_UNLIKELY(!pIoXfer))
621 return VERR_NO_MEMORY;
622
623 AssertMsg(pEntry->pbData, ("Entry is in ghost state\n"));
624
625 pIoXfer->fIoCache = true;
626 pIoXfer->pEntry = pEntry;
627 pIoXfer->SgSeg.pvSeg = pEntry->pbData;
628 pIoXfer->SgSeg.cbSeg = pEntry->cbData;
629 pIoXfer->enmXferDir = PDMBLKCACHEXFERDIR_WRITE;
630 RTSgBufInit(&pIoXfer->SgBuf, &pIoXfer->SgSeg, 1);
631
632 return pdmBlkCacheEnqueue(pBlkCache, pEntry->Core.Key, pEntry->cbData, pIoXfer);
633}
634
635/**
636 * Passthrough a part of a request directly to the I/O manager handling the
637 * endpoint.
638 *
639 * @returns VBox status code.
640 * @param pBlkCache The endpoint cache.
641 * @param pReq The request.
642 * @param pSgBuf The scatter/gather buffer.
643 * @param offStart Offset to start transfer from.
644 * @param cbData Amount of data to transfer.
645 * @param enmXferDir The transfer type (read/write)
646 */
647static int pdmBlkCacheRequestPassthrough(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEREQ pReq,
648 PRTSGBUF pSgBuf, uint64_t offStart, size_t cbData,
649 PDMBLKCACHEXFERDIR enmXferDir)
650{
651
652 PPDMBLKCACHEIOXFER pIoXfer = (PPDMBLKCACHEIOXFER)RTMemAllocZ(sizeof(PDMBLKCACHEIOXFER));
653 if (RT_UNLIKELY(!pIoXfer))
654 return VERR_NO_MEMORY;
655
656 ASMAtomicIncU32(&pReq->cXfersPending);
657 pIoXfer->fIoCache = false;
658 pIoXfer->pReq = pReq;
659 pIoXfer->enmXferDir = enmXferDir;
660 if (pSgBuf)
661 {
662 RTSgBufClone(&pIoXfer->SgBuf, pSgBuf);
663 RTSgBufAdvance(pSgBuf, cbData);
664 }
665
666 return pdmBlkCacheEnqueue(pBlkCache, offStart, cbData, pIoXfer);
667}
668
669/**
670 * Commit a single dirty entry to the endpoint
671 *
672 * @returns nothing
673 * @param pEntry The entry to commit.
674 */
675static void pdmBlkCacheEntryCommit(PPDMBLKCACHEENTRY pEntry)
676{
677 AssertMsg( (pEntry->fFlags & PDMBLKCACHE_ENTRY_IS_DIRTY)
678 && !(pEntry->fFlags & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS),
679 ("Invalid flags set for entry %#p\n", pEntry));
680
681 pdmBlkCacheEntryWriteToMedium(pEntry);
682}
683
684/**
685 * Commit all dirty entries for a single endpoint.
686 *
687 * @returns nothing.
688 * @param pBlkCache The endpoint cache to commit.
689 */
690static void pdmBlkCacheCommit(PPDMBLKCACHE pBlkCache)
691{
692 uint32_t cbCommitted = 0;
693
694 /* Return if the cache was suspended. */
695 if (pBlkCache->fSuspended)
696 return;
697
698 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
699
700 /* The list is moved to a new header to reduce locking overhead. */
701 RTLISTANCHOR ListDirtyNotCommitted;
702
703 RTSpinlockAcquire(pBlkCache->LockList);
704 RTListMove(&ListDirtyNotCommitted, &pBlkCache->ListDirtyNotCommitted);
705 RTSpinlockRelease(pBlkCache->LockList);
706
707 if (!RTListIsEmpty(&ListDirtyNotCommitted))
708 {
709 PPDMBLKCACHEENTRY pEntry = RTListGetFirst(&ListDirtyNotCommitted, PDMBLKCACHEENTRY, NodeNotCommitted);
710
711 while (!RTListNodeIsLast(&ListDirtyNotCommitted, &pEntry->NodeNotCommitted))
712 {
713 PPDMBLKCACHEENTRY pNext = RTListNodeGetNext(&pEntry->NodeNotCommitted, PDMBLKCACHEENTRY,
714 NodeNotCommitted);
715 pdmBlkCacheEntryCommit(pEntry);
716 cbCommitted += pEntry->cbData;
717 RTListNodeRemove(&pEntry->NodeNotCommitted);
718 pEntry = pNext;
719 }
720
721 /* Commit the last endpoint */
722 Assert(RTListNodeIsLast(&ListDirtyNotCommitted, &pEntry->NodeNotCommitted));
723 pdmBlkCacheEntryCommit(pEntry);
724 cbCommitted += pEntry->cbData;
725 RTListNodeRemove(&pEntry->NodeNotCommitted);
726 AssertMsg(RTListIsEmpty(&ListDirtyNotCommitted),
727 ("Committed all entries but list is not empty\n"));
728 }
729
730 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
731 AssertMsg(pBlkCache->pCache->cbDirty >= cbCommitted,
732 ("Number of committed bytes exceeds number of dirty bytes\n"));
733 uint32_t cbDirtyOld = ASMAtomicSubU32(&pBlkCache->pCache->cbDirty, cbCommitted);
734
735 /* Reset the commit timer if we don't have any dirty bits. */
736 if ( !(cbDirtyOld - cbCommitted)
737 && pBlkCache->pCache->u32CommitTimeoutMs != 0)
738 TMTimerStop(pBlkCache->pCache->pVM, pBlkCache->pCache->hTimerCommit);
739}
740
741/**
742 * Commit all dirty entries in the cache.
743 *
744 * @returns nothing.
745 * @param pCache The global cache instance.
746 */
747static void pdmBlkCacheCommitDirtyEntries(PPDMBLKCACHEGLOBAL pCache)
748{
749 bool fCommitInProgress = ASMAtomicXchgBool(&pCache->fCommitInProgress, true);
750
751 if (!fCommitInProgress)
752 {
753 pdmBlkCacheLockEnter(pCache);
754 Assert(!RTListIsEmpty(&pCache->ListUsers));
755
756 PPDMBLKCACHE pBlkCache = RTListGetFirst(&pCache->ListUsers, PDMBLKCACHE, NodeCacheUser);
757 AssertPtr(pBlkCache);
758
759 while (!RTListNodeIsLast(&pCache->ListUsers, &pBlkCache->NodeCacheUser))
760 {
761 pdmBlkCacheCommit(pBlkCache);
762
763 pBlkCache = RTListNodeGetNext(&pBlkCache->NodeCacheUser, PDMBLKCACHE,
764 NodeCacheUser);
765 }
766
767 /* Commit the last endpoint */
768 Assert(RTListNodeIsLast(&pCache->ListUsers, &pBlkCache->NodeCacheUser));
769 pdmBlkCacheCommit(pBlkCache);
770
771 pdmBlkCacheLockLeave(pCache);
772 ASMAtomicWriteBool(&pCache->fCommitInProgress, false);
773 }
774}
775
776/**
777 * Adds the given entry as a dirty to the cache.
778 *
779 * @returns Flag whether the amount of dirty bytes in the cache exceeds the threshold
780 * @param pBlkCache The endpoint cache the entry belongs to.
781 * @param pEntry The entry to add.
782 */
783static bool pdmBlkCacheAddDirtyEntry(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEENTRY pEntry)
784{
785 bool fDirtyBytesExceeded = false;
786 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
787
788 /* If the commit timer is disabled we commit right away. */
789 if (pCache->u32CommitTimeoutMs == 0)
790 {
791 pEntry->fFlags |= PDMBLKCACHE_ENTRY_IS_DIRTY;
792 pdmBlkCacheEntryCommit(pEntry);
793 }
794 else if (!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IS_DIRTY))
795 {
796 pEntry->fFlags |= PDMBLKCACHE_ENTRY_IS_DIRTY;
797
798 RTSpinlockAcquire(pBlkCache->LockList);
799 RTListAppend(&pBlkCache->ListDirtyNotCommitted, &pEntry->NodeNotCommitted);
800 RTSpinlockRelease(pBlkCache->LockList);
801
802 uint32_t cbDirty = ASMAtomicAddU32(&pCache->cbDirty, pEntry->cbData);
803
804 /* Prevent committing if the VM was suspended. */
805 if (RT_LIKELY(!ASMAtomicReadBool(&pCache->fIoErrorVmSuspended)))
806 fDirtyBytesExceeded = (cbDirty + pEntry->cbData >= pCache->cbCommitDirtyThreshold);
807 else if (!cbDirty && pCache->u32CommitTimeoutMs > 0)
808 {
809 /* Arm the commit timer. */
810 TMTimerSetMillies(pCache->pVM, pCache->hTimerCommit, pCache->u32CommitTimeoutMs);
811 }
812 }
813
814 return fDirtyBytesExceeded;
815}
816
817static PPDMBLKCACHE pdmR3BlkCacheFindById(PPDMBLKCACHEGLOBAL pBlkCacheGlobal, const char *pcszId)
818{
819 bool fFound = false;
820
821 PPDMBLKCACHE pBlkCache;
822 RTListForEach(&pBlkCacheGlobal->ListUsers, pBlkCache, PDMBLKCACHE, NodeCacheUser)
823 {
824 if (!RTStrCmp(pBlkCache->pszId, pcszId))
825 {
826 fFound = true;
827 break;
828 }
829 }
830
831 return fFound ? pBlkCache : NULL;
832}
833
834/**
835 * @callback_method_impl{FNTMTIMERINT, Commit timer callback.}
836 */
837static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
838{
839 PPDMBLKCACHEGLOBAL pCache = (PPDMBLKCACHEGLOBAL)pvUser;
840 RT_NOREF(pVM, hTimer);
841
842 LogFlowFunc(("Commit interval expired, commiting dirty entries\n"));
843
844 if ( ASMAtomicReadU32(&pCache->cbDirty) > 0
845 && !ASMAtomicReadBool(&pCache->fIoErrorVmSuspended))
846 pdmBlkCacheCommitDirtyEntries(pCache);
847
848 LogFlowFunc(("Entries committed, going to sleep\n"));
849}
850
851static DECLCALLBACK(int) pdmR3BlkCacheSaveExec(PVM pVM, PSSMHANDLE pSSM)
852{
853 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
854
855 AssertPtr(pBlkCacheGlobal);
856
857 pdmBlkCacheLockEnter(pBlkCacheGlobal);
858
859 SSMR3PutU32(pSSM, pBlkCacheGlobal->cRefs);
860
861 /* Go through the list and save all dirty entries. */
862 PPDMBLKCACHE pBlkCache;
863 RTListForEach(&pBlkCacheGlobal->ListUsers, pBlkCache, PDMBLKCACHE, NodeCacheUser)
864 {
865 uint32_t cEntries = 0;
866 PPDMBLKCACHEENTRY pEntry;
867
868 RTSemRWRequestRead(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
869 SSMR3PutU32(pSSM, (uint32_t)strlen(pBlkCache->pszId));
870 SSMR3PutStrZ(pSSM, pBlkCache->pszId);
871
872 /* Count the number of entries to safe. */
873 RTListForEach(&pBlkCache->ListDirtyNotCommitted, pEntry, PDMBLKCACHEENTRY, NodeNotCommitted)
874 {
875 cEntries++;
876 }
877
878 SSMR3PutU32(pSSM, cEntries);
879
880 /* Walk the list of all dirty entries and save them. */
881 RTListForEach(&pBlkCache->ListDirtyNotCommitted, pEntry, PDMBLKCACHEENTRY, NodeNotCommitted)
882 {
883 /* A few sanity checks. */
884 AssertMsg(!pEntry->cRefs, ("The entry is still referenced\n"));
885 AssertMsg(pEntry->fFlags & PDMBLKCACHE_ENTRY_IS_DIRTY, ("Entry is not dirty\n"));
886 AssertMsg(!(pEntry->fFlags & ~PDMBLKCACHE_ENTRY_IS_DIRTY), ("Invalid flags set\n"));
887 AssertMsg(!pEntry->pWaitingHead && !pEntry->pWaitingTail, ("There are waiting requests\n"));
888 AssertMsg( pEntry->pList == &pBlkCacheGlobal->LruRecentlyUsedIn
889 || pEntry->pList == &pBlkCacheGlobal->LruFrequentlyUsed,
890 ("Invalid list\n"));
891 AssertMsg(pEntry->cbData == pEntry->Core.KeyLast - pEntry->Core.Key + 1,
892 ("Size and range do not match\n"));
893
894 /* Save */
895 SSMR3PutU64(pSSM, pEntry->Core.Key);
896 SSMR3PutU32(pSSM, pEntry->cbData);
897 SSMR3PutMem(pSSM, pEntry->pbData, pEntry->cbData);
898 }
899
900 RTSemRWReleaseRead(pBlkCache->SemRWEntries);
901 }
902
903 pdmBlkCacheLockLeave(pBlkCacheGlobal);
904
905 /* Terminator */
906 return SSMR3PutU32(pSSM, UINT32_MAX);
907}
908
909static DECLCALLBACK(int) pdmR3BlkCacheLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
910{
911 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
912 uint32_t cRefs;
913
914 NOREF(uPass);
915 AssertPtr(pBlkCacheGlobal);
916
917 pdmBlkCacheLockEnter(pBlkCacheGlobal);
918
919 if (uVersion != PDM_BLK_CACHE_SAVED_STATE_VERSION)
920 return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
921
922 SSMR3GetU32(pSSM, &cRefs);
923
924 /*
925 * Fewer users in the saved state than in the current VM are allowed
926 * because that means that there are only new ones which don't have any saved state
927 * which can get lost.
928 * More saved state entries than registered cache users are only allowed if the
929 * missing users don't have any data saved in the cache.
930 */
931 int rc = VINF_SUCCESS;
932 char *pszId = NULL;
933
934 while ( cRefs > 0
935 && RT_SUCCESS(rc))
936 {
937 PPDMBLKCACHE pBlkCache = NULL;
938 uint32_t cbId = 0;
939
940 SSMR3GetU32(pSSM, &cbId);
941 Assert(cbId > 0);
942
943 cbId++; /* Include terminator */
944 pszId = (char *)RTMemAllocZ(cbId * sizeof(char));
945 if (!pszId)
946 {
947 rc = VERR_NO_MEMORY;
948 break;
949 }
950
951 rc = SSMR3GetStrZ(pSSM, pszId, cbId);
952 AssertRC(rc);
953
954 /* Search for the block cache with the provided id. */
955 pBlkCache = pdmR3BlkCacheFindById(pBlkCacheGlobal, pszId);
956
957 /* Get the entries */
958 uint32_t cEntries;
959 SSMR3GetU32(pSSM, &cEntries);
960
961 if (!pBlkCache && (cEntries > 0))
962 {
963 rc = SSMR3SetCfgError(pSSM, RT_SRC_POS,
964 N_("The VM is missing a block device and there is data in the cache. Please make sure the source and target VMs have compatible storage configurations"));
965 break;
966 }
967
968 RTMemFree(pszId);
969 pszId = NULL;
970
971 while (cEntries > 0)
972 {
973 PPDMBLKCACHEENTRY pEntry;
974 uint64_t off;
975 uint32_t cbEntry;
976
977 SSMR3GetU64(pSSM, &off);
978 SSMR3GetU32(pSSM, &cbEntry);
979
980 pEntry = pdmBlkCacheEntryAlloc(pBlkCache, off, cbEntry, NULL);
981 if (!pEntry)
982 {
983 rc = VERR_NO_MEMORY;
984 break;
985 }
986
987 rc = SSMR3GetMem(pSSM, pEntry->pbData, cbEntry);
988 if (RT_FAILURE(rc))
989 {
990 RTMemFree(pEntry->pbData);
991 RTMemFree(pEntry);
992 break;
993 }
994
995 /* Insert into the tree. */
996 bool fInserted = RTAvlrU64Insert(pBlkCache->pTree, &pEntry->Core);
997 Assert(fInserted); NOREF(fInserted);
998
999 /* Add to the dirty list. */
1000 pdmBlkCacheAddDirtyEntry(pBlkCache, pEntry);
1001 pdmBlkCacheEntryAddToList(&pBlkCacheGlobal->LruRecentlyUsedIn, pEntry);
1002 pdmBlkCacheAdd(pBlkCacheGlobal, cbEntry);
1003 pdmBlkCacheEntryRelease(pEntry);
1004 cEntries--;
1005 }
1006
1007 cRefs--;
1008 }
1009
1010 if (pszId)
1011 RTMemFree(pszId);
1012
1013 if (cRefs && RT_SUCCESS(rc))
1014 rc = SSMR3SetCfgError(pSSM, RT_SRC_POS,
1015 N_("Unexpected error while restoring state. Please make sure the source and target VMs have compatible storage configurations"));
1016
1017 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1018
1019 if (RT_SUCCESS(rc))
1020 {
1021 uint32_t u32 = 0;
1022 rc = SSMR3GetU32(pSSM, &u32);
1023 if (RT_SUCCESS(rc))
1024 AssertMsgReturn(u32 == UINT32_MAX, ("%#x\n", u32), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
1025 }
1026
1027 return rc;
1028}
1029
1030int pdmR3BlkCacheInit(PVM pVM)
1031{
1032 int rc = VINF_SUCCESS;
1033 PUVM pUVM = pVM->pUVM;
1034 PPDMBLKCACHEGLOBAL pBlkCacheGlobal;
1035
1036 LogFlowFunc((": pVM=%p\n", pVM));
1037
1038 VM_ASSERT_EMT(pVM);
1039
1040 PCFGMNODE pCfgRoot = CFGMR3GetRoot(pVM);
1041 PCFGMNODE pCfgBlkCache = CFGMR3GetChild(CFGMR3GetChild(pCfgRoot, "PDM"), "BlkCache");
1042
1043 pBlkCacheGlobal = (PPDMBLKCACHEGLOBAL)RTMemAllocZ(sizeof(PDMBLKCACHEGLOBAL));
1044 if (!pBlkCacheGlobal)
1045 return VERR_NO_MEMORY;
1046
1047 RTListInit(&pBlkCacheGlobal->ListUsers);
1048 pBlkCacheGlobal->pVM = pVM;
1049 pBlkCacheGlobal->cRefs = 0;
1050 pBlkCacheGlobal->cbCached = 0;
1051 pBlkCacheGlobal->fCommitInProgress = false;
1052
1053 /* Initialize members */
1054 pBlkCacheGlobal->LruRecentlyUsedIn.pHead = NULL;
1055 pBlkCacheGlobal->LruRecentlyUsedIn.pTail = NULL;
1056 pBlkCacheGlobal->LruRecentlyUsedIn.cbCached = 0;
1057
1058 pBlkCacheGlobal->LruRecentlyUsedOut.pHead = NULL;
1059 pBlkCacheGlobal->LruRecentlyUsedOut.pTail = NULL;
1060 pBlkCacheGlobal->LruRecentlyUsedOut.cbCached = 0;
1061
1062 pBlkCacheGlobal->LruFrequentlyUsed.pHead = NULL;
1063 pBlkCacheGlobal->LruFrequentlyUsed.pTail = NULL;
1064 pBlkCacheGlobal->LruFrequentlyUsed.cbCached = 0;
1065
1066 do
1067 {
1068 rc = CFGMR3QueryU32Def(pCfgBlkCache, "CacheSize", &pBlkCacheGlobal->cbMax, 5 * _1M);
1069 AssertLogRelRCBreak(rc);
1070 LogFlowFunc(("Maximum number of bytes cached %u\n", pBlkCacheGlobal->cbMax));
1071
1072 pBlkCacheGlobal->cbRecentlyUsedInMax = (pBlkCacheGlobal->cbMax / 100) * 25; /* 25% of the buffer size */
1073 pBlkCacheGlobal->cbRecentlyUsedOutMax = (pBlkCacheGlobal->cbMax / 100) * 50; /* 50% of the buffer size */
1074 LogFlowFunc(("cbRecentlyUsedInMax=%u cbRecentlyUsedOutMax=%u\n",
1075 pBlkCacheGlobal->cbRecentlyUsedInMax, pBlkCacheGlobal->cbRecentlyUsedOutMax));
1076
1077 /** @todo r=aeichner: Experiment to find optimal default values */
1078 rc = CFGMR3QueryU32Def(pCfgBlkCache, "CacheCommitIntervalMs", &pBlkCacheGlobal->u32CommitTimeoutMs, 10000 /* 10sec */);
1079 AssertLogRelRCBreak(rc);
1080 rc = CFGMR3QueryU32Def(pCfgBlkCache, "CacheCommitThreshold", &pBlkCacheGlobal->cbCommitDirtyThreshold, pBlkCacheGlobal->cbMax / 2);
1081 AssertLogRelRCBreak(rc);
1082 } while (0);
1083
1084 if (RT_SUCCESS(rc))
1085 {
1086 STAMR3Register(pVM, &pBlkCacheGlobal->cbMax,
1087 STAMTYPE_U32, STAMVISIBILITY_ALWAYS,
1088 "/PDM/BlkCache/cbMax",
1089 STAMUNIT_BYTES,
1090 "Maximum cache size");
1091 STAMR3Register(pVM, &pBlkCacheGlobal->cbCached,
1092 STAMTYPE_U32, STAMVISIBILITY_ALWAYS,
1093 "/PDM/BlkCache/cbCached",
1094 STAMUNIT_BYTES,
1095 "Currently used cache");
1096 STAMR3Register(pVM, &pBlkCacheGlobal->LruRecentlyUsedIn.cbCached,
1097 STAMTYPE_U32, STAMVISIBILITY_ALWAYS,
1098 "/PDM/BlkCache/cbCachedMruIn",
1099 STAMUNIT_BYTES,
1100 "Number of bytes cached in MRU list");
1101 STAMR3Register(pVM, &pBlkCacheGlobal->LruRecentlyUsedOut.cbCached,
1102 STAMTYPE_U32, STAMVISIBILITY_ALWAYS,
1103 "/PDM/BlkCache/cbCachedMruOut",
1104 STAMUNIT_BYTES,
1105 "Number of bytes cached in FRU list");
1106 STAMR3Register(pVM, &pBlkCacheGlobal->LruFrequentlyUsed.cbCached,
1107 STAMTYPE_U32, STAMVISIBILITY_ALWAYS,
1108 "/PDM/BlkCache/cbCachedFru",
1109 STAMUNIT_BYTES,
1110 "Number of bytes cached in FRU ghost list");
1111
1112#ifdef VBOX_WITH_STATISTICS
1113 STAMR3Register(pVM, &pBlkCacheGlobal->cHits,
1114 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1115 "/PDM/BlkCache/CacheHits",
1116 STAMUNIT_COUNT, "Number of hits in the cache");
1117 STAMR3Register(pVM, &pBlkCacheGlobal->cPartialHits,
1118 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1119 "/PDM/BlkCache/CachePartialHits",
1120 STAMUNIT_COUNT, "Number of partial hits in the cache");
1121 STAMR3Register(pVM, &pBlkCacheGlobal->cMisses,
1122 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1123 "/PDM/BlkCache/CacheMisses",
1124 STAMUNIT_COUNT, "Number of misses when accessing the cache");
1125 STAMR3Register(pVM, &pBlkCacheGlobal->StatRead,
1126 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1127 "/PDM/BlkCache/CacheRead",
1128 STAMUNIT_BYTES, "Number of bytes read from the cache");
1129 STAMR3Register(pVM, &pBlkCacheGlobal->StatWritten,
1130 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1131 "/PDM/BlkCache/CacheWritten",
1132 STAMUNIT_BYTES, "Number of bytes written to the cache");
1133 STAMR3Register(pVM, &pBlkCacheGlobal->StatTreeGet,
1134 STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
1135 "/PDM/BlkCache/CacheTreeGet",
1136 STAMUNIT_TICKS_PER_CALL, "Time taken to access an entry in the tree");
1137 STAMR3Register(pVM, &pBlkCacheGlobal->StatTreeInsert,
1138 STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
1139 "/PDM/BlkCache/CacheTreeInsert",
1140 STAMUNIT_TICKS_PER_CALL, "Time taken to insert an entry in the tree");
1141 STAMR3Register(pVM, &pBlkCacheGlobal->StatTreeRemove,
1142 STAMTYPE_PROFILE_ADV, STAMVISIBILITY_ALWAYS,
1143 "/PDM/BlkCache/CacheTreeRemove",
1144 STAMUNIT_TICKS_PER_CALL, "Time taken to remove an entry an the tree");
1145 STAMR3Register(pVM, &pBlkCacheGlobal->StatBuffersReused,
1146 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1147 "/PDM/BlkCache/CacheBuffersReused",
1148 STAMUNIT_COUNT, "Number of times a buffer could be reused");
1149#endif
1150
1151 /* Initialize the critical section */
1152 rc = RTCritSectInit(&pBlkCacheGlobal->CritSect);
1153 }
1154
1155 if (RT_SUCCESS(rc))
1156 {
1157 /* Create the commit timer */
1158 if (pBlkCacheGlobal->u32CommitTimeoutMs > 0)
1159 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmBlkCacheCommitTimerCallback, pBlkCacheGlobal,
1160 TMTIMER_FLAGS_NO_RING0, "BlkCache-Commit", &pBlkCacheGlobal->hTimerCommit);
1161
1162 if (RT_SUCCESS(rc))
1163 {
1164 /* Register saved state handler. */
1165 rc = SSMR3RegisterInternal(pVM, "pdmblkcache", 0, PDM_BLK_CACHE_SAVED_STATE_VERSION, pBlkCacheGlobal->cbMax,
1166 NULL, NULL, NULL,
1167 NULL, pdmR3BlkCacheSaveExec, NULL,
1168 NULL, pdmR3BlkCacheLoadExec, NULL);
1169 if (RT_SUCCESS(rc))
1170 {
1171 LogRel(("BlkCache: Cache successfully initialized. Cache size is %u bytes\n", pBlkCacheGlobal->cbMax));
1172 LogRel(("BlkCache: Cache commit interval is %u ms\n", pBlkCacheGlobal->u32CommitTimeoutMs));
1173 LogRel(("BlkCache: Cache commit threshold is %u bytes\n", pBlkCacheGlobal->cbCommitDirtyThreshold));
1174 pUVM->pdm.s.pBlkCacheGlobal = pBlkCacheGlobal;
1175 return VINF_SUCCESS;
1176 }
1177 }
1178
1179 RTCritSectDelete(&pBlkCacheGlobal->CritSect);
1180 }
1181
1182 if (pBlkCacheGlobal)
1183 RTMemFree(pBlkCacheGlobal);
1184
1185 LogFlowFunc((": returns rc=%Rrc\n", rc));
1186 return rc;
1187}
1188
1189void pdmR3BlkCacheTerm(PVM pVM)
1190{
1191 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1192
1193 if (pBlkCacheGlobal)
1194 {
1195 /* Make sure no one else uses the cache now */
1196 pdmBlkCacheLockEnter(pBlkCacheGlobal);
1197
1198 /* Cleanup deleting all cache entries waiting for in progress entries to finish. */
1199 pdmBlkCacheDestroyList(&pBlkCacheGlobal->LruRecentlyUsedIn);
1200 pdmBlkCacheDestroyList(&pBlkCacheGlobal->LruRecentlyUsedOut);
1201 pdmBlkCacheDestroyList(&pBlkCacheGlobal->LruFrequentlyUsed);
1202
1203 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1204
1205 RTCritSectDelete(&pBlkCacheGlobal->CritSect);
1206 RTMemFree(pBlkCacheGlobal);
1207 pVM->pUVM->pdm.s.pBlkCacheGlobal = NULL;
1208 }
1209}
1210
1211int pdmR3BlkCacheResume(PVM pVM)
1212{
1213 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1214
1215 LogFlowFunc(("pVM=%#p\n", pVM));
1216
1217 if ( pBlkCacheGlobal
1218 && ASMAtomicXchgBool(&pBlkCacheGlobal->fIoErrorVmSuspended, false))
1219 {
1220 /* The VM was suspended because of an I/O error, commit all dirty entries. */
1221 pdmBlkCacheCommitDirtyEntries(pBlkCacheGlobal);
1222 }
1223
1224 return VINF_SUCCESS;
1225}
1226
1227static int pdmR3BlkCacheRetain(PVM pVM, PPPDMBLKCACHE ppBlkCache, const char *pcszId)
1228{
1229 int rc = VINF_SUCCESS;
1230 PPDMBLKCACHE pBlkCache = NULL;
1231 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1232
1233 if (!pBlkCacheGlobal)
1234 return VERR_NOT_SUPPORTED;
1235
1236 /*
1237 * Check that no other user cache has the same id first,
1238 * Unique id's are necessary in case the state is saved.
1239 */
1240 pdmBlkCacheLockEnter(pBlkCacheGlobal);
1241
1242 pBlkCache = pdmR3BlkCacheFindById(pBlkCacheGlobal, pcszId);
1243
1244 if (!pBlkCache)
1245 {
1246 pBlkCache = (PPDMBLKCACHE)RTMemAllocZ(sizeof(PDMBLKCACHE));
1247
1248 if (pBlkCache)
1249 pBlkCache->pszId = RTStrDup(pcszId);
1250
1251 if ( pBlkCache
1252 && pBlkCache->pszId)
1253 {
1254 pBlkCache->fSuspended = false;
1255 pBlkCache->cIoXfersActive = 0;
1256 pBlkCache->pCache = pBlkCacheGlobal;
1257 RTListInit(&pBlkCache->ListDirtyNotCommitted);
1258
1259 rc = RTSpinlockCreate(&pBlkCache->LockList, RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, "pdmR3BlkCacheRetain");
1260 if (RT_SUCCESS(rc))
1261 {
1262 rc = RTSemRWCreate(&pBlkCache->SemRWEntries);
1263 if (RT_SUCCESS(rc))
1264 {
1265 pBlkCache->pTree = (PAVLRU64TREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
1266 if (pBlkCache->pTree)
1267 {
1268#ifdef VBOX_WITH_STATISTICS
1269 STAMR3RegisterF(pBlkCacheGlobal->pVM, &pBlkCache->StatWriteDeferred,
1270 STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS,
1271 STAMUNIT_COUNT, "Number of deferred writes",
1272 "/PDM/BlkCache/%s/Cache/DeferredWrites", pBlkCache->pszId);
1273#endif
1274
1275 /* Add to the list of users. */
1276 pBlkCacheGlobal->cRefs++;
1277 RTListAppend(&pBlkCacheGlobal->ListUsers, &pBlkCache->NodeCacheUser);
1278 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1279
1280 *ppBlkCache = pBlkCache;
1281 LogFlowFunc(("returns success\n"));
1282 return VINF_SUCCESS;
1283 }
1284
1285 rc = VERR_NO_MEMORY;
1286 RTSemRWDestroy(pBlkCache->SemRWEntries);
1287 }
1288
1289 RTSpinlockDestroy(pBlkCache->LockList);
1290 }
1291
1292 RTStrFree(pBlkCache->pszId);
1293 }
1294 else
1295 rc = VERR_NO_MEMORY;
1296
1297 if (pBlkCache)
1298 RTMemFree(pBlkCache);
1299 }
1300 else
1301 rc = VERR_ALREADY_EXISTS;
1302
1303 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1304
1305 LogFlowFunc(("Leave rc=%Rrc\n", rc));
1306 return rc;
1307}
1308
1309VMMR3DECL(int) PDMR3BlkCacheRetainDriver(PVM pVM, PPDMDRVINS pDrvIns, PPPDMBLKCACHE ppBlkCache,
1310 PFNPDMBLKCACHEXFERCOMPLETEDRV pfnXferComplete,
1311 PFNPDMBLKCACHEXFERENQUEUEDRV pfnXferEnqueue,
1312 PFNPDMBLKCACHEXFERENQUEUEDISCARDDRV pfnXferEnqueueDiscard,
1313 const char *pcszId)
1314{
1315 int rc = VINF_SUCCESS;
1316 PPDMBLKCACHE pBlkCache;
1317
1318 rc = pdmR3BlkCacheRetain(pVM, &pBlkCache, pcszId);
1319 if (RT_SUCCESS(rc))
1320 {
1321 pBlkCache->enmType = PDMBLKCACHETYPE_DRV;
1322 pBlkCache->u.Drv.pfnXferComplete = pfnXferComplete;
1323 pBlkCache->u.Drv.pfnXferEnqueue = pfnXferEnqueue;
1324 pBlkCache->u.Drv.pfnXferEnqueueDiscard = pfnXferEnqueueDiscard;
1325 pBlkCache->u.Drv.pDrvIns = pDrvIns;
1326 *ppBlkCache = pBlkCache;
1327 }
1328
1329 LogFlowFunc(("Leave rc=%Rrc\n", rc));
1330 return rc;
1331}
1332
1333VMMR3DECL(int) PDMR3BlkCacheRetainDevice(PVM pVM, PPDMDEVINS pDevIns, PPPDMBLKCACHE ppBlkCache,
1334 PFNPDMBLKCACHEXFERCOMPLETEDEV pfnXferComplete,
1335 PFNPDMBLKCACHEXFERENQUEUEDEV pfnXferEnqueue,
1336 PFNPDMBLKCACHEXFERENQUEUEDISCARDDEV pfnXferEnqueueDiscard,
1337 const char *pcszId)
1338{
1339 int rc = VINF_SUCCESS;
1340 PPDMBLKCACHE pBlkCache;
1341
1342 rc = pdmR3BlkCacheRetain(pVM, &pBlkCache, pcszId);
1343 if (RT_SUCCESS(rc))
1344 {
1345 pBlkCache->enmType = PDMBLKCACHETYPE_DEV;
1346 pBlkCache->u.Dev.pfnXferComplete = pfnXferComplete;
1347 pBlkCache->u.Dev.pfnXferEnqueue = pfnXferEnqueue;
1348 pBlkCache->u.Dev.pfnXferEnqueueDiscard = pfnXferEnqueueDiscard;
1349 pBlkCache->u.Dev.pDevIns = pDevIns;
1350 *ppBlkCache = pBlkCache;
1351 }
1352
1353 LogFlowFunc(("Leave rc=%Rrc\n", rc));
1354 return rc;
1355
1356}
1357
1358VMMR3DECL(int) PDMR3BlkCacheRetainUsb(PVM pVM, PPDMUSBINS pUsbIns, PPPDMBLKCACHE ppBlkCache,
1359 PFNPDMBLKCACHEXFERCOMPLETEUSB pfnXferComplete,
1360 PFNPDMBLKCACHEXFERENQUEUEUSB pfnXferEnqueue,
1361 PFNPDMBLKCACHEXFERENQUEUEDISCARDUSB pfnXferEnqueueDiscard,
1362 const char *pcszId)
1363{
1364 int rc = VINF_SUCCESS;
1365 PPDMBLKCACHE pBlkCache;
1366
1367 rc = pdmR3BlkCacheRetain(pVM, &pBlkCache, pcszId);
1368 if (RT_SUCCESS(rc))
1369 {
1370 pBlkCache->enmType = PDMBLKCACHETYPE_USB;
1371 pBlkCache->u.Usb.pfnXferComplete = pfnXferComplete;
1372 pBlkCache->u.Usb.pfnXferEnqueue = pfnXferEnqueue;
1373 pBlkCache->u.Usb.pfnXferEnqueueDiscard = pfnXferEnqueueDiscard;
1374 pBlkCache->u.Usb.pUsbIns = pUsbIns;
1375 *ppBlkCache = pBlkCache;
1376 }
1377
1378 LogFlowFunc(("Leave rc=%Rrc\n", rc));
1379 return rc;
1380
1381}
1382
1383VMMR3DECL(int) PDMR3BlkCacheRetainInt(PVM pVM, void *pvUser, PPPDMBLKCACHE ppBlkCache,
1384 PFNPDMBLKCACHEXFERCOMPLETEINT pfnXferComplete,
1385 PFNPDMBLKCACHEXFERENQUEUEINT pfnXferEnqueue,
1386 PFNPDMBLKCACHEXFERENQUEUEDISCARDINT pfnXferEnqueueDiscard,
1387 const char *pcszId)
1388{
1389 int rc = VINF_SUCCESS;
1390 PPDMBLKCACHE pBlkCache;
1391
1392 rc = pdmR3BlkCacheRetain(pVM, &pBlkCache, pcszId);
1393 if (RT_SUCCESS(rc))
1394 {
1395 pBlkCache->enmType = PDMBLKCACHETYPE_INTERNAL;
1396 pBlkCache->u.Int.pfnXferComplete = pfnXferComplete;
1397 pBlkCache->u.Int.pfnXferEnqueue = pfnXferEnqueue;
1398 pBlkCache->u.Int.pfnXferEnqueueDiscard = pfnXferEnqueueDiscard;
1399 pBlkCache->u.Int.pvUser = pvUser;
1400 *ppBlkCache = pBlkCache;
1401 }
1402
1403 LogFlowFunc(("Leave rc=%Rrc\n", rc));
1404 return rc;
1405
1406}
1407
1408/**
1409 * Callback for the AVL destroy routine. Frees a cache entry for this endpoint.
1410 *
1411 * @returns IPRT status code.
1412 * @param pNode The node to destroy.
1413 * @param pvUser Opaque user data.
1414 */
1415static DECLCALLBACK(int) pdmBlkCacheEntryDestroy(PAVLRU64NODECORE pNode, void *pvUser)
1416{
1417 PPDMBLKCACHEENTRY pEntry = (PPDMBLKCACHEENTRY)pNode;
1418 PPDMBLKCACHEGLOBAL pCache = (PPDMBLKCACHEGLOBAL)pvUser;
1419 PPDMBLKCACHE pBlkCache = pEntry->pBlkCache;
1420
1421 while (ASMAtomicReadU32(&pEntry->fFlags) & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS)
1422 {
1423 /* Leave the locks to let the I/O thread make progress but reference the entry to prevent eviction. */
1424 pdmBlkCacheEntryRef(pEntry);
1425 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
1426 pdmBlkCacheLockLeave(pCache);
1427
1428 RTThreadSleep(250);
1429
1430 /* Re-enter all locks */
1431 pdmBlkCacheLockEnter(pCache);
1432 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1433 pdmBlkCacheEntryRelease(pEntry);
1434 }
1435
1436 AssertMsg(!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS),
1437 ("Entry is dirty and/or still in progress fFlags=%#x\n", pEntry->fFlags));
1438
1439 bool fUpdateCache = pEntry->pList == &pCache->LruFrequentlyUsed
1440 || pEntry->pList == &pCache->LruRecentlyUsedIn;
1441
1442 pdmBlkCacheEntryRemoveFromList(pEntry);
1443
1444 if (fUpdateCache)
1445 pdmBlkCacheSub(pCache, pEntry->cbData);
1446
1447 RTMemPageFree(pEntry->pbData, pEntry->cbData);
1448 RTMemFree(pEntry);
1449
1450 return VINF_SUCCESS;
1451}
1452
1453VMMR3DECL(void) PDMR3BlkCacheRelease(PPDMBLKCACHE pBlkCache)
1454{
1455 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
1456
1457 /*
1458 * Commit all dirty entries now (they are waited on for completion during the
1459 * destruction of the AVL tree below).
1460 * The exception is if the VM was paused because of an I/O error before.
1461 */
1462 if (!ASMAtomicReadBool(&pCache->fIoErrorVmSuspended))
1463 pdmBlkCacheCommit(pBlkCache);
1464
1465 /* Make sure nobody is accessing the cache while we delete the tree. */
1466 pdmBlkCacheLockEnter(pCache);
1467 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1468 RTAvlrU64Destroy(pBlkCache->pTree, pdmBlkCacheEntryDestroy, pCache);
1469 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
1470
1471 RTSpinlockDestroy(pBlkCache->LockList);
1472
1473 pCache->cRefs--;
1474 RTListNodeRemove(&pBlkCache->NodeCacheUser);
1475
1476 pdmBlkCacheLockLeave(pCache);
1477
1478 RTMemFree(pBlkCache->pTree);
1479 pBlkCache->pTree = NULL;
1480 RTSemRWDestroy(pBlkCache->SemRWEntries);
1481
1482#ifdef VBOX_WITH_STATISTICS
1483 STAMR3DeregisterF(pCache->pVM->pUVM, "/PDM/BlkCache/%s/Cache/DeferredWrites", pBlkCache->pszId);
1484#endif
1485
1486 RTStrFree(pBlkCache->pszId);
1487 RTMemFree(pBlkCache);
1488}
1489
1490VMMR3DECL(void) PDMR3BlkCacheReleaseDevice(PVM pVM, PPDMDEVINS pDevIns)
1491{
1492 LogFlow(("%s: pDevIns=%p\n", __FUNCTION__, pDevIns));
1493
1494 /*
1495 * Validate input.
1496 */
1497 if (!pDevIns)
1498 return;
1499 VM_ASSERT_EMT(pVM);
1500
1501 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1502 PPDMBLKCACHE pBlkCache, pBlkCacheNext;
1503
1504 /* Return silently if not supported. */
1505 if (!pBlkCacheGlobal)
1506 return;
1507
1508 pdmBlkCacheLockEnter(pBlkCacheGlobal);
1509
1510 RTListForEachSafe(&pBlkCacheGlobal->ListUsers, pBlkCache, pBlkCacheNext, PDMBLKCACHE, NodeCacheUser)
1511 {
1512 if ( pBlkCache->enmType == PDMBLKCACHETYPE_DEV
1513 && pBlkCache->u.Dev.pDevIns == pDevIns)
1514 PDMR3BlkCacheRelease(pBlkCache);
1515 }
1516
1517 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1518}
1519
1520VMMR3DECL(void) PDMR3BlkCacheReleaseDriver(PVM pVM, PPDMDRVINS pDrvIns)
1521{
1522 LogFlow(("%s: pDrvIns=%p\n", __FUNCTION__, pDrvIns));
1523
1524 /*
1525 * Validate input.
1526 */
1527 if (!pDrvIns)
1528 return;
1529 VM_ASSERT_EMT(pVM);
1530
1531 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1532 PPDMBLKCACHE pBlkCache, pBlkCacheNext;
1533
1534 /* Return silently if not supported. */
1535 if (!pBlkCacheGlobal)
1536 return;
1537
1538 pdmBlkCacheLockEnter(pBlkCacheGlobal);
1539
1540 RTListForEachSafe(&pBlkCacheGlobal->ListUsers, pBlkCache, pBlkCacheNext, PDMBLKCACHE, NodeCacheUser)
1541 {
1542 if ( pBlkCache->enmType == PDMBLKCACHETYPE_DRV
1543 && pBlkCache->u.Drv.pDrvIns == pDrvIns)
1544 PDMR3BlkCacheRelease(pBlkCache);
1545 }
1546
1547 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1548}
1549
1550VMMR3DECL(void) PDMR3BlkCacheReleaseUsb(PVM pVM, PPDMUSBINS pUsbIns)
1551{
1552 LogFlow(("%s: pUsbIns=%p\n", __FUNCTION__, pUsbIns));
1553
1554 /*
1555 * Validate input.
1556 */
1557 if (!pUsbIns)
1558 return;
1559 VM_ASSERT_EMT(pVM);
1560
1561 PPDMBLKCACHEGLOBAL pBlkCacheGlobal = pVM->pUVM->pdm.s.pBlkCacheGlobal;
1562 PPDMBLKCACHE pBlkCache, pBlkCacheNext;
1563
1564 /* Return silently if not supported. */
1565 if (!pBlkCacheGlobal)
1566 return;
1567
1568 pdmBlkCacheLockEnter(pBlkCacheGlobal);
1569
1570 RTListForEachSafe(&pBlkCacheGlobal->ListUsers, pBlkCache, pBlkCacheNext, PDMBLKCACHE, NodeCacheUser)
1571 {
1572 if ( pBlkCache->enmType == PDMBLKCACHETYPE_USB
1573 && pBlkCache->u.Usb.pUsbIns == pUsbIns)
1574 PDMR3BlkCacheRelease(pBlkCache);
1575 }
1576
1577 pdmBlkCacheLockLeave(pBlkCacheGlobal);
1578}
1579
1580static PPDMBLKCACHEENTRY pdmBlkCacheGetCacheEntryByOffset(PPDMBLKCACHE pBlkCache, uint64_t off)
1581{
1582 STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeGet, Cache);
1583
1584 RTSemRWRequestRead(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1585 PPDMBLKCACHEENTRY pEntry = (PPDMBLKCACHEENTRY)RTAvlrU64RangeGet(pBlkCache->pTree, off);
1586 if (pEntry)
1587 pdmBlkCacheEntryRef(pEntry);
1588 RTSemRWReleaseRead(pBlkCache->SemRWEntries);
1589
1590 STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeGet, Cache);
1591
1592 return pEntry;
1593}
1594
1595/**
1596 * Return the best fit cache entries for the given offset.
1597 *
1598 * @returns nothing.
1599 * @param pBlkCache The endpoint cache.
1600 * @param off The offset.
1601 * @param ppEntryAbove Where to store the pointer to the best fit entry above
1602 * the given offset. NULL if not required.
1603 */
1604static void pdmBlkCacheGetCacheBestFitEntryByOffset(PPDMBLKCACHE pBlkCache, uint64_t off, PPDMBLKCACHEENTRY *ppEntryAbove)
1605{
1606 STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeGet, Cache);
1607
1608 RTSemRWRequestRead(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1609 if (ppEntryAbove)
1610 {
1611 *ppEntryAbove = (PPDMBLKCACHEENTRY)RTAvlrU64GetBestFit(pBlkCache->pTree, off, true /*fAbove*/);
1612 if (*ppEntryAbove)
1613 pdmBlkCacheEntryRef(*ppEntryAbove);
1614 }
1615
1616 RTSemRWReleaseRead(pBlkCache->SemRWEntries);
1617
1618 STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeGet, Cache);
1619}
1620
1621static void pdmBlkCacheInsertEntry(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEENTRY pEntry)
1622{
1623 STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeInsert, Cache);
1624 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1625 bool fInserted = RTAvlrU64Insert(pBlkCache->pTree, &pEntry->Core);
1626 AssertMsg(fInserted, ("Node was not inserted into tree\n")); NOREF(fInserted);
1627 STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeInsert, Cache);
1628 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
1629}
1630
1631/**
1632 * Allocates and initializes a new entry for the cache.
1633 * The entry has a reference count of 1.
1634 *
1635 * @returns Pointer to the new cache entry or NULL if out of memory.
1636 * @param pBlkCache The cache the entry belongs to.
1637 * @param off Start offset.
1638 * @param cbData Size of the cache entry.
1639 * @param pbBuffer Pointer to the buffer to use.
1640 * NULL if a new buffer should be allocated.
1641 * The buffer needs to have the same size of the entry.
1642 */
1643static PPDMBLKCACHEENTRY pdmBlkCacheEntryAlloc(PPDMBLKCACHE pBlkCache, uint64_t off, size_t cbData, uint8_t *pbBuffer)
1644{
1645 AssertReturn(cbData <= UINT32_MAX, NULL);
1646 PPDMBLKCACHEENTRY pEntryNew = (PPDMBLKCACHEENTRY)RTMemAllocZ(sizeof(PDMBLKCACHEENTRY));
1647
1648 if (RT_UNLIKELY(!pEntryNew))
1649 return NULL;
1650
1651 pEntryNew->Core.Key = off;
1652 pEntryNew->Core.KeyLast = off + cbData - 1;
1653 pEntryNew->pBlkCache = pBlkCache;
1654 pEntryNew->fFlags = 0;
1655 pEntryNew->cRefs = 1; /* We are using it now. */
1656 pEntryNew->pList = NULL;
1657 pEntryNew->cbData = (uint32_t)cbData;
1658 pEntryNew->pWaitingHead = NULL;
1659 pEntryNew->pWaitingTail = NULL;
1660 if (pbBuffer)
1661 pEntryNew->pbData = pbBuffer;
1662 else
1663 pEntryNew->pbData = (uint8_t *)RTMemPageAlloc(cbData);
1664
1665 if (RT_UNLIKELY(!pEntryNew->pbData))
1666 {
1667 RTMemFree(pEntryNew);
1668 return NULL;
1669 }
1670
1671 return pEntryNew;
1672}
1673
1674/**
1675 * Checks that a set of flags is set/clear acquiring the R/W semaphore
1676 * in exclusive mode.
1677 *
1678 * @returns true if the flag in fSet is set and the one in fClear is clear.
1679 * false otherwise.
1680 * The R/W semaphore is only held if true is returned.
1681 *
1682 * @param pBlkCache The endpoint cache instance data.
1683 * @param pEntry The entry to check the flags for.
1684 * @param fSet The flag which is tested to be set.
1685 * @param fClear The flag which is tested to be clear.
1686 */
1687DECLINLINE(bool) pdmBlkCacheEntryFlagIsSetClearAcquireLock(PPDMBLKCACHE pBlkCache,
1688 PPDMBLKCACHEENTRY pEntry,
1689 uint32_t fSet, uint32_t fClear)
1690{
1691 uint32_t fFlags = ASMAtomicReadU32(&pEntry->fFlags);
1692 bool fPassed = ((fFlags & fSet) && !(fFlags & fClear));
1693
1694 if (fPassed)
1695 {
1696 /* Acquire the lock and check again because the completion callback might have raced us. */
1697 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
1698
1699 fFlags = ASMAtomicReadU32(&pEntry->fFlags);
1700 fPassed = ((fFlags & fSet) && !(fFlags & fClear));
1701
1702 /* Drop the lock if we didn't passed the test. */
1703 if (!fPassed)
1704 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
1705 }
1706
1707 return fPassed;
1708}
1709
1710/**
1711 * Adds a segment to the waiting list for a cache entry
1712 * which is currently in progress.
1713 *
1714 * @returns nothing.
1715 * @param pEntry The cache entry to add the segment to.
1716 * @param pWaiter The waiter entry to add.
1717 */
1718DECLINLINE(void) pdmBlkCacheEntryAddWaiter(PPDMBLKCACHEENTRY pEntry,
1719 PPDMBLKCACHEWAITER pWaiter)
1720{
1721 pWaiter->pNext = NULL;
1722
1723 if (pEntry->pWaitingHead)
1724 {
1725 AssertPtr(pEntry->pWaitingTail);
1726
1727 pEntry->pWaitingTail->pNext = pWaiter;
1728 pEntry->pWaitingTail = pWaiter;
1729 }
1730 else
1731 {
1732 Assert(!pEntry->pWaitingTail);
1733
1734 pEntry->pWaitingHead = pWaiter;
1735 pEntry->pWaitingTail = pWaiter;
1736 }
1737}
1738
1739/**
1740 * Add a buffer described by the I/O memory context
1741 * to the entry waiting for completion.
1742 *
1743 * @returns VBox status code.
1744 * @param pEntry The entry to add the buffer to.
1745 * @param pReq The request.
1746 * @param pSgBuf The scatter/gather buffer. Will be advanced by cbData.
1747 * @param offDiff Offset from the start of the buffer in the entry.
1748 * @param cbData Amount of data to wait for onthis entry.
1749 * @param fWrite Flag whether the task waits because it wants to write to
1750 * the cache entry.
1751 */
1752static int pdmBlkCacheEntryWaitersAdd(PPDMBLKCACHEENTRY pEntry, PPDMBLKCACHEREQ pReq,
1753 PRTSGBUF pSgBuf, uint64_t offDiff, size_t cbData, bool fWrite)
1754{
1755 PPDMBLKCACHEWAITER pWaiter = (PPDMBLKCACHEWAITER)RTMemAllocZ(sizeof(PDMBLKCACHEWAITER));
1756 if (!pWaiter)
1757 return VERR_NO_MEMORY;
1758
1759 ASMAtomicIncU32(&pReq->cXfersPending);
1760 pWaiter->pReq = pReq;
1761 pWaiter->offCacheEntry = offDiff;
1762 pWaiter->cbTransfer = cbData;
1763 pWaiter->fWrite = fWrite;
1764 RTSgBufClone(&pWaiter->SgBuf, pSgBuf);
1765 RTSgBufAdvance(pSgBuf, cbData);
1766
1767 pdmBlkCacheEntryAddWaiter(pEntry, pWaiter);
1768
1769 return VINF_SUCCESS;
1770}
1771
1772/**
1773 * Calculate aligned offset and size for a new cache entry which do not
1774 * intersect with an already existing entry and the file end.
1775 *
1776 * @returns The number of bytes the entry can hold of the requested amount
1777 * of bytes.
1778 * @param pBlkCache The endpoint cache.
1779 * @param off The start offset.
1780 * @param cb The number of bytes the entry needs to hold at
1781 * least.
1782 * @param pcbEntry Where to store the number of bytes the entry can hold.
1783 * Can be less than given because of other entries.
1784 */
1785static uint32_t pdmBlkCacheEntryBoundariesCalc(PPDMBLKCACHE pBlkCache,
1786 uint64_t off, uint32_t cb,
1787 uint32_t *pcbEntry)
1788{
1789 /* Get the best fit entries around the offset */
1790 PPDMBLKCACHEENTRY pEntryAbove = NULL;
1791 pdmBlkCacheGetCacheBestFitEntryByOffset(pBlkCache, off, &pEntryAbove);
1792
1793 /* Log the info */
1794 LogFlow(("%sest fit entry above off=%llu (BestFit=%llu BestFitEnd=%llu BestFitSize=%u)\n",
1795 pEntryAbove ? "B" : "No b",
1796 off,
1797 pEntryAbove ? pEntryAbove->Core.Key : 0,
1798 pEntryAbove ? pEntryAbove->Core.KeyLast : 0,
1799 pEntryAbove ? pEntryAbove->cbData : 0));
1800
1801 uint32_t cbNext;
1802 uint32_t cbInEntry;
1803 if ( pEntryAbove
1804 && off + cb > pEntryAbove->Core.Key)
1805 {
1806 cbInEntry = (uint32_t)(pEntryAbove->Core.Key - off);
1807 cbNext = (uint32_t)(pEntryAbove->Core.Key - off);
1808 }
1809 else
1810 {
1811 cbInEntry = cb;
1812 cbNext = cb;
1813 }
1814
1815 /* A few sanity checks */
1816 AssertMsg(!pEntryAbove || off + cbNext <= pEntryAbove->Core.Key,
1817 ("Aligned size intersects with another cache entry\n"));
1818 Assert(cbInEntry <= cbNext);
1819
1820 if (pEntryAbove)
1821 pdmBlkCacheEntryRelease(pEntryAbove);
1822
1823 LogFlow(("off=%llu cbNext=%u\n", off, cbNext));
1824
1825 *pcbEntry = cbNext;
1826
1827 return cbInEntry;
1828}
1829
1830/**
1831 * Create a new cache entry evicting data from the cache if required.
1832 *
1833 * @returns Pointer to the new cache entry or NULL
1834 * if not enough bytes could be evicted from the cache.
1835 * @param pBlkCache The endpoint cache.
1836 * @param off The offset.
1837 * @param cb Number of bytes the cache entry should have.
1838 * @param pcbData Where to store the number of bytes the new
1839 * entry can hold. May be lower than actually
1840 * requested due to another entry intersecting the
1841 * access range.
1842 */
1843static PPDMBLKCACHEENTRY pdmBlkCacheEntryCreate(PPDMBLKCACHE pBlkCache, uint64_t off, size_t cb, size_t *pcbData)
1844{
1845 uint32_t cbEntry = 0;
1846
1847 *pcbData = pdmBlkCacheEntryBoundariesCalc(pBlkCache, off, (uint32_t)cb, &cbEntry);
1848 AssertReturn(cb <= UINT32_MAX, NULL);
1849
1850 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
1851 pdmBlkCacheLockEnter(pCache);
1852
1853 PPDMBLKCACHEENTRY pEntryNew = NULL;
1854 uint8_t *pbBuffer = NULL;
1855 bool fEnough = pdmBlkCacheReclaim(pCache, cbEntry, true, &pbBuffer);
1856 if (fEnough)
1857 {
1858 LogFlow(("Evicted enough bytes (%u requested). Creating new cache entry\n", cbEntry));
1859
1860 pEntryNew = pdmBlkCacheEntryAlloc(pBlkCache, off, cbEntry, pbBuffer);
1861 if (RT_LIKELY(pEntryNew))
1862 {
1863 pdmBlkCacheEntryAddToList(&pCache->LruRecentlyUsedIn, pEntryNew);
1864 pdmBlkCacheAdd(pCache, cbEntry);
1865 pdmBlkCacheLockLeave(pCache);
1866
1867 pdmBlkCacheInsertEntry(pBlkCache, pEntryNew);
1868
1869 AssertMsg( (off >= pEntryNew->Core.Key)
1870 && (off + *pcbData <= pEntryNew->Core.KeyLast + 1),
1871 ("Overflow in calculation off=%llu\n", off));
1872 }
1873 else
1874 pdmBlkCacheLockLeave(pCache);
1875 }
1876 else
1877 pdmBlkCacheLockLeave(pCache);
1878
1879 return pEntryNew;
1880}
1881
1882static PPDMBLKCACHEREQ pdmBlkCacheReqAlloc(void *pvUser)
1883{
1884 PPDMBLKCACHEREQ pReq = (PPDMBLKCACHEREQ)RTMemAlloc(sizeof(PDMBLKCACHEREQ));
1885
1886 if (RT_LIKELY(pReq))
1887 {
1888 pReq->pvUser = pvUser;
1889 pReq->rcReq = VINF_SUCCESS;
1890 pReq->cXfersPending = 0;
1891 }
1892
1893 return pReq;
1894}
1895
1896static void pdmBlkCacheReqComplete(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEREQ pReq)
1897{
1898 switch (pBlkCache->enmType)
1899 {
1900 case PDMBLKCACHETYPE_DEV:
1901 {
1902 pBlkCache->u.Dev.pfnXferComplete(pBlkCache->u.Dev.pDevIns,
1903 pReq->pvUser, pReq->rcReq);
1904 break;
1905 }
1906 case PDMBLKCACHETYPE_DRV:
1907 {
1908 pBlkCache->u.Drv.pfnXferComplete(pBlkCache->u.Drv.pDrvIns,
1909 pReq->pvUser, pReq->rcReq);
1910 break;
1911 }
1912 case PDMBLKCACHETYPE_USB:
1913 {
1914 pBlkCache->u.Usb.pfnXferComplete(pBlkCache->u.Usb.pUsbIns,
1915 pReq->pvUser, pReq->rcReq);
1916 break;
1917 }
1918 case PDMBLKCACHETYPE_INTERNAL:
1919 {
1920 pBlkCache->u.Int.pfnXferComplete(pBlkCache->u.Int.pvUser,
1921 pReq->pvUser, pReq->rcReq);
1922 break;
1923 }
1924 default:
1925 AssertMsgFailed(("Unknown block cache type!\n"));
1926 }
1927
1928 RTMemFree(pReq);
1929}
1930
1931static bool pdmBlkCacheReqUpdate(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEREQ pReq,
1932 int rcReq, bool fCallHandler)
1933{
1934 if (RT_FAILURE(rcReq))
1935 ASMAtomicCmpXchgS32(&pReq->rcReq, rcReq, VINF_SUCCESS);
1936
1937 AssertMsg(pReq->cXfersPending > 0, ("No transfers are pending for this request\n"));
1938 uint32_t cXfersPending = ASMAtomicDecU32(&pReq->cXfersPending);
1939
1940 if (!cXfersPending)
1941 {
1942 if (fCallHandler)
1943 pdmBlkCacheReqComplete(pBlkCache, pReq);
1944 return true;
1945 }
1946
1947 LogFlowFunc(("pReq=%#p cXfersPending=%u\n", pReq, cXfersPending));
1948 return false;
1949}
1950
1951VMMR3DECL(int) PDMR3BlkCacheRead(PPDMBLKCACHE pBlkCache, uint64_t off,
1952 PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser)
1953{
1954 int rc = VINF_SUCCESS;
1955 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
1956 PPDMBLKCACHEENTRY pEntry;
1957 PPDMBLKCACHEREQ pReq;
1958
1959 LogFlowFunc((": pBlkCache=%#p{%s} off=%llu pSgBuf=%#p cbRead=%u pvUser=%#p\n",
1960 pBlkCache, pBlkCache->pszId, off, pSgBuf, cbRead, pvUser));
1961
1962 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
1963 AssertReturn(!pBlkCache->fSuspended, VERR_INVALID_STATE);
1964
1965 RTSGBUF SgBuf;
1966 RTSgBufClone(&SgBuf, pSgBuf);
1967
1968 /* Allocate new request structure. */
1969 pReq = pdmBlkCacheReqAlloc(pvUser);
1970 if (RT_UNLIKELY(!pReq))
1971 return VERR_NO_MEMORY;
1972
1973 /* Increment data transfer counter to keep the request valid while we access it. */
1974 ASMAtomicIncU32(&pReq->cXfersPending);
1975
1976 while (cbRead)
1977 {
1978 size_t cbToRead;
1979
1980 pEntry = pdmBlkCacheGetCacheEntryByOffset(pBlkCache, off);
1981
1982 /*
1983 * If there is no entry we try to create a new one eviciting unused pages
1984 * if the cache is full. If this is not possible we will pass the request through
1985 * and skip the caching (all entries may be still in progress so they can't
1986 * be evicted)
1987 * If we have an entry it can be in one of the LRU lists where the entry
1988 * contains data (recently used or frequently used LRU) so we can just read
1989 * the data we need and put the entry at the head of the frequently used LRU list.
1990 * In case the entry is in one of the ghost lists it doesn't contain any data.
1991 * We have to fetch it again evicting pages from either T1 or T2 to make room.
1992 */
1993 if (pEntry)
1994 {
1995 uint64_t offDiff = off - pEntry->Core.Key;
1996
1997 AssertMsg(off >= pEntry->Core.Key,
1998 ("Overflow in calculation off=%llu OffsetAligned=%llu\n",
1999 off, pEntry->Core.Key));
2000
2001 AssertPtr(pEntry->pList);
2002
2003 cbToRead = RT_MIN(pEntry->cbData - offDiff, cbRead);
2004
2005 AssertMsg(off + cbToRead <= pEntry->Core.Key + pEntry->Core.KeyLast + 1,
2006 ("Buffer of cache entry exceeded off=%llu cbToRead=%d\n",
2007 off, cbToRead));
2008
2009 cbRead -= cbToRead;
2010
2011 if (!cbRead)
2012 STAM_COUNTER_INC(&pCache->cHits);
2013 else
2014 STAM_COUNTER_INC(&pCache->cPartialHits);
2015
2016 STAM_COUNTER_ADD(&pCache->StatRead, cbToRead);
2017
2018 /* Ghost lists contain no data. */
2019 if ( (pEntry->pList == &pCache->LruRecentlyUsedIn)
2020 || (pEntry->pList == &pCache->LruFrequentlyUsed))
2021 {
2022 if (pdmBlkCacheEntryFlagIsSetClearAcquireLock(pBlkCache, pEntry,
2023 PDMBLKCACHE_ENTRY_IO_IN_PROGRESS,
2024 PDMBLKCACHE_ENTRY_IS_DIRTY))
2025 {
2026 /* Entry didn't completed yet. Append to the list */
2027 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2028 &SgBuf, offDiff, cbToRead,
2029 false /* fWrite */);
2030 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2031 }
2032 else
2033 {
2034 /* Read as much as we can from the entry. */
2035 RTSgBufCopyFromBuf(&SgBuf, pEntry->pbData + offDiff, cbToRead);
2036 }
2037
2038 /* Move this entry to the top position */
2039 if (pEntry->pList == &pCache->LruFrequentlyUsed)
2040 {
2041 pdmBlkCacheLockEnter(pCache);
2042 pdmBlkCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
2043 pdmBlkCacheLockLeave(pCache);
2044 }
2045 /* Release the entry */
2046 pdmBlkCacheEntryRelease(pEntry);
2047 }
2048 else
2049 {
2050 uint8_t *pbBuffer = NULL;
2051
2052 LogFlow(("Fetching data for ghost entry %#p from file\n", pEntry));
2053
2054 pdmBlkCacheLockEnter(pCache);
2055 pdmBlkCacheEntryRemoveFromList(pEntry); /* Remove it before we remove data, otherwise it may get freed when evicting data. */
2056 bool fEnough = pdmBlkCacheReclaim(pCache, pEntry->cbData, true, &pbBuffer);
2057
2058 /* Move the entry to Am and fetch it to the cache. */
2059 if (fEnough)
2060 {
2061 pdmBlkCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
2062 pdmBlkCacheAdd(pCache, pEntry->cbData);
2063 pdmBlkCacheLockLeave(pCache);
2064
2065 if (pbBuffer)
2066 pEntry->pbData = pbBuffer;
2067 else
2068 pEntry->pbData = (uint8_t *)RTMemPageAlloc(pEntry->cbData);
2069 AssertPtr(pEntry->pbData);
2070
2071 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2072 &SgBuf, offDiff, cbToRead,
2073 false /* fWrite */);
2074 pdmBlkCacheEntryReadFromMedium(pEntry);
2075 /* Release the entry */
2076 pdmBlkCacheEntryRelease(pEntry);
2077 }
2078 else
2079 {
2080 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2081 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
2082 RTAvlrU64Remove(pBlkCache->pTree, pEntry->Core.Key);
2083 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
2084 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2085
2086 pdmBlkCacheLockLeave(pCache);
2087
2088 RTMemFree(pEntry);
2089
2090 pdmBlkCacheRequestPassthrough(pBlkCache, pReq,
2091 &SgBuf, off, cbToRead,
2092 PDMBLKCACHEXFERDIR_READ);
2093 }
2094 }
2095 }
2096 else
2097 {
2098#ifdef VBOX_WITH_IO_READ_CACHE
2099 /* No entry found for this offset. Create a new entry and fetch the data to the cache. */
2100 PPDMBLKCACHEENTRY pEntryNew = pdmBlkCacheEntryCreate(pBlkCache,
2101 off, cbRead,
2102 &cbToRead);
2103
2104 cbRead -= cbToRead;
2105
2106 if (pEntryNew)
2107 {
2108 if (!cbRead)
2109 STAM_COUNTER_INC(&pCache->cMisses);
2110 else
2111 STAM_COUNTER_INC(&pCache->cPartialHits);
2112
2113 pdmBlkCacheEntryWaitersAdd(pEntryNew, pReq,
2114 &SgBuf,
2115 off - pEntryNew->Core.Key,
2116 cbToRead,
2117 false /* fWrite */);
2118 pdmBlkCacheEntryReadFromMedium(pEntryNew);
2119 pdmBlkCacheEntryRelease(pEntryNew); /* it is protected by the I/O in progress flag now. */
2120 }
2121 else
2122 {
2123 /*
2124 * There is not enough free space in the cache.
2125 * Pass the request directly to the I/O manager.
2126 */
2127 LogFlow(("Couldn't evict %u bytes from the cache. Remaining request will be passed through\n", cbToRead));
2128
2129 pdmBlkCacheRequestPassthrough(pBlkCache, pReq,
2130 &SgBuf, off, cbToRead,
2131 PDMBLKCACHEXFERDIR_READ);
2132 }
2133#else
2134 /* Clip read size if necessary. */
2135 PPDMBLKCACHEENTRY pEntryAbove;
2136 pdmBlkCacheGetCacheBestFitEntryByOffset(pBlkCache, off, &pEntryAbove);
2137
2138 if (pEntryAbove)
2139 {
2140 if (off + cbRead > pEntryAbove->Core.Key)
2141 cbToRead = pEntryAbove->Core.Key - off;
2142 else
2143 cbToRead = cbRead;
2144
2145 pdmBlkCacheEntryRelease(pEntryAbove);
2146 }
2147 else
2148 cbToRead = cbRead;
2149
2150 cbRead -= cbToRead;
2151 pdmBlkCacheRequestPassthrough(pBlkCache, pReq,
2152 &SgBuf, off, cbToRead,
2153 PDMBLKCACHEXFERDIR_READ);
2154#endif
2155 }
2156 off += cbToRead;
2157 }
2158
2159 if (!pdmBlkCacheReqUpdate(pBlkCache, pReq, rc, false))
2160 rc = VINF_AIO_TASK_PENDING;
2161 else
2162 {
2163 rc = pReq->rcReq;
2164 RTMemFree(pReq);
2165 }
2166
2167 LogFlowFunc((": Leave rc=%Rrc\n", rc));
2168
2169 return rc;
2170}
2171
2172VMMR3DECL(int) PDMR3BlkCacheWrite(PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbWrite, void *pvUser)
2173{
2174 int rc = VINF_SUCCESS;
2175 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
2176 PPDMBLKCACHEENTRY pEntry;
2177 PPDMBLKCACHEREQ pReq;
2178
2179 LogFlowFunc((": pBlkCache=%#p{%s} off=%llu pSgBuf=%#p cbWrite=%u pvUser=%#p\n",
2180 pBlkCache, pBlkCache->pszId, off, pSgBuf, cbWrite, pvUser));
2181
2182 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
2183 AssertReturn(!pBlkCache->fSuspended, VERR_INVALID_STATE);
2184
2185 RTSGBUF SgBuf;
2186 RTSgBufClone(&SgBuf, pSgBuf);
2187
2188 /* Allocate new request structure. */
2189 pReq = pdmBlkCacheReqAlloc(pvUser);
2190 if (RT_UNLIKELY(!pReq))
2191 return VERR_NO_MEMORY;
2192
2193 /* Increment data transfer counter to keep the request valid while we access it. */
2194 ASMAtomicIncU32(&pReq->cXfersPending);
2195
2196 while (cbWrite)
2197 {
2198 size_t cbToWrite;
2199
2200 pEntry = pdmBlkCacheGetCacheEntryByOffset(pBlkCache, off);
2201 if (pEntry)
2202 {
2203 /* Write the data into the entry and mark it as dirty */
2204 AssertPtr(pEntry->pList);
2205
2206 uint64_t offDiff = off - pEntry->Core.Key;
2207 AssertMsg(off >= pEntry->Core.Key, ("Overflow in calculation off=%llu OffsetAligned=%llu\n", off, pEntry->Core.Key));
2208
2209 cbToWrite = RT_MIN(pEntry->cbData - offDiff, cbWrite);
2210 cbWrite -= cbToWrite;
2211
2212 if (!cbWrite)
2213 STAM_COUNTER_INC(&pCache->cHits);
2214 else
2215 STAM_COUNTER_INC(&pCache->cPartialHits);
2216
2217 STAM_COUNTER_ADD(&pCache->StatWritten, cbToWrite);
2218
2219 /* Ghost lists contain no data. */
2220 if ( (pEntry->pList == &pCache->LruRecentlyUsedIn)
2221 || (pEntry->pList == &pCache->LruFrequentlyUsed))
2222 {
2223 /* Check if the entry is dirty. */
2224 if (pdmBlkCacheEntryFlagIsSetClearAcquireLock(pBlkCache, pEntry,
2225 PDMBLKCACHE_ENTRY_IS_DIRTY,
2226 0))
2227 {
2228 /* If it is already dirty but not in progress just update the data. */
2229 if (!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS))
2230 RTSgBufCopyToBuf(&SgBuf, pEntry->pbData + offDiff, cbToWrite);
2231 else
2232 {
2233 /* The data isn't written to the file yet */
2234 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2235 &SgBuf, offDiff, cbToWrite,
2236 true /* fWrite */);
2237 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2238 }
2239
2240 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2241 }
2242 else /* Dirty bit not set */
2243 {
2244 /*
2245 * Check if a read is in progress for this entry.
2246 * We have to defer processing in that case.
2247 */
2248 if (pdmBlkCacheEntryFlagIsSetClearAcquireLock(pBlkCache, pEntry,
2249 PDMBLKCACHE_ENTRY_IO_IN_PROGRESS,
2250 0))
2251 {
2252 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2253 &SgBuf, offDiff, cbToWrite,
2254 true /* fWrite */);
2255 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2256 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2257 }
2258 else /* I/O in progress flag not set */
2259 {
2260 /* Write as much as we can into the entry and update the file. */
2261 RTSgBufCopyToBuf(&SgBuf, pEntry->pbData + offDiff, cbToWrite);
2262
2263 bool fCommit = pdmBlkCacheAddDirtyEntry(pBlkCache, pEntry);
2264 if (fCommit)
2265 pdmBlkCacheCommitDirtyEntries(pCache);
2266 }
2267 } /* Dirty bit not set */
2268
2269 /* Move this entry to the top position */
2270 if (pEntry->pList == &pCache->LruFrequentlyUsed)
2271 {
2272 pdmBlkCacheLockEnter(pCache);
2273 pdmBlkCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
2274 pdmBlkCacheLockLeave(pCache);
2275 }
2276
2277 pdmBlkCacheEntryRelease(pEntry);
2278 }
2279 else /* Entry is on the ghost list */
2280 {
2281 uint8_t *pbBuffer = NULL;
2282
2283 pdmBlkCacheLockEnter(pCache);
2284 pdmBlkCacheEntryRemoveFromList(pEntry); /* Remove it before we remove data, otherwise it may get freed when evicting data. */
2285 bool fEnough = pdmBlkCacheReclaim(pCache, pEntry->cbData, true, &pbBuffer);
2286
2287 if (fEnough)
2288 {
2289 /* Move the entry to Am and fetch it to the cache. */
2290 pdmBlkCacheEntryAddToList(&pCache->LruFrequentlyUsed, pEntry);
2291 pdmBlkCacheAdd(pCache, pEntry->cbData);
2292 pdmBlkCacheLockLeave(pCache);
2293
2294 if (pbBuffer)
2295 pEntry->pbData = pbBuffer;
2296 else
2297 pEntry->pbData = (uint8_t *)RTMemPageAlloc(pEntry->cbData);
2298 AssertPtr(pEntry->pbData);
2299
2300 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2301 &SgBuf, offDiff, cbToWrite,
2302 true /* fWrite */);
2303 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2304 pdmBlkCacheEntryReadFromMedium(pEntry);
2305
2306 /* Release the reference. If it is still needed the I/O in progress flag should protect it now. */
2307 pdmBlkCacheEntryRelease(pEntry);
2308 }
2309 else
2310 {
2311 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2312 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
2313 RTAvlrU64Remove(pBlkCache->pTree, pEntry->Core.Key);
2314 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
2315 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2316
2317 pdmBlkCacheLockLeave(pCache);
2318
2319 RTMemFree(pEntry);
2320 pdmBlkCacheRequestPassthrough(pBlkCache, pReq,
2321 &SgBuf, off, cbToWrite,
2322 PDMBLKCACHEXFERDIR_WRITE);
2323 }
2324 }
2325 }
2326 else /* No entry found */
2327 {
2328 /*
2329 * No entry found. Try to create a new cache entry to store the data in and if that fails
2330 * write directly to the file.
2331 */
2332 PPDMBLKCACHEENTRY pEntryNew = pdmBlkCacheEntryCreate(pBlkCache,
2333 off, cbWrite,
2334 &cbToWrite);
2335
2336 cbWrite -= cbToWrite;
2337
2338 if (pEntryNew)
2339 {
2340 uint64_t offDiff = off - pEntryNew->Core.Key;
2341
2342 STAM_COUNTER_INC(&pCache->cHits);
2343
2344 /*
2345 * Check if it is possible to just write the data without waiting
2346 * for it to get fetched first.
2347 */
2348 if (!offDiff && pEntryNew->cbData == cbToWrite)
2349 {
2350 RTSgBufCopyToBuf(&SgBuf, pEntryNew->pbData, cbToWrite);
2351
2352 bool fCommit = pdmBlkCacheAddDirtyEntry(pBlkCache, pEntryNew);
2353 if (fCommit)
2354 pdmBlkCacheCommitDirtyEntries(pCache);
2355 STAM_COUNTER_ADD(&pCache->StatWritten, cbToWrite);
2356 }
2357 else
2358 {
2359 /* Defer the write and fetch the data from the endpoint. */
2360 pdmBlkCacheEntryWaitersAdd(pEntryNew, pReq,
2361 &SgBuf, offDiff, cbToWrite,
2362 true /* fWrite */);
2363 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2364 pdmBlkCacheEntryReadFromMedium(pEntryNew);
2365 }
2366
2367 pdmBlkCacheEntryRelease(pEntryNew);
2368 }
2369 else
2370 {
2371 /*
2372 * There is not enough free space in the cache.
2373 * Pass the request directly to the I/O manager.
2374 */
2375 LogFlow(("Couldn't evict %u bytes from the cache. Remaining request will be passed through\n", cbToWrite));
2376
2377 STAM_COUNTER_INC(&pCache->cMisses);
2378
2379 pdmBlkCacheRequestPassthrough(pBlkCache, pReq,
2380 &SgBuf, off, cbToWrite,
2381 PDMBLKCACHEXFERDIR_WRITE);
2382 }
2383 }
2384
2385 off += cbToWrite;
2386 }
2387
2388 if (!pdmBlkCacheReqUpdate(pBlkCache, pReq, rc, false))
2389 rc = VINF_AIO_TASK_PENDING;
2390 else
2391 {
2392 rc = pReq->rcReq;
2393 RTMemFree(pReq);
2394 }
2395
2396 LogFlowFunc((": Leave rc=%Rrc\n", rc));
2397
2398 return rc;
2399}
2400
2401VMMR3DECL(int) PDMR3BlkCacheFlush(PPDMBLKCACHE pBlkCache, void *pvUser)
2402{
2403 int rc = VINF_SUCCESS;
2404 PPDMBLKCACHEREQ pReq;
2405
2406 LogFlowFunc((": pBlkCache=%#p{%s}\n", pBlkCache, pBlkCache->pszId));
2407
2408 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
2409 AssertReturn(!pBlkCache->fSuspended, VERR_INVALID_STATE);
2410
2411 /* Commit dirty entries in the cache. */
2412 pdmBlkCacheCommit(pBlkCache);
2413
2414 /* Allocate new request structure. */
2415 pReq = pdmBlkCacheReqAlloc(pvUser);
2416 if (RT_UNLIKELY(!pReq))
2417 return VERR_NO_MEMORY;
2418
2419 rc = pdmBlkCacheRequestPassthrough(pBlkCache, pReq, NULL, 0, 0,
2420 PDMBLKCACHEXFERDIR_FLUSH);
2421 AssertRC(rc);
2422
2423 LogFlowFunc((": Leave rc=%Rrc\n", rc));
2424 return VINF_AIO_TASK_PENDING;
2425}
2426
2427VMMR3DECL(int) PDMR3BlkCacheDiscard(PPDMBLKCACHE pBlkCache, PCRTRANGE paRanges,
2428 unsigned cRanges, void *pvUser)
2429{
2430 int rc = VINF_SUCCESS;
2431 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
2432 PPDMBLKCACHEENTRY pEntry;
2433 PPDMBLKCACHEREQ pReq;
2434
2435 LogFlowFunc((": pBlkCache=%#p{%s} paRanges=%#p cRanges=%u pvUser=%#p\n",
2436 pBlkCache, pBlkCache->pszId, paRanges, cRanges, pvUser));
2437
2438 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
2439 AssertReturn(!pBlkCache->fSuspended, VERR_INVALID_STATE);
2440
2441 /* Allocate new request structure. */
2442 pReq = pdmBlkCacheReqAlloc(pvUser);
2443 if (RT_UNLIKELY(!pReq))
2444 return VERR_NO_MEMORY;
2445
2446 /* Increment data transfer counter to keep the request valid while we access it. */
2447 ASMAtomicIncU32(&pReq->cXfersPending);
2448
2449 for (unsigned i = 0; i < cRanges; i++)
2450 {
2451 uint64_t offCur = paRanges[i].offStart;
2452 size_t cbLeft = paRanges[i].cbRange;
2453
2454 while (cbLeft)
2455 {
2456 size_t cbThisDiscard = 0;
2457
2458 pEntry = pdmBlkCacheGetCacheEntryByOffset(pBlkCache, offCur);
2459
2460 if (pEntry)
2461 {
2462 /* Write the data into the entry and mark it as dirty */
2463 AssertPtr(pEntry->pList);
2464
2465 uint64_t offDiff = offCur - pEntry->Core.Key;
2466
2467 AssertMsg(offCur >= pEntry->Core.Key,
2468 ("Overflow in calculation offCur=%llu OffsetAligned=%llu\n",
2469 offCur, pEntry->Core.Key));
2470
2471 cbThisDiscard = RT_MIN(pEntry->cbData - offDiff, cbLeft);
2472
2473 /* Ghost lists contain no data. */
2474 if ( (pEntry->pList == &pCache->LruRecentlyUsedIn)
2475 || (pEntry->pList == &pCache->LruFrequentlyUsed))
2476 {
2477 /* Check if the entry is dirty. */
2478 if (pdmBlkCacheEntryFlagIsSetClearAcquireLock(pBlkCache, pEntry,
2479 PDMBLKCACHE_ENTRY_IS_DIRTY,
2480 0))
2481 {
2482 /* If it is dirty but not yet in progress remove it. */
2483 if (!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS))
2484 {
2485 pdmBlkCacheLockEnter(pCache);
2486 pdmBlkCacheEntryRemoveFromList(pEntry);
2487
2488 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
2489 RTAvlrU64Remove(pBlkCache->pTree, pEntry->Core.Key);
2490 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
2491
2492 pdmBlkCacheLockLeave(pCache);
2493
2494 RTMemFree(pEntry);
2495 }
2496 else
2497 {
2498#if 0
2499 /* The data isn't written to the file yet */
2500 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2501 &SgBuf, offDiff, cbToWrite,
2502 true /* fWrite */);
2503 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2504#endif
2505 }
2506
2507 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2508 pdmBlkCacheEntryRelease(pEntry);
2509 }
2510 else /* Dirty bit not set */
2511 {
2512 /*
2513 * Check if a read is in progress for this entry.
2514 * We have to defer processing in that case.
2515 */
2516 if(pdmBlkCacheEntryFlagIsSetClearAcquireLock(pBlkCache, pEntry,
2517 PDMBLKCACHE_ENTRY_IO_IN_PROGRESS,
2518 0))
2519 {
2520#if 0
2521 pdmBlkCacheEntryWaitersAdd(pEntry, pReq,
2522 &SgBuf, offDiff, cbToWrite,
2523 true /* fWrite */);
2524#endif
2525 STAM_COUNTER_INC(&pBlkCache->StatWriteDeferred);
2526 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2527 pdmBlkCacheEntryRelease(pEntry);
2528 }
2529 else /* I/O in progress flag not set */
2530 {
2531 pdmBlkCacheLockEnter(pCache);
2532 pdmBlkCacheEntryRemoveFromList(pEntry);
2533
2534 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2535 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
2536 RTAvlrU64Remove(pBlkCache->pTree, pEntry->Core.Key);
2537 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
2538 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2539
2540 pdmBlkCacheLockLeave(pCache);
2541
2542 RTMemFree(pEntry);
2543 }
2544 } /* Dirty bit not set */
2545 }
2546 else /* Entry is on the ghost list just remove cache entry. */
2547 {
2548 pdmBlkCacheLockEnter(pCache);
2549 pdmBlkCacheEntryRemoveFromList(pEntry);
2550
2551 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2552 STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
2553 RTAvlrU64Remove(pBlkCache->pTree, pEntry->Core.Key);
2554 STAM_PROFILE_ADV_STOP(&pCache->StatTreeRemove, Cache);
2555 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2556
2557 pdmBlkCacheLockLeave(pCache);
2558
2559 RTMemFree(pEntry);
2560 }
2561 }
2562 /* else: no entry found. */
2563
2564 offCur += cbThisDiscard;
2565 cbLeft -= cbThisDiscard;
2566 }
2567 }
2568
2569 if (!pdmBlkCacheReqUpdate(pBlkCache, pReq, rc, false))
2570 rc = VINF_AIO_TASK_PENDING;
2571 else
2572 {
2573 rc = pReq->rcReq;
2574 RTMemFree(pReq);
2575 }
2576
2577 LogFlowFunc((": Leave rc=%Rrc\n", rc));
2578
2579 return rc;
2580}
2581
2582/**
2583 * Completes a task segment freeing all resources and completes the task handle
2584 * if everything was transferred.
2585 *
2586 * @returns Next task segment handle.
2587 * @param pBlkCache The endpoint block cache.
2588 * @param pWaiter Task segment to complete.
2589 * @param rc Status code to set.
2590 */
2591static PPDMBLKCACHEWAITER pdmBlkCacheWaiterComplete(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEWAITER pWaiter, int rc)
2592{
2593 PPDMBLKCACHEWAITER pNext = pWaiter->pNext;
2594 PPDMBLKCACHEREQ pReq = pWaiter->pReq;
2595
2596 pdmBlkCacheReqUpdate(pBlkCache, pReq, rc, true);
2597
2598 RTMemFree(pWaiter);
2599
2600 return pNext;
2601}
2602
2603static void pdmBlkCacheIoXferCompleteEntry(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer)
2604{
2605 PPDMBLKCACHEENTRY pEntry = hIoXfer->pEntry;
2606 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
2607
2608 /* Reference the entry now as we are clearing the I/O in progress flag
2609 * which protected the entry till now. */
2610 pdmBlkCacheEntryRef(pEntry);
2611
2612 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2613 pEntry->fFlags &= ~PDMBLKCACHE_ENTRY_IO_IN_PROGRESS;
2614
2615 /* Process waiting segment list. The data in entry might have changed in-between. */
2616 bool fDirty = false;
2617 PPDMBLKCACHEWAITER pComplete = pEntry->pWaitingHead;
2618 PPDMBLKCACHEWAITER pCurr = pComplete;
2619
2620 AssertMsg((pCurr && pEntry->pWaitingTail) || (!pCurr && !pEntry->pWaitingTail),
2621 ("The list tail was not updated correctly\n"));
2622 pEntry->pWaitingTail = NULL;
2623 pEntry->pWaitingHead = NULL;
2624
2625 if (hIoXfer->enmXferDir == PDMBLKCACHEXFERDIR_WRITE)
2626 {
2627 /*
2628 * An error here is difficult to handle as the original request completed already.
2629 * The error is logged for now and the VM is paused.
2630 * If the user continues the entry is written again in the hope
2631 * the user fixed the problem and the next write succeeds.
2632 */
2633 if (RT_FAILURE(rcIoXfer))
2634 {
2635 LogRel(("I/O cache: Error while writing entry at offset %llu (%u bytes) to medium \"%s\" (rc=%Rrc)\n",
2636 pEntry->Core.Key, pEntry->cbData, pBlkCache->pszId, rcIoXfer));
2637
2638 if (!ASMAtomicXchgBool(&pCache->fIoErrorVmSuspended, true))
2639 {
2640 int rc = VMSetRuntimeError(pCache->pVM, VMSETRTERR_FLAGS_SUSPEND | VMSETRTERR_FLAGS_NO_WAIT, "BLKCACHE_IOERR",
2641 N_("The I/O cache encountered an error while updating data in medium \"%s\" (rc=%Rrc). "
2642 "Make sure there is enough free space on the disk and that the disk is working properly. "
2643 "Operation can be resumed afterwards"),
2644 pBlkCache->pszId, rcIoXfer);
2645 AssertRC(rc);
2646 }
2647
2648 /* Mark the entry as dirty again to get it added to the list later on. */
2649 fDirty = true;
2650 }
2651
2652 pEntry->fFlags &= ~PDMBLKCACHE_ENTRY_IS_DIRTY;
2653
2654 while (pCurr)
2655 {
2656 AssertMsg(pCurr->fWrite, ("Completed write entries should never have read tasks attached\n"));
2657
2658 RTSgBufCopyToBuf(&pCurr->SgBuf, pEntry->pbData + pCurr->offCacheEntry, pCurr->cbTransfer);
2659 fDirty = true;
2660 pCurr = pCurr->pNext;
2661 }
2662 }
2663 else
2664 {
2665 AssertMsg(hIoXfer->enmXferDir == PDMBLKCACHEXFERDIR_READ, ("Invalid transfer type\n"));
2666 AssertMsg(!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IS_DIRTY),
2667 ("Invalid flags set\n"));
2668
2669 while (pCurr)
2670 {
2671 if (pCurr->fWrite)
2672 {
2673 RTSgBufCopyToBuf(&pCurr->SgBuf, pEntry->pbData + pCurr->offCacheEntry, pCurr->cbTransfer);
2674 fDirty = true;
2675 }
2676 else
2677 RTSgBufCopyFromBuf(&pCurr->SgBuf, pEntry->pbData + pCurr->offCacheEntry, pCurr->cbTransfer);
2678
2679 pCurr = pCurr->pNext;
2680 }
2681 }
2682
2683 bool fCommit = false;
2684 if (fDirty)
2685 fCommit = pdmBlkCacheAddDirtyEntry(pBlkCache, pEntry);
2686
2687 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2688
2689 /* Dereference so that it isn't protected anymore except we issued anyother write for it. */
2690 pdmBlkCacheEntryRelease(pEntry);
2691
2692 if (fCommit)
2693 pdmBlkCacheCommitDirtyEntries(pCache);
2694
2695 /* Complete waiters now. */
2696 while (pComplete)
2697 pComplete = pdmBlkCacheWaiterComplete(pBlkCache, pComplete, rcIoXfer);
2698}
2699
2700VMMR3DECL(void) PDMR3BlkCacheIoXferComplete(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer)
2701{
2702 LogFlowFunc(("pBlkCache=%#p hIoXfer=%#p rcIoXfer=%Rrc\n", pBlkCache, hIoXfer, rcIoXfer));
2703
2704 if (hIoXfer->fIoCache)
2705 pdmBlkCacheIoXferCompleteEntry(pBlkCache, hIoXfer, rcIoXfer);
2706 else
2707 pdmBlkCacheReqUpdate(pBlkCache, hIoXfer->pReq, rcIoXfer, true);
2708
2709 ASMAtomicDecU32(&pBlkCache->cIoXfersActive);
2710 pdmBlkCacheR3TraceMsgF(pBlkCache, "BlkCache: I/O req %#p (%RTbool) completed (%u now active)",
2711 hIoXfer, hIoXfer->fIoCache, pBlkCache->cIoXfersActive);
2712 RTMemFree(hIoXfer);
2713}
2714
2715/**
2716 * Callback for the AVL do with all routine. Waits for a cachen entry to finish any pending I/O.
2717 *
2718 * @returns IPRT status code.
2719 * @param pNode The node to destroy.
2720 * @param pvUser Opaque user data.
2721 */
2722static DECLCALLBACK(int) pdmBlkCacheEntryQuiesce(PAVLRU64NODECORE pNode, void *pvUser)
2723{
2724 PPDMBLKCACHEENTRY pEntry = (PPDMBLKCACHEENTRY)pNode;
2725 PPDMBLKCACHE pBlkCache = pEntry->pBlkCache;
2726 NOREF(pvUser);
2727
2728 while (ASMAtomicReadU32(&pEntry->fFlags) & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS)
2729 {
2730 /* Leave the locks to let the I/O thread make progress but reference the entry to prevent eviction. */
2731 pdmBlkCacheEntryRef(pEntry);
2732 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2733
2734 RTThreadSleep(1);
2735
2736 /* Re-enter all locks and drop the reference. */
2737 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2738 pdmBlkCacheEntryRelease(pEntry);
2739 }
2740
2741 AssertMsg(!(pEntry->fFlags & PDMBLKCACHE_ENTRY_IO_IN_PROGRESS),
2742 ("Entry is dirty and/or still in progress fFlags=%#x\n", pEntry->fFlags));
2743
2744 return VINF_SUCCESS;
2745}
2746
2747VMMR3DECL(int) PDMR3BlkCacheSuspend(PPDMBLKCACHE pBlkCache)
2748{
2749 int rc = VINF_SUCCESS;
2750 LogFlowFunc(("pBlkCache=%#p\n", pBlkCache));
2751
2752 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
2753
2754 if (!ASMAtomicReadBool(&pBlkCache->pCache->fIoErrorVmSuspended))
2755 pdmBlkCacheCommit(pBlkCache); /* Can issue new I/O requests. */
2756 ASMAtomicXchgBool(&pBlkCache->fSuspended, true);
2757
2758 /* Wait for all I/O to complete. */
2759 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2760 rc = RTAvlrU64DoWithAll(pBlkCache->pTree, true, pdmBlkCacheEntryQuiesce, NULL);
2761 AssertRC(rc);
2762 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2763
2764 return rc;
2765}
2766
2767VMMR3DECL(int) PDMR3BlkCacheResume(PPDMBLKCACHE pBlkCache)
2768{
2769 LogFlowFunc(("pBlkCache=%#p\n", pBlkCache));
2770
2771 AssertPtrReturn(pBlkCache, VERR_INVALID_POINTER);
2772
2773 ASMAtomicXchgBool(&pBlkCache->fSuspended, false);
2774
2775 return VINF_SUCCESS;
2776}
2777
2778VMMR3DECL(int) PDMR3BlkCacheClear(PPDMBLKCACHE pBlkCache)
2779{
2780 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
2781
2782 /*
2783 * Commit all dirty entries now (they are waited on for completion during the
2784 * destruction of the AVL tree below).
2785 * The exception is if the VM was paused because of an I/O error before.
2786 */
2787 if (!ASMAtomicReadBool(&pCache->fIoErrorVmSuspended))
2788 pdmBlkCacheCommit(pBlkCache);
2789
2790 /* Make sure nobody is accessing the cache while we delete the tree. */
2791 pdmBlkCacheLockEnter(pCache);
2792 RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
2793 RTAvlrU64Destroy(pBlkCache->pTree, pdmBlkCacheEntryDestroy, pCache);
2794 RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
2795
2796 pdmBlkCacheLockLeave(pCache);
2797 return VINF_SUCCESS;
2798}
2799
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