VirtualBox

source: vbox/trunk/src/VBox/Storage/VDIfVfs2.cpp@ 91521

Last change on this file since 91521 was 83043, checked in by vboxsync, 5 years ago

Storage/VDIfVfs2.cpp: Plug small memory leak
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.2 KB
Line 
1/* $Id: VDIfVfs2.cpp 83043 2020-02-10 18:11:54Z 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-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
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 */
46typedef 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. */
67typedef struct VDIFFROMVFS *PVDIFFROMVFS;
68
69
70typedef 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} */
106static 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} */
115static 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} */
124static 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} */
133static 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} */
142static 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} */
152static 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} */
162static 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} */
174static 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} */
205static 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} */
220static 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} */
235static 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} */
250static 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
264VBOXDDU_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
318VBOXDDU_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
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