1 | /* $Id: VDIfVfs2.cpp 93115 2022-01-01 11:31:46Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Virtual Disk Image (VDI), I/O interface to IPRT VFS I/O stream glue.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2012-2022 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 |
|
---|
18 |
|
---|
19 | /*********************************************************************************************************************************
|
---|
20 | * Header Files *
|
---|
21 | *********************************************************************************************************************************/
|
---|
22 | #include <iprt/types.h>
|
---|
23 | #include <iprt/assert.h>
|
---|
24 | #include <iprt/mem.h>
|
---|
25 | #include <iprt/err.h>
|
---|
26 | #include <iprt/asm.h>
|
---|
27 | #include <iprt/string.h>
|
---|
28 | #include <iprt/file.h>
|
---|
29 | #include <iprt/sg.h>
|
---|
30 | #include <iprt/vfslowlevel.h>
|
---|
31 | #include <iprt/poll.h>
|
---|
32 | #include <VBox/vd.h>
|
---|
33 | #include <VBox/vd-ifs-internal.h>
|
---|
34 |
|
---|
35 | #include <VBox/log.h>
|
---|
36 |
|
---|
37 |
|
---|
38 | /*********************************************************************************************************************************
|
---|
39 | * Structures and Typedefs *
|
---|
40 | *********************************************************************************************************************************/
|
---|
41 | /**
|
---|
42 | * Extended VD I/O interface structure that vdIfFromVfs_xxx uses.
|
---|
43 | *
|
---|
44 | * It's passed as pvUser to each call.
|
---|
45 | */
|
---|
46 | typedef struct VDIFFROMVFS
|
---|
47 | {
|
---|
48 | VDINTERFACEIO CoreIo;
|
---|
49 |
|
---|
50 | /** Magic. */
|
---|
51 | uint32_t u32Magic;
|
---|
52 | /** The stream access mode (RTFILE_O_ACCESS_MASK), possibly others. */
|
---|
53 | uint32_t fAccessMode;
|
---|
54 | /** The I/O stream. This is NIL after it's been closed. */
|
---|
55 | RTVFSIOSTREAM hVfsIos;
|
---|
56 | /** Completion callback. */
|
---|
57 | PFNVDCOMPLETED pfnCompleted;
|
---|
58 | /** User parameter for the completion callback. */
|
---|
59 | void *pvCompletedUser;
|
---|
60 | /** Set if hVfsIos has been opened. */
|
---|
61 | bool fOpened;
|
---|
62 | } VDIFFROMVFS;
|
---|
63 | /** Magic value for VDIFFROMVFS::u32Magic. */
|
---|
64 | #define VDIFFROMVFS_MAGIC UINT32_C(0x11223344)
|
---|
65 |
|
---|
66 | /** Pointer to the instance data for the vdIfFromVfs_ methods. */
|
---|
67 | typedef struct VDIFFROMVFS *PVDIFFROMVFS;
|
---|
68 |
|
---|
69 |
|
---|
70 | typedef struct FILESTORAGEINTERNAL
|
---|
71 | {
|
---|
72 | /** File handle. */
|
---|
73 | RTFILE file;
|
---|
74 | } FILESTORAGEINTERNAL, *PFILESTORAGEINTERNAL;
|
---|
75 |
|
---|
76 |
|
---|
77 | /*********************************************************************************************************************************
|
---|
78 | * Defined Constants And Macros *
|
---|
79 | *********************************************************************************************************************************/
|
---|
80 |
|
---|
81 | #define STATUS_WAIT UINT32_C(0)
|
---|
82 | #define STATUS_WRITE UINT32_C(1)
|
---|
83 | #define STATUS_WRITING UINT32_C(2)
|
---|
84 | #define STATUS_READ UINT32_C(3)
|
---|
85 | #define STATUS_READING UINT32_C(4)
|
---|
86 | #define STATUS_END UINT32_C(5)
|
---|
87 |
|
---|
88 | /* Enable for getting some flow history. */
|
---|
89 | #if 0
|
---|
90 | # define DEBUG_PRINT_FLOW() RTPrintf("%s\n", __FUNCTION__)
|
---|
91 | #else
|
---|
92 | # define DEBUG_PRINT_FLOW() do {} while (0)
|
---|
93 | #endif
|
---|
94 |
|
---|
95 |
|
---|
96 | /*********************************************************************************************************************************
|
---|
97 | * Internal Functions *
|
---|
98 | *********************************************************************************************************************************/
|
---|
99 |
|
---|
100 |
|
---|
101 | /** @name VDINTERFACEIO stubs returning not-implemented.
|
---|
102 | * @{
|
---|
103 | */
|
---|
104 |
|
---|
105 | /** @interface_method_impl{VDINTERFACEIO,pfnDelete} */
|
---|
106 | static DECLCALLBACK(int) notImpl_Delete(void *pvUser, const char *pcszFilename)
|
---|
107 | {
|
---|
108 | NOREF(pvUser); NOREF(pcszFilename);
|
---|
109 | Log(("%s\n", __FUNCTION__));
|
---|
110 | AssertFailed();
|
---|
111 | return VERR_NOT_IMPLEMENTED;
|
---|
112 | }
|
---|
113 |
|
---|
114 | /** @interface_method_impl{VDINTERFACEIO,pfnMove} */
|
---|
115 | static DECLCALLBACK(int) notImpl_Move(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
|
---|
116 | {
|
---|
117 | NOREF(pvUser); NOREF(pcszSrc); NOREF(pcszDst); NOREF(fMove);
|
---|
118 | Log(("%s\n", __FUNCTION__));
|
---|
119 | AssertFailed();
|
---|
120 | return VERR_NOT_IMPLEMENTED;
|
---|
121 | }
|
---|
122 |
|
---|
123 | /** @interface_method_impl{VDINTERFACEIO,pfnGetFreeSpace} */
|
---|
124 | static DECLCALLBACK(int) notImpl_GetFreeSpace(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
|
---|
125 | {
|
---|
126 | NOREF(pvUser); NOREF(pcszFilename); NOREF(pcbFreeSpace);
|
---|
127 | Log(("%s\n", __FUNCTION__));
|
---|
128 | AssertFailed();
|
---|
129 | return VERR_NOT_IMPLEMENTED;
|
---|
130 | }
|
---|
131 |
|
---|
132 | /** @interface_method_impl{VDINTERFACEIO,pfnGetModificationTime} */
|
---|
133 | static DECLCALLBACK(int) notImpl_GetModificationTime(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
|
---|
134 | {
|
---|
135 | NOREF(pvUser); NOREF(pcszFilename); NOREF(pModificationTime);
|
---|
136 | Log(("%s\n", __FUNCTION__));
|
---|
137 | AssertFailed();
|
---|
138 | return VERR_NOT_IMPLEMENTED;
|
---|
139 | }
|
---|
140 |
|
---|
141 | /** @interface_method_impl{VDINTERFACEIO,pfnSetSize} */
|
---|
142 | static DECLCALLBACK(int) notImpl_SetSize(void *pvUser, void *pvStorage, uint64_t cb)
|
---|
143 | {
|
---|
144 | NOREF(pvUser); NOREF(pvStorage); NOREF(cb);
|
---|
145 | Log(("%s\n", __FUNCTION__));
|
---|
146 | AssertFailed();
|
---|
147 | return VERR_NOT_IMPLEMENTED;
|
---|
148 | }
|
---|
149 |
|
---|
150 | #if 0 /* unused */
|
---|
151 | /** @interface_method_impl{VDINTERFACEIO,pfnWriteSync} */
|
---|
152 | static DECLCALLBACK(int) notImpl_WriteSync(void *pvUser, void *pvStorage, uint64_t off, const void *pvBuf,
|
---|
153 | size_t cbWrite, size_t *pcbWritten)
|
---|
154 | {
|
---|
155 | RT_NOREF6(pvUser, pvStorage, off, pvBuf, cbWrite, pcbWritten)
|
---|
156 | Log(("%s\n", __FUNCTION__));
|
---|
157 | return VERR_NOT_IMPLEMENTED;
|
---|
158 | }
|
---|
159 | #endif
|
---|
160 |
|
---|
161 | /** @interface_method_impl{VDINTERFACEIO,pfnFlushSync} */
|
---|
162 | static DECLCALLBACK(int) notImpl_FlushSync(void *pvUser, void *pvStorage)
|
---|
163 | {
|
---|
164 | NOREF(pvUser); NOREF(pvStorage);
|
---|
165 | Log(("%s\n", __FUNCTION__));
|
---|
166 | AssertFailed();
|
---|
167 | return VERR_NOT_IMPLEMENTED;
|
---|
168 | }
|
---|
169 |
|
---|
170 | /** @} */
|
---|
171 |
|
---|
172 |
|
---|
173 | /** @interface_method_impl{VDINTERFACEIO,pfnOpen} */
|
---|
174 | static DECLCALLBACK(int) vdIfFromVfs_Open(void *pvUser, const char *pszLocation, uint32_t fOpen,
|
---|
175 | PFNVDCOMPLETED pfnCompleted, void **ppvStorage)
|
---|
176 | {
|
---|
177 | RT_NOREF1(pszLocation);
|
---|
178 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pvUser;
|
---|
179 |
|
---|
180 | /*
|
---|
181 | * Validate input.
|
---|
182 | */
|
---|
183 | AssertPtrReturn(ppvStorage, VERR_INVALID_POINTER);
|
---|
184 | AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
|
---|
185 |
|
---|
186 | /*
|
---|
187 | * We ignore the name, assuming the caller is opening the stream/file we're .
|
---|
188 | * serving. Thus, after close, all open calls fail.
|
---|
189 | */
|
---|
190 | AssertReturn(!pThis->fOpened, VERR_FILE_NOT_FOUND);
|
---|
191 | AssertReturn(pThis->hVfsIos != NIL_RTVFSIOSTREAM, VERR_FILE_NOT_FOUND); /* paranoia */
|
---|
192 | AssertMsgReturn((pThis->fAccessMode & fOpen & RTFILE_O_ACCESS_MASK) == (fOpen & RTFILE_O_ACCESS_MASK),
|
---|
193 | ("fAccessMode=%#x fOpen=%#x\n", pThis->fAccessMode, fOpen), VERR_ACCESS_DENIED);
|
---|
194 |
|
---|
195 | pThis->fAccessMode = fOpen & RTFILE_O_ACCESS_MASK;
|
---|
196 | pThis->fOpened = true;
|
---|
197 | pThis->pfnCompleted = pfnCompleted;
|
---|
198 | pThis->pvCompletedUser = pvUser;
|
---|
199 |
|
---|
200 | *ppvStorage = pThis->hVfsIos;
|
---|
201 | return VINF_SUCCESS;
|
---|
202 | }
|
---|
203 |
|
---|
204 | /** @interface_method_impl{VDINTERFACEIO,pfnClose} */
|
---|
205 | static DECLCALLBACK(int) vdIfFromVfs_Close(void *pvUser, void *pvStorage)
|
---|
206 | {
|
---|
207 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pvUser;
|
---|
208 | AssertPtrReturn(pThis, VERR_INVALID_POINTER);
|
---|
209 | AssertReturn(pThis->hVfsIos == (RTVFSIOSTREAM)pvStorage, VERR_INVALID_HANDLE);
|
---|
210 | AssertReturn(pThis->fOpened, VERR_INVALID_HANDLE);
|
---|
211 |
|
---|
212 | RTVfsIoStrmRelease(pThis->hVfsIos);
|
---|
213 | pThis->hVfsIos = NIL_RTVFSIOSTREAM;
|
---|
214 |
|
---|
215 | return VINF_SUCCESS;
|
---|
216 | }
|
---|
217 |
|
---|
218 |
|
---|
219 | /** @interface_method_impl{VDINTERFACEIO,pfnGetSize} */
|
---|
220 | static DECLCALLBACK(int) vdIfFromVfs_GetSize(void *pvUser, void *pvStorage, uint64_t *pcb)
|
---|
221 | {
|
---|
222 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pvUser;
|
---|
223 | AssertPtrReturn(pThis, VERR_INVALID_POINTER);
|
---|
224 | AssertReturn(pThis->hVfsIos == (RTVFSIOSTREAM)pvStorage, VERR_INVALID_HANDLE);
|
---|
225 | AssertReturn(pThis->fOpened, VERR_INVALID_HANDLE);
|
---|
226 |
|
---|
227 | RTFSOBJINFO ObjInfo;
|
---|
228 | int rc = RTVfsIoStrmQueryInfo(pThis->hVfsIos, &ObjInfo, RTFSOBJATTRADD_NOTHING);
|
---|
229 | if (RT_SUCCESS(rc))
|
---|
230 | *pcb = ObjInfo.cbObject;
|
---|
231 | return rc;
|
---|
232 | }
|
---|
233 |
|
---|
234 | /** @interface_method_impl{VDINTERFACEIO,pfnReadSync} */
|
---|
235 | static DECLCALLBACK(int) vdIfFromVfs_ReadSync(void *pvUser, void *pvStorage, uint64_t off, void *pvBuf,
|
---|
236 | size_t cbToRead, size_t *pcbRead)
|
---|
237 | {
|
---|
238 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pvUser;
|
---|
239 | AssertPtrReturn(pThis, VERR_INVALID_POINTER);
|
---|
240 | AssertReturn(pThis->hVfsIos == (RTVFSIOSTREAM)pvStorage, VERR_INVALID_HANDLE);
|
---|
241 | AssertReturn(pThis->fOpened, VERR_INVALID_HANDLE);
|
---|
242 | AssertPtrNullReturn(pcbRead, VERR_INVALID_POINTER);
|
---|
243 | AssertReturn(pThis->fAccessMode & RTFILE_O_READ, VERR_ACCESS_DENIED);
|
---|
244 |
|
---|
245 | return RTVfsIoStrmReadAt(pThis->hVfsIos, off, pvBuf, cbToRead, true /*fBlocking*/, pcbRead);
|
---|
246 | }
|
---|
247 |
|
---|
248 |
|
---|
249 | /** @interface_method_impl{VDINTERFACEIO,pfnWriteSync} */
|
---|
250 | static DECLCALLBACK(int) vdIfFromVfs_WriteSync(void *pvUser, void *pvStorage, uint64_t off, void const *pvBuf,
|
---|
251 | size_t cbToWrite, size_t *pcbWritten)
|
---|
252 | {
|
---|
253 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pvUser;
|
---|
254 | AssertPtrReturn(pThis, VERR_INVALID_POINTER);
|
---|
255 | AssertReturn(pThis->hVfsIos == (RTVFSIOSTREAM)pvStorage, VERR_INVALID_HANDLE);
|
---|
256 | AssertReturn(pThis->fOpened, VERR_INVALID_HANDLE);
|
---|
257 | AssertPtrNullReturn(pcbWritten, VERR_INVALID_POINTER);
|
---|
258 | AssertReturn(pThis->fAccessMode & RTFILE_O_WRITE, VERR_ACCESS_DENIED);
|
---|
259 |
|
---|
260 | return RTVfsIoStrmWriteAt(pThis->hVfsIos, off, pvBuf, cbToWrite, true /*fBlocking*/, pcbWritten);
|
---|
261 | }
|
---|
262 |
|
---|
263 |
|
---|
264 | VBOXDDU_DECL(int) VDIfCreateFromVfsStream(RTVFSIOSTREAM hVfsIos, uint32_t fAccessMode, PVDINTERFACEIO *ppIoIf)
|
---|
265 | {
|
---|
266 | /*
|
---|
267 | * Validate input.
|
---|
268 | */
|
---|
269 | AssertPtrReturn(ppIoIf, VERR_INVALID_POINTER);
|
---|
270 | *ppIoIf = NULL;
|
---|
271 | AssertReturn(hVfsIos != NIL_RTVFSIOSTREAM, VERR_INVALID_HANDLE);
|
---|
272 | AssertReturn(fAccessMode & RTFILE_O_ACCESS_MASK, VERR_INVALID_FLAGS);
|
---|
273 |
|
---|
274 | uint32_t cRefs = RTVfsIoStrmRetain(hVfsIos);
|
---|
275 | AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
|
---|
276 |
|
---|
277 | /*
|
---|
278 | * Allocate and init a callback + instance data structure.
|
---|
279 | */
|
---|
280 | int rc;
|
---|
281 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)RTMemAllocZ(sizeof(*pThis));
|
---|
282 | if (pThis)
|
---|
283 | {
|
---|
284 | pThis->CoreIo.pfnOpen = vdIfFromVfs_Open;
|
---|
285 | pThis->CoreIo.pfnClose = vdIfFromVfs_Close;
|
---|
286 | pThis->CoreIo.pfnDelete = notImpl_Delete;
|
---|
287 | pThis->CoreIo.pfnMove = notImpl_Move;
|
---|
288 | pThis->CoreIo.pfnGetFreeSpace = notImpl_GetFreeSpace;
|
---|
289 | pThis->CoreIo.pfnGetModificationTime = notImpl_GetModificationTime;
|
---|
290 | pThis->CoreIo.pfnGetSize = vdIfFromVfs_GetSize;
|
---|
291 | pThis->CoreIo.pfnSetSize = notImpl_SetSize;
|
---|
292 | pThis->CoreIo.pfnReadSync = vdIfFromVfs_ReadSync;
|
---|
293 | pThis->CoreIo.pfnWriteSync = vdIfFromVfs_WriteSync;
|
---|
294 | pThis->CoreIo.pfnFlushSync = notImpl_FlushSync;
|
---|
295 |
|
---|
296 | pThis->hVfsIos = hVfsIos;
|
---|
297 | pThis->fAccessMode = fAccessMode;
|
---|
298 | pThis->fOpened = false;
|
---|
299 | pThis->u32Magic = VDIFFROMVFS_MAGIC;
|
---|
300 |
|
---|
301 | PVDINTERFACE pFakeList = NULL;
|
---|
302 | rc = VDInterfaceAdd(&pThis->CoreIo.Core, "FromVfsStream", VDINTERFACETYPE_IO, pThis, sizeof(pThis->CoreIo), &pFakeList);
|
---|
303 | if (RT_SUCCESS(rc))
|
---|
304 | {
|
---|
305 | *ppIoIf = &pThis->CoreIo;
|
---|
306 | return VINF_SUCCESS;
|
---|
307 | }
|
---|
308 |
|
---|
309 | RTMemFree(pThis);
|
---|
310 | }
|
---|
311 | else
|
---|
312 | rc = VERR_NO_MEMORY;
|
---|
313 | RTVfsIoStrmRelease(hVfsIos);
|
---|
314 | return rc;
|
---|
315 | }
|
---|
316 |
|
---|
317 |
|
---|
318 | VBOXDDU_DECL(int) VDIfDestroyFromVfsStream(PVDINTERFACEIO pIoIf)
|
---|
319 | {
|
---|
320 | if (pIoIf)
|
---|
321 | {
|
---|
322 | PVDIFFROMVFS pThis = (PVDIFFROMVFS)pIoIf;
|
---|
323 | AssertPtrReturn(pThis, VERR_INVALID_POINTER);
|
---|
324 | AssertReturn(pThis->u32Magic == VDIFFROMVFS_MAGIC, VERR_INVALID_MAGIC);
|
---|
325 |
|
---|
326 | if (pThis->hVfsIos != NIL_RTVFSIOSTREAM)
|
---|
327 | {
|
---|
328 | RTVfsIoStrmRelease(pThis->hVfsIos);
|
---|
329 | pThis->hVfsIos = NIL_RTVFSIOSTREAM;
|
---|
330 | }
|
---|
331 | pThis->u32Magic = ~VDIFFROMVFS_MAGIC;
|
---|
332 | RTMemFree(pThis);
|
---|
333 | }
|
---|
334 | return VINF_SUCCESS;
|
---|
335 | }
|
---|
336 |
|
---|