VirtualBox

source: vbox/trunk/src/VBox/Storage/VDInternal.h@ 69564

Last change on this file since 69564 was 66486, checked in by vboxsync, 7 years ago

Storage/VD: Convert all backends to use the region list callbacks, remove the pfnGetSize and pfnGetSectorSize callbacks because they are covered by the region lists
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.2 KB
Line 
1/* $Id: VDInternal.h 66486 2017-04-10 07:23:59Z vboxsync $ */
2/** @file
3 * VD - Virtual Disk container implementation, internal header file.
4 */
5
6/*
7 * Copyright (C) 2017 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* Header Files *
20*********************************************************************************************************************************/
21#ifndef ___VDInternal_h
22#define ___VDInternal_h
23#include <VBox/vd.h>
24#include <VBox/vd-plugin.h>
25
26#include <iprt/avl.h>
27#include <iprt/list.h>
28#include <iprt/memcache.h>
29
30/** Disable dynamic backends on non x86 architectures. This feature
31 * requires the SUPR3 library which is not available there.
32 */
33#if !defined(VBOX_HDD_NO_DYNAMIC_BACKENDS) && !defined(RT_ARCH_X86) && !defined(RT_ARCH_AMD64)
34# define VBOX_HDD_NO_DYNAMIC_BACKENDS
35#endif
36
37/** Magic number contained in the VDISK instance data, used for checking that the passed
38 * pointer contains a valid instance in debug builds. */
39#define VDISK_SIGNATURE 0x6f0e2a7d
40
41/**
42 * Structure containing everything I/O related
43 * for the image and cache descriptors.
44 */
45typedef struct VDIO
46{
47 /** I/O interface to the upper layer. */
48 PVDINTERFACEIO pInterfaceIo;
49
50 /** Per image internal I/O interface. */
51 VDINTERFACEIOINT VDIfIoInt;
52
53 /** Fallback I/O interface, only used if the caller doesn't provide it. */
54 VDINTERFACEIO VDIfIo;
55
56 /** Opaque backend data. */
57 void *pBackendData;
58 /** Disk this image is part of */
59 PVDISK pDisk;
60 /** Flag whether to ignore flush requests. */
61 bool fIgnoreFlush;
62} VDIO, *PVDIO;
63
64/** Forward declaration of an I/O task */
65typedef struct VDIOTASK *PVDIOTASK;
66
67/**
68 * Virtual disk container image descriptor.
69 */
70typedef struct VDIMAGE
71{
72 /** Link to parent image descriptor, if any. */
73 struct VDIMAGE *pPrev;
74 /** Link to child image descriptor, if any. */
75 struct VDIMAGE *pNext;
76 /** Container base filename. (UTF-8) */
77 char *pszFilename;
78 /** Data managed by the backend which keeps the actual info. */
79 void *pBackendData;
80 /** Cached sanitized image flags. */
81 unsigned uImageFlags;
82 /** Image open flags (only those handled generically in this code and which
83 * the backends will never ever see). */
84 unsigned uOpenFlags;
85
86 /** Function pointers for the various backend methods. */
87 PCVDIMAGEBACKEND Backend;
88 /** Pointer to list of VD interfaces, per-image. */
89 PVDINTERFACE pVDIfsImage;
90 /** I/O related things. */
91 VDIO VDIo;
92} VDIMAGE, *PVDIMAGE;
93
94/**
95 * Virtual disk cache image descriptor.
96 */
97typedef struct VDCACHE
98{
99 /** Cache base filename. (UTF-8) */
100 char *pszFilename;
101 /** Data managed by the backend which keeps the actual info. */
102 void *pBackendData;
103 /** Cached sanitized image flags. */
104 unsigned uImageFlags;
105 /** Image open flags (only those handled generically in this code and which
106 * the backends will never ever see). */
107 unsigned uOpenFlags;
108
109 /** Function pointers for the various backend methods. */
110 PCVDCACHEBACKEND Backend;
111
112 /** Pointer to list of VD interfaces, per-cache. */
113 PVDINTERFACE pVDIfsCache;
114 /** I/O related things. */
115 VDIO VDIo;
116} VDCACHE, *PVDCACHE;
117
118/**
119 * A block waiting for a discard.
120 */
121typedef struct VDDISCARDBLOCK
122{
123 /** AVL core. */
124 AVLRU64NODECORE Core;
125 /** LRU list node. */
126 RTLISTNODE NodeLru;
127 /** Number of bytes to discard. */
128 size_t cbDiscard;
129 /** Bitmap of allocated sectors. */
130 void *pbmAllocated;
131} VDDISCARDBLOCK, *PVDDISCARDBLOCK;
132
133/**
134 * VD discard state.
135 */
136typedef struct VDDISCARDSTATE
137{
138 /** Number of bytes waiting for a discard. */
139 size_t cbDiscarding;
140 /** AVL tree with blocks waiting for a discard.
141 * The uOffset + cbDiscard range is the search key. */
142 PAVLRU64TREE pTreeBlocks;
143 /** LRU list of the least frequently discarded blocks.
144 * If there are to many blocks waiting the least frequently used
145 * will be removed and the range will be set to 0.
146 */
147 RTLISTNODE ListLru;
148} VDDISCARDSTATE, *PVDDISCARDSTATE;
149
150/**
151 * VD filter instance.
152 */
153typedef struct VDFILTER
154{
155 /** List node for the read filter chain. */
156 RTLISTNODE ListNodeChainRead;
157 /** List node for the write filter chain. */
158 RTLISTNODE ListNodeChainWrite;
159 /** Number of references to this filter. */
160 uint32_t cRefs;
161 /** Opaque VD filter backend instance data. */
162 void *pvBackendData;
163 /** Pointer to the filter backend interface. */
164 PCVDFILTERBACKEND pBackend;
165 /** Pointer to list of VD interfaces, per-filter. */
166 PVDINTERFACE pVDIfsFilter;
167 /** I/O related things. */
168 VDIO VDIo;
169} VDFILTER;
170/** Pointer to a VD filter instance. */
171typedef VDFILTER *PVDFILTER;
172
173/**
174 * Virtual disk container main structure, private part.
175 */
176struct VDISK
177{
178 /** Structure signature (VDISK_SIGNATURE). */
179 uint32_t u32Signature;
180
181 /** Image type. */
182 VDTYPE enmType;
183
184 /** Number of opened images. */
185 unsigned cImages;
186
187 /** Base image. */
188 PVDIMAGE pBase;
189
190 /** Last opened image in the chain.
191 * The same as pBase if only one image is used. */
192 PVDIMAGE pLast;
193
194 /** If a merge to one of the parents is running this may be non-NULL
195 * to indicate to what image the writes should be additionally relayed. */
196 PVDIMAGE pImageRelay;
197
198 /** Flags representing the modification state. */
199 unsigned uModified;
200
201 /** Cached size of this disk. */
202 uint64_t cbSize;
203 /** Cached PCHS geometry for this disk. */
204 VDGEOMETRY PCHSGeometry;
205 /** Cached LCHS geometry for this disk. */
206 VDGEOMETRY LCHSGeometry;
207
208 /** Pointer to list of VD interfaces, per-disk. */
209 PVDINTERFACE pVDIfsDisk;
210 /** Pointer to the common interface structure for error reporting. */
211 PVDINTERFACEERROR pInterfaceError;
212 /** Pointer to the optional thread synchronization callbacks. */
213 PVDINTERFACETHREADSYNC pInterfaceThreadSync;
214
215 /** Memory cache for I/O contexts */
216 RTMEMCACHE hMemCacheIoCtx;
217 /** Memory cache for I/O tasks. */
218 RTMEMCACHE hMemCacheIoTask;
219 /** An I/O context is currently using the disk structures
220 * Every I/O context must be placed on one of the lists below. */
221 volatile bool fLocked;
222 /** Head of pending I/O tasks waiting for completion - LIFO order. */
223 volatile PVDIOTASK pIoTasksPendingHead;
224 /** Head of newly queued I/O contexts - LIFO order. */
225 volatile PVDIOCTX pIoCtxHead;
226 /** Head of halted I/O contexts which are given back to generic
227 * disk framework by the backend. - LIFO order. */
228 volatile PVDIOCTX pIoCtxHaltedHead;
229
230 /** Head of blocked I/O contexts, processed only
231 * after pIoCtxLockOwner was freed - LIFO order. */
232 volatile PVDIOCTX pIoCtxBlockedHead;
233 /** I/O context which locked the disk for a growing write or flush request.
234 * Other flush or growing write requests need to wait until
235 * the current one completes. - NIL_VDIOCTX if unlocked. */
236 volatile PVDIOCTX pIoCtxLockOwner;
237 /** If the disk was locked by a growing write, flush or discard request this
238 * contains the start offset to check for interfering I/O while it is in progress. */
239 uint64_t uOffsetStartLocked;
240 /** If the disk was locked by a growing write, flush or discard request this contains
241 * the first non affected offset to check for interfering I/O while it is in progress. */
242 uint64_t uOffsetEndLocked;
243
244 /** Pointer to the L2 disk cache if any. */
245 PVDCACHE pCache;
246 /** Pointer to the discard state if any. */
247 PVDDISCARDSTATE pDiscard;
248
249 /** Read filter chain - PVDFILTER. */
250 RTLISTANCHOR ListFilterChainRead;
251 /** Write filter chain - PVDFILTER. */
252 RTLISTANCHOR ListFilterChainWrite;
253};
254
255
256DECLHIDDEN(int) vdPluginInit(void);
257DECLHIDDEN(int) vdPluginTerm(void);
258DECLHIDDEN(bool) vdPluginIsInitialized(void);
259DECLHIDDEN(int) vdPluginUnloadFromPath(const char *pszPath);
260DECLHIDDEN(int) vdPluginUnloadFromFilename(const char *pszFilename);
261DECLHIDDEN(int) vdPluginLoadFromPath(const char *pszPath);
262DECLHIDDEN(int) vdPluginLoadFromFilename(const char *pszFilename);
263
264DECLHIDDEN(uint32_t) vdGetImageBackendCount(void);
265DECLHIDDEN(int) vdQueryImageBackend(uint32_t idx, PCVDIMAGEBACKEND *ppBackend);
266DECLHIDDEN(int) vdFindImageBackend(const char *pszBackend, PCVDIMAGEBACKEND *ppBackend);
267DECLHIDDEN(uint32_t) vdGetCacheBackendCount(void);
268DECLHIDDEN(int) vdQueryCacheBackend(uint32_t idx, PCVDCACHEBACKEND *ppBackend);
269DECLHIDDEN(int) vdFindCacheBackend(const char *pszBackend, PCVDCACHEBACKEND *ppBackend);
270DECLHIDDEN(uint32_t) vdGetFilterBackendCount(void);
271DECLHIDDEN(int) vdQueryFilterBackend(uint32_t idx, PCVDFILTERBACKEND *ppBackend);
272DECLHIDDEN(int) vdFindFilterBackend(const char *pszFilter, PCVDFILTERBACKEND *ppBackend);
273
274DECLHIDDEN(int) vdIoIterQueryStartNext(VDIOITER hVdIoIter, uint64_t *pu64Start);
275DECLHIDDEN(int) vdIoIterQuerySegSizeByStart(VDIOITER hVdIoIter, uint64_t u64Start, size_t *pcRegSize);
276DECLHIDDEN(int) vdIoIterAdvance(VDIOITER hVdIoIter, uint64_t cBlocksOrBytes);
277
278#endif /* !___VDInternal_h */
279
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use