VirtualBox

source: vbox/trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp@ 33000

Last change on this file since 33000 was 32553, checked in by vboxsync, 14 years ago

VBoxHDD: More cleanup

  • The I/O interface between the generic layer and the backend is private because it includes operations for various async I/O tasks the user of VBoxHDD doesn't know about. Renamed it to make clear that it is internal and make the old async I/O interface the one which can be used for the VFS layer from the outside.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 46.1 KB
Line 
1/* $Id: ParallelsHDDCore.cpp 32553 2010-09-16 12:07:01Z vboxsync $ */
2/** @file
3 *
4 * Parallels hdd disk image, core code.
5 */
6
7/*
8 * Copyright (C) 2006-2010 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#define LOG_GROUP LOG_GROUP_VD_PARALLELS
20#include <VBox/VBoxHDD-Plugin.h>
21#include <VBox/err.h>
22
23#include <VBox/log.h>
24#include <iprt/assert.h>
25#include <iprt/mem.h>
26#include <iprt/uuid.h>
27#include <iprt/path.h>
28#include <iprt/string.h>
29
30#define PARALLELS_HEADER_MAGIC "WithoutFreeSpace"
31#define PARALLELS_DISK_VERSION 2
32
33/** The header of the parallels disk. */
34#pragma pack(1)
35typedef struct ParallelsHeader
36{
37 /** The magic header to identify a parallels hdd image. */
38 char HeaderIdentifier[16];
39 /** The version of the disk image. */
40 uint32_t uVersion;
41 /** The number of heads the hdd has. */
42 uint32_t cHeads;
43 /** Number of cylinders. */
44 uint32_t cCylinders;
45 /** Number of sectors per track. */
46 uint32_t cSectorsPerTrack;
47 /** Number of entries in the allocation bitmap. */
48 uint32_t cEntriesInAllocationBitmap;
49 /** Total number of sectors. */
50 uint32_t cSectors;
51 /** Padding. */
52 char Padding[24];
53} ParallelsHeader;
54#pragma pack()
55
56/**
57 * Parallels image structure.
58 */
59typedef struct PARALLELSIMAGE
60{
61 /** Image file name. */
62 const char *pszFilename;
63 /** Opaque storage handle. */
64 PVDIOSTORAGE pStorage;
65
66 /** I/O interface. */
67 PVDINTERFACE pInterfaceIO;
68 /** I/O interface callbacks. */
69 PVDINTERFACEIOINT pInterfaceIOCallbacks;
70
71 /** Pointer to the per-disk VD interface list. */
72 PVDINTERFACE pVDIfsDisk;
73 /** Pointer to the per-image VD interface list. */
74 PVDINTERFACE pVDIfsImage;
75 /** Error interface. */
76 PVDINTERFACE pInterfaceError;
77 /** Error interface callbacks. */
78 PVDINTERFACEERROR pInterfaceErrorCallbacks;
79
80 /** Open flags passed by VBoxHDD layer. */
81 unsigned uOpenFlags;
82 /** Image flags defined during creation or determined during open. */
83 unsigned uImageFlags;
84 /** Total size of the image. */
85 uint64_t cbSize;
86
87 /** Physical geometry of this image. */
88 VDGEOMETRY PCHSGeometry;
89 /** Logical geometry of this image. */
90 VDGEOMETRY LCHSGeometry;
91
92 /** Pointer to the allocation bitmap. */
93 uint32_t *pAllocationBitmap;
94 /** Entries in the allocation bitmap. */
95 uint64_t cAllocationBitmapEntries;
96 /** Flag whether the allocation bitmap was changed. */
97 bool fAllocationBitmapChanged;
98 /** Current file size. */
99 uint64_t cbFileCurrent;
100} PARALLELSIMAGE, *PPARALLELSIMAGE;
101
102/*******************************************************************************
103* Static Variables *
104*******************************************************************************/
105
106/** NULL-terminated array of supported file extensions. */
107static const char *const s_apszParallelsFileExtensions[] =
108{
109 "hdd",
110 NULL
111};
112
113/***************************************************
114 * Internal functions *
115 **************************************************/
116
117/**
118 * Internal: signal an error to the frontend.
119 */
120DECLINLINE(int) parallelsError(PPARALLELSIMAGE pImage, int rc, RT_SRC_POS_DECL,
121 const char *pszFormat, ...)
122{
123 va_list va;
124 va_start(va, pszFormat);
125 if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
126 pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS,
127 pszFormat, va);
128 va_end(va);
129 return rc;
130}
131
132/**
133 * Internal: signal an informational message to the frontend.
134 */
135DECLINLINE(int) parallelsMessage(PPARALLELSIMAGE pImage, const char *pszFormat, ...)
136{
137 int rc = VINF_SUCCESS;
138 va_list va;
139 va_start(va, pszFormat);
140 if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
141 rc = pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser,
142 pszFormat, va);
143 va_end(va);
144 return rc;
145}
146
147
148DECLINLINE(int) parallelsFileOpen(PPARALLELSIMAGE pImage, const char *pszFilename,
149 uint32_t fOpen)
150{
151 return pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
152 pszFilename, fOpen,
153 &pImage->pStorage);
154}
155
156DECLINLINE(int) parallelsFileClose(PPARALLELSIMAGE pImage)
157{
158 return pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
159 pImage->pStorage);
160}
161
162DECLINLINE(int) parallelsFileDelete(PPARALLELSIMAGE pImage, const char *pszFilename)
163{
164 return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
165 pszFilename);
166}
167
168DECLINLINE(int) parallelsFileMove(PPARALLELSIMAGE pImage, const char *pszSrc,
169 const char *pszDst, unsigned fMove)
170{
171 return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
172 pszSrc, pszDst, fMove);
173}
174
175DECLINLINE(int) parallelsFileGetSize(PPARALLELSIMAGE pImage, uint64_t *pcbSize)
176{
177 return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
178 pImage->pStorage, pcbSize);
179}
180
181DECLINLINE(int) parallelsFileSetSize(PPARALLELSIMAGE pImage, uint64_t cbSize)
182{
183 return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
184 pImage->pStorage, cbSize);
185}
186
187DECLINLINE(int) parallelsFileWriteSync(PPARALLELSIMAGE pImage, uint64_t uOffset,
188 const void *pvBuffer, size_t cbBuffer,
189 size_t *pcbWritten)
190{
191 return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
192 pImage->pStorage, uOffset,
193 pvBuffer, cbBuffer, pcbWritten);
194}
195
196DECLINLINE(int) parallelsFileReadSync(PPARALLELSIMAGE pImage, uint64_t uOffset,
197 void *pvBuffer, size_t cbBuffer, size_t *pcbRead)
198{
199 return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
200 pImage->pStorage, uOffset,
201 pvBuffer, cbBuffer, pcbRead);
202}
203
204DECLINLINE(int) parallelsFileFlushSync(PPARALLELSIMAGE pImage)
205{
206 return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
207 pImage->pStorage);
208}
209
210DECLINLINE(int) parallelsFileReadUserAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
211 PVDIOCTX pIoCtx, size_t cbRead)
212{
213 return pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
214 pImage->pStorage,
215 uOffset, pIoCtx,
216 cbRead);
217}
218
219DECLINLINE(int) parallelsFileWriteUserAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
220 PVDIOCTX pIoCtx, size_t cbWrite,
221 PFNVDXFERCOMPLETED pfnComplete,
222 void *pvCompleteUser)
223{
224 return pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
225 pImage->pStorage,
226 uOffset, pIoCtx,
227 cbWrite,
228 pfnComplete,
229 pvCompleteUser);
230}
231
232DECLINLINE(int) parallelsFileWriteMetaAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
233 void *pvBuffer, size_t cbBuffer,
234 PVDIOCTX pIoCtx,
235 PFNVDXFERCOMPLETED pfnComplete,
236 void *pvCompleteUser)
237{
238 return pImage->pInterfaceIOCallbacks->pfnWriteMetaAsync(pImage->pInterfaceIO->pvUser,
239 pImage->pStorage,
240 uOffset, pvBuffer,
241 cbBuffer, pIoCtx,
242 pfnComplete,
243 pvCompleteUser);
244}
245
246DECLINLINE(int) parallelsFileFlushAsync(PPARALLELSIMAGE pImage, PVDIOCTX pIoCtx,
247 PFNVDXFERCOMPLETED pfnComplete,
248 void *pvCompleteUser)
249{
250 return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
251 pImage->pStorage,
252 pIoCtx, pfnComplete,
253 pvCompleteUser);
254}
255
256
257/**
258 * Internal. Flush image data to disk.
259 */
260static int parallelsFlushImage(PPARALLELSIMAGE pImage)
261{
262 int rc = VINF_SUCCESS;
263
264 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
265 return VINF_SUCCESS;
266
267 if ( !(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
268 && (pImage->fAllocationBitmapChanged))
269 {
270 pImage->fAllocationBitmapChanged = false;
271 /* Write the allocation bitmap to the file. */
272 rc = parallelsFileWriteSync(pImage, sizeof(ParallelsHeader),
273 pImage->pAllocationBitmap,
274 pImage->cAllocationBitmapEntries * sizeof(uint32_t),
275 NULL);
276 if (RT_FAILURE(rc))
277 return rc;
278 }
279
280 /* Flush file. */
281 rc = parallelsFileFlushSync(pImage);
282
283 LogFlowFunc(("returns %Rrc\n", rc));
284 return rc;
285}
286
287/**
288 * Internal. Free all allocated space for representing an image except pImage,
289 * and optionally delete the image from disk.
290 */
291static int parallelsFreeImage(PPARALLELSIMAGE pImage, bool fDelete)
292{
293 int rc = VINF_SUCCESS;
294
295 /* Freeing a never allocated image (e.g. because the open failed) is
296 * not signalled as an error. After all nothing bad happens. */
297 if (pImage)
298 {
299 if (pImage->pStorage)
300 {
301 /* No point updating the file that is deleted anyway. */
302 if (!fDelete)
303 parallelsFlushImage(pImage);
304
305 parallelsFileClose(pImage);
306 pImage->pStorage = NULL;
307 }
308
309 if (pImage->pAllocationBitmap)
310 {
311 RTMemFree(pImage->pAllocationBitmap);
312 pImage->pAllocationBitmap = NULL;
313 }
314
315 if (fDelete && pImage->pszFilename)
316 parallelsFileDelete(pImage, pImage->pszFilename);
317 }
318
319 return rc;
320}
321
322static int parallelsOpenImage(PPARALLELSIMAGE pImage, unsigned uOpenFlags)
323{
324 int rc = VINF_SUCCESS;
325 ParallelsHeader parallelsHeader;
326
327 /* Try to get error interface. */
328 pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
329 if (pImage->pInterfaceError)
330 pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
331
332 /* Get I/O interface. */
333 pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
334 AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
335 pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
336 AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
337
338 rc = parallelsFileOpen(pImage, pImage->pszFilename,
339 VDOpenFlagsToFileOpenFlags(uOpenFlags,
340 false /* fCreate */));
341 if (RT_FAILURE(rc))
342 goto out;
343
344 rc = parallelsFileGetSize(pImage, &pImage->cbFileCurrent);
345 if (RT_FAILURE(rc))
346 goto out;
347 AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
348
349 rc = parallelsFileReadSync(pImage, 0, &parallelsHeader, sizeof(parallelsHeader), NULL);
350 if (RT_FAILURE(rc))
351 goto out;
352
353 if (memcmp(parallelsHeader.HeaderIdentifier, PARALLELS_HEADER_MAGIC, 16))
354 {
355 /* Check if the file has hdd as extension. It is a fixed size raw image then. */
356 char *pszExtension = RTPathExt(pImage->pszFilename);
357 if (strcmp(pszExtension, ".hdd"))
358 {
359 rc = VERR_VD_PARALLELS_INVALID_HEADER;
360 goto out;
361 }
362
363 /* This is a fixed size image. */
364 pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED;
365 pImage->cbSize = pImage->cbFileCurrent;
366
367 pImage->PCHSGeometry.cHeads = 16;
368 pImage->PCHSGeometry.cSectors = 63;
369 uint64_t cCylinders = pImage->cbSize / (512 * pImage->PCHSGeometry.cSectors * pImage->PCHSGeometry.cHeads);
370 pImage->PCHSGeometry.cCylinders = (uint32_t)cCylinders;
371 }
372 else
373 {
374 if (parallelsHeader.uVersion != PARALLELS_DISK_VERSION)
375 {
376 rc = VERR_NOT_SUPPORTED;
377 goto out;
378 }
379
380 if (parallelsHeader.cEntriesInAllocationBitmap > (1 << 30))
381 {
382 rc = VERR_NOT_SUPPORTED;
383 goto out;
384 }
385
386 Log(("cSectors=%u\n", parallelsHeader.cSectors));
387 pImage->cbSize = ((uint64_t)parallelsHeader.cSectors) * 512;
388 pImage->uImageFlags = VD_IMAGE_FLAGS_NONE;
389 pImage->cAllocationBitmapEntries = parallelsHeader.cEntriesInAllocationBitmap;
390 pImage->pAllocationBitmap = (uint32_t *)RTMemAllocZ((uint32_t)pImage->cAllocationBitmapEntries * sizeof(uint32_t));
391 if (!pImage->pAllocationBitmap)
392 {
393 rc = VERR_NO_MEMORY;
394 goto out;
395 }
396
397 rc = parallelsFileReadSync(pImage, sizeof(ParallelsHeader),
398 pImage->pAllocationBitmap,
399 pImage->cAllocationBitmapEntries * sizeof(uint32_t),
400 NULL);
401 if (RT_FAILURE(rc))
402 goto out;
403
404 pImage->PCHSGeometry.cCylinders = parallelsHeader.cCylinders;
405 pImage->PCHSGeometry.cHeads = parallelsHeader.cHeads;
406 pImage->PCHSGeometry.cSectors = parallelsHeader.cSectorsPerTrack;
407 }
408
409out:
410 LogFlowFunc(("returns %Rrc\n", rc));
411 return rc;
412}
413
414
415/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
416static int parallelsCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
417 PVDINTERFACE pVDIfsImage)
418{
419 int rc;
420 PVDIOSTORAGE pStorage;
421 ParallelsHeader parallelsHeader;
422
423 /* Get I/O interface. */
424 PVDINTERFACE pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT);
425 AssertPtrReturn(pInterfaceIO, VERR_INVALID_PARAMETER);
426 PVDINTERFACEIOINT pInterfaceIOCallbacks = VDGetInterfaceIOInt(pInterfaceIO);
427 AssertPtrReturn(pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
428
429 rc = pInterfaceIOCallbacks->pfnOpen(pInterfaceIO->pvUser, pszFilename,
430 VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
431 false /* fCreate */),
432 &pStorage);
433 if (RT_FAILURE(rc))
434 return rc;
435
436 rc = pInterfaceIOCallbacks->pfnReadSync(pInterfaceIO->pvUser, pStorage,
437 0, &parallelsHeader,
438 sizeof(ParallelsHeader), NULL);
439 if (RT_SUCCESS(rc))
440 {
441 if ( !memcmp(parallelsHeader.HeaderIdentifier, PARALLELS_HEADER_MAGIC, 16)
442 && (parallelsHeader.uVersion == PARALLELS_DISK_VERSION))
443 rc = VINF_SUCCESS;
444 else
445 {
446 /*
447 * The image may be an fixed size image.
448 * Unfortunately fixed sized parallels images
449 * are just raw files hence no magic header to
450 * check for.
451 * The code succeeds if the file is a multiple
452 * of 512 and if the file extensions is *.hdd
453 */
454 uint64_t cbFile;
455 char *pszExtension;
456
457 rc = pInterfaceIOCallbacks->pfnGetSize(pInterfaceIO->pvUser, pStorage,
458 &cbFile);
459 if (RT_FAILURE(rc) || ((cbFile % 512) != 0))
460 {
461 pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
462 return VERR_VD_PARALLELS_INVALID_HEADER;
463 }
464
465 pszExtension = RTPathExt(pszFilename);
466 if (!pszExtension || strcmp(pszExtension, ".hdd"))
467 rc = VERR_VD_PARALLELS_INVALID_HEADER;
468 else
469 rc = VINF_SUCCESS;
470 }
471 }
472
473 pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
474 return rc;
475}
476
477/** @copydoc VBOXHDDBACKEND::pfnOpen */
478static int parallelsOpen(const char *pszFilename, unsigned uOpenFlags,
479 PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
480 void **ppBackendData)
481{
482 LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
483 int rc;
484 PPARALLELSIMAGE pImage;
485
486 /* Check open flags. All valid flags are supported. */
487 if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
488 {
489 rc = VERR_INVALID_PARAMETER;
490 goto out;
491 }
492
493 /* Check remaining arguments. */
494 if ( !VALID_PTR(pszFilename)
495 || !*pszFilename)
496 {
497 rc = VERR_INVALID_PARAMETER;
498 goto out;
499 }
500
501 /** @todo r=klaus why this duplicate check, async is not claimed... */
502 if (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
503 {
504 rc = VERR_NOT_SUPPORTED;
505 goto out;
506 }
507
508 pImage = (PPARALLELSIMAGE)RTMemAllocZ(sizeof(PARALLELSIMAGE));
509 if (!pImage)
510 {
511 rc = VERR_NO_MEMORY;
512 goto out;
513 }
514
515 pImage->pszFilename = pszFilename;
516 pImage->pStorage = NULL;
517 pImage->pVDIfsDisk = pVDIfsDisk;
518 pImage->pVDIfsImage = pVDIfsImage;
519 pImage->fAllocationBitmapChanged = false;
520
521 rc = parallelsOpenImage(pImage, uOpenFlags);
522 if (RT_SUCCESS(rc))
523 *ppBackendData = pImage;
524 else
525 RTMemFree(pImage);
526
527out:
528 LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
529 return rc;
530}
531
532/** @copydoc VBOXHDDBACKEND::pfnCreate */
533static int parallelsCreate(const char *pszFilename, uint64_t cbSize,
534 unsigned uImageFlags, const char *pszComment,
535 PCVDGEOMETRY pPCHSGeometry,
536 PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
537 unsigned uOpenFlags, unsigned uPercentStart,
538 unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
539 PVDINTERFACE pVDIfsImage,
540 PVDINTERFACE pVDIfsOperation, void **ppBackendData)
541{
542 LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p ppBackendData=%#p", pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
543 int rc = VERR_NOT_IMPLEMENTED;
544
545 LogFlowFunc(("returns %Rrc\n", rc));
546 return rc;
547}
548
549/** @copydoc VBOXHDDBACKEND::pfnRename */
550static int parallelsRename(void *pBackendData, const char *pszFilename)
551{
552 LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
553 int rc = VINF_SUCCESS;
554 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
555
556 /* Check arguments. */
557 if ( !pImage
558 || !pszFilename
559 || !*pszFilename)
560 {
561 rc = VERR_INVALID_PARAMETER;
562 goto out;
563 }
564
565 /* Close the image. */
566 rc = parallelsFreeImage(pImage, false);
567 if (RT_FAILURE(rc))
568 goto out;
569
570 /* Rename the file. */
571 rc = parallelsFileMove(pImage, pImage->pszFilename, pszFilename, 0);
572 if (RT_FAILURE(rc))
573 {
574 /* The move failed, try to reopen the original image. */
575 int rc2 = parallelsOpenImage(pImage, pImage->uOpenFlags);
576 if (RT_FAILURE(rc2))
577 rc = rc2;
578
579 goto out;
580 }
581
582 /* Update pImage with the new information. */
583 pImage->pszFilename = pszFilename;
584
585 /* Open the old image with new name. */
586 rc = parallelsOpenImage(pImage, pImage->uOpenFlags);
587 if (RT_FAILURE(rc))
588 goto out;
589
590out:
591 LogFlowFunc(("returns %Rrc\n", rc));
592 return rc;
593}
594
595/** @copydoc VBOXHDDBACKEND::pfnClose */
596static int parallelsClose(void *pBackendData, bool fDelete)
597{
598 LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
599 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
600 int rc;
601
602 rc = parallelsFreeImage(pImage, fDelete);
603 RTMemFree(pImage);
604
605 LogFlowFunc(("returns %Rrc\n", rc));
606 return rc;
607}
608
609/** @copydoc VBOXHDDBACKEND::pfnRead */
610static int parallelsRead(void *pBackendData, uint64_t uOffset, void *pvBuf,
611 size_t cbBuf, size_t *pcbActuallyRead)
612{
613 LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbBuf=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbBuf, pcbActuallyRead));
614 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
615 int rc = VINF_SUCCESS;
616 uint64_t uSector;
617 uint64_t uOffsetInFile;
618 uint32_t iIndexInAllocationTable;
619
620 AssertPtr(pImage);
621 Assert(uOffset % 512 == 0);
622 Assert(cbBuf % 512 == 0);
623
624 if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
625 {
626 rc = parallelsFileReadSync(pImage, uOffset, pvBuf, cbBuf, NULL);
627 }
628 else
629 {
630 /* Calculate offset in the real file. */
631 uSector = uOffset / 512;
632 /* One chunk in the file is always one track big. */
633 iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
634 uSector = uSector % pImage->PCHSGeometry.cSectors;
635
636 cbBuf = RT_MIN(cbBuf, (pImage->PCHSGeometry.cSectors - uSector)*512);
637
638 if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
639 {
640 rc = VERR_VD_BLOCK_FREE;
641 }
642 else
643 {
644 uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
645 rc = parallelsFileReadSync(pImage, uOffsetInFile, pvBuf, cbBuf, NULL);
646 }
647 }
648
649 if (RT_SUCCESS(rc))
650 {
651 if (pcbActuallyRead)
652 *pcbActuallyRead = cbBuf;
653
654 Log2(("parallelsRead: off=%#llx pvBuf=%p cbBuf=%d\n"
655 "%.*Rhxd\n",
656 uOffset, pvBuf, cbBuf, cbBuf, pvBuf));
657 }
658
659out:
660 LogFlowFunc(("returns %Rrc\n", rc));
661 return rc;
662}
663
664/** @copydoc VBOXHDDBACKEND::pfnWrite */
665static int parallelsWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
666 size_t cbBuf, size_t *pcbWriteProcess,
667 size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
668{
669 LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbBuf=%zu pcbWriteProcess=%#p\n", pBackendData, uOffset, pvBuf, cbBuf, pcbWriteProcess));
670 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
671 int rc = VINF_SUCCESS;
672 uint64_t uSector;
673 uint64_t uOffsetInFile;
674 uint32_t iIndexInAllocationTable;
675
676 AssertPtr(pImage);
677 Assert(uOffset % 512 == 0);
678 Assert(cbBuf % 512 == 0);
679
680 if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
681 {
682 rc = parallelsFileWriteSync(pImage, uOffset, pvBuf, cbBuf, NULL);
683 }
684 else
685 {
686 /** Calculate offset in the real file. */
687 uSector = uOffset / 512;
688 /** One chunk in the file is always one track big. */
689 iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
690 uSector = uSector % pImage->PCHSGeometry.cSectors;
691
692 cbBuf = RT_MIN(cbBuf, (pImage->PCHSGeometry.cSectors - uSector)*512);
693
694 if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
695 {
696 /* Allocate new chunk in the file. */
697 AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
698 pImage->pAllocationBitmap[iIndexInAllocationTable] = (uint32_t)(pImage->cbFileCurrent / 512);
699 pImage->cbFileCurrent += pImage->PCHSGeometry.cSectors * 512;
700 pImage->fAllocationBitmapChanged = true;
701
702 uint8_t *pNewBlock = (uint8_t *)RTMemAllocZ(pImage->PCHSGeometry.cSectors * 512);
703
704 if (!pNewBlock)
705 {
706 rc = VERR_NO_MEMORY;
707 goto out;
708 }
709
710 uOffsetInFile = (uint64_t)pImage->pAllocationBitmap[iIndexInAllocationTable] * 512;
711 memcpy(pNewBlock + (uOffset - ((uint64_t)iIndexInAllocationTable * pImage->PCHSGeometry.cSectors * 512)),
712 pvBuf, cbBuf);
713
714 /*
715 * Write the new block at the current end of the file.
716 */
717 rc = parallelsFileWriteSync(pImage, uOffsetInFile, pNewBlock,
718 pImage->PCHSGeometry.cSectors * 512,
719 NULL);
720
721 RTMemFree(pNewBlock);
722 }
723 else
724 {
725 uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
726 rc = parallelsFileWriteSync(pImage, uOffsetInFile, pvBuf, cbBuf, NULL);
727 }
728 }
729
730 if (pcbWriteProcess)
731 *pcbWriteProcess = cbBuf;
732
733 /* Stay on the safe side. Do not run the risk of confusing the higher
734 * level, as that can be pretty lethal to image consistency. */
735 *pcbPreRead = 0;
736 *pcbPostRead = 0;
737
738out:
739 LogFlowFunc(("returns %Rrc\n", rc));
740 return rc;
741}
742
743/** @copydoc VBOXHDDBACKEND::pfnFlush */
744static int parallelsFlush(void *pBackendData)
745{
746 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
747 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
748 int rc;
749
750 AssertPtr(pImage);
751
752 rc = parallelsFlushImage(pImage);
753
754 LogFlowFunc(("returns %Rrc\n", rc));
755 return rc;
756}
757
758/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
759static unsigned parallelsGetVersion(void *pBackendData)
760{
761 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
762 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
763
764 AssertPtr(pImage);
765
766 if (pImage)
767 return PARALLELS_DISK_VERSION;
768 else
769 return 0;
770}
771
772/** @copydoc VBOXHDDBACKEND::pfnGetSize */
773static uint64_t parallelsGetSize(void *pBackendData)
774{
775 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
776 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
777 uint64_t cb = 0;
778
779 AssertPtr(pImage);
780
781 if (pImage && pImage->pStorage)
782 cb = pImage->cbSize;
783
784 LogFlowFunc(("returns %llu\n", cb));
785 return cb;
786}
787
788/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
789static uint64_t parallelsGetFileSize(void *pBackendData)
790{
791 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
792 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
793 uint64_t cb = 0;
794
795 AssertPtr(pImage);
796
797 if (pImage && pImage->pStorage)
798 cb = pImage->cbFileCurrent;
799
800 LogFlowFunc(("returns %lld\n", cb));
801 return cb;
802}
803
804/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
805static int parallelsGetPCHSGeometry(void *pBackendData,
806 PVDGEOMETRY pPCHSGeometry)
807{
808 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
809 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
810 int rc;
811
812 AssertPtr(pImage);
813
814 if (pImage)
815 {
816 if (pImage->PCHSGeometry.cCylinders)
817 {
818 *pPCHSGeometry = pImage->PCHSGeometry;
819 rc = VINF_SUCCESS;
820 }
821 else
822 rc = VERR_VD_GEOMETRY_NOT_SET;
823 }
824 else
825 rc = VERR_VD_NOT_OPENED;
826
827 LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
828 return rc;
829}
830
831/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
832static int parallelsSetPCHSGeometry(void *pBackendData,
833 PCVDGEOMETRY pPCHSGeometry)
834{
835 LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
836 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
837 int rc;
838
839 AssertPtr(pImage);
840
841 if (pImage)
842 {
843 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
844 {
845 rc = VERR_VD_IMAGE_READ_ONLY;
846 goto out;
847 }
848
849 pImage->PCHSGeometry = *pPCHSGeometry;
850 rc = VINF_SUCCESS;
851 }
852 else
853 rc = VERR_VD_NOT_OPENED;
854
855out:
856 LogFlowFunc(("returns %Rrc\n", rc));
857 return rc;
858}
859
860/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
861static int parallelsGetLCHSGeometry(void *pBackendData,
862 PVDGEOMETRY pLCHSGeometry)
863{
864 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
865 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
866 int rc;
867
868 AssertPtr(pImage);
869
870 if (pImage)
871 {
872 if (pImage->LCHSGeometry.cCylinders)
873 {
874 *pLCHSGeometry = pImage->LCHSGeometry;
875 rc = VINF_SUCCESS;
876 }
877 else
878 rc = VERR_VD_GEOMETRY_NOT_SET;
879 }
880 else
881 rc = VERR_VD_NOT_OPENED;
882
883 LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
884 return rc;
885}
886
887/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
888static int parallelsSetLCHSGeometry(void *pBackendData,
889 PCVDGEOMETRY pLCHSGeometry)
890{
891 LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
892 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
893 int rc;
894
895 AssertPtr(pImage);
896
897 if (pImage)
898 {
899 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
900 {
901 rc = VERR_VD_IMAGE_READ_ONLY;
902 goto out;
903 }
904
905 pImage->LCHSGeometry = *pLCHSGeometry;
906 rc = VINF_SUCCESS;
907 }
908 else
909 rc = VERR_VD_NOT_OPENED;
910
911out:
912 LogFlowFunc(("returns %Rrc\n", rc));
913 return rc;
914}
915
916/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
917static unsigned parallelsGetImageFlags(void *pBackendData)
918{
919 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
920 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
921 unsigned uImageFlags;
922
923 AssertPtr(pImage);
924
925 if (pImage)
926 uImageFlags = pImage->uImageFlags;
927 else
928 uImageFlags = 0;
929
930 LogFlowFunc(("returns %#x\n", uImageFlags));
931 return uImageFlags;
932}
933
934/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
935static unsigned parallelsGetOpenFlags(void *pBackendData)
936{
937 LogFlowFunc(("pBackendData=%#p\n", pBackendData));
938 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
939 unsigned uOpenFlags;
940
941 AssertPtr(pImage);
942
943 if (pImage)
944 uOpenFlags = pImage->uOpenFlags;
945 else
946 uOpenFlags = 0;
947
948 LogFlowFunc(("returns %#x\n", uOpenFlags));
949 return uOpenFlags;
950}
951
952/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
953static int parallelsSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
954{
955 LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
956 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
957 int rc;
958
959 /* Image must be opened and the new flags must be valid. Just readonly and
960 * info flags are supported. */
961 /** @todo r=klaus add VD_OPEN_FLAGS_ASYNC_IO when async io has been tested */
962 if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_SHAREABLE)))
963 {
964 rc = VERR_INVALID_PARAMETER;
965 goto out;
966 }
967
968 /* Implement this operation via reopening the image. */
969 parallelsFreeImage(pImage, true);
970 rc = parallelsOpenImage(pImage, uOpenFlags);
971
972out:
973 LogFlowFunc(("returns %Rrc\n", rc));
974 return rc;
975}
976
977/** @copydoc VBOXHDDBACKEND::pfnGetComment */
978static int parallelsGetComment(void *pBackendData, char *pszComment,
979 size_t cbComment)
980{
981 LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
982 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
983 int rc;
984
985 AssertPtr(pImage);
986
987 if (pImage)
988 rc = VERR_NOT_SUPPORTED;
989 else
990 rc = VERR_VD_NOT_OPENED;
991
992 LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
993 return rc;
994}
995
996/** @copydoc VBOXHDDBACKEND::pfnSetComment */
997static int parallelsSetComment(void *pBackendData, const char *pszComment)
998{
999 LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1000 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1001 int rc;
1002
1003 AssertPtr(pImage);
1004
1005 if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1006 {
1007 rc = VERR_VD_IMAGE_READ_ONLY;
1008 goto out;
1009 }
1010
1011 if (pImage)
1012 rc = VERR_NOT_SUPPORTED;
1013 else
1014 rc = VERR_VD_NOT_OPENED;
1015
1016out:
1017 LogFlowFunc(("returns %Rrc\n", rc));
1018 return rc;
1019}
1020
1021/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
1022static int parallelsGetUuid(void *pBackendData, PRTUUID pUuid)
1023{
1024 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1025 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1026 int rc;
1027
1028 AssertPtr(pImage);
1029
1030 if (pImage)
1031 rc = VERR_NOT_SUPPORTED;
1032 else
1033 rc = VERR_VD_NOT_OPENED;
1034
1035 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1036 return rc;
1037}
1038
1039/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
1040static int parallelsSetUuid(void *pBackendData, PCRTUUID pUuid)
1041{
1042 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1043 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1044 int rc;
1045
1046 AssertPtr(pImage);
1047
1048 if (pImage)
1049 {
1050 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1051 rc = VERR_NOT_SUPPORTED;
1052 else
1053 rc = VERR_VD_IMAGE_READ_ONLY;
1054 }
1055 else
1056 rc = VERR_VD_NOT_OPENED;
1057
1058 LogFlowFunc(("returns %Rrc\n", rc));
1059 return rc;
1060}
1061
1062/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
1063static int parallelsGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1064{
1065 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1066 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1067 int rc;
1068
1069 AssertPtr(pImage);
1070
1071 if (pImage)
1072 rc = VERR_NOT_SUPPORTED;
1073 else
1074 rc = VERR_VD_NOT_OPENED;
1075
1076 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1077 return rc;
1078}
1079
1080/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
1081static int parallelsSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1082{
1083 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1084 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1085 int rc;
1086
1087 AssertPtr(pImage);
1088
1089 if (pImage)
1090 {
1091 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1092 rc = VERR_NOT_SUPPORTED;
1093 else
1094 rc = VERR_VD_IMAGE_READ_ONLY;
1095 }
1096 else
1097 rc = VERR_VD_NOT_OPENED;
1098
1099 LogFlowFunc(("returns %Rrc\n", rc));
1100 return rc;
1101}
1102
1103/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1104static int parallelsGetParentUuid(void *pBackendData, PRTUUID pUuid)
1105{
1106 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1107 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1108 int rc;
1109
1110 AssertPtr(pImage);
1111
1112 if (pImage)
1113 rc = VERR_NOT_SUPPORTED;
1114 else
1115 rc = VERR_VD_NOT_OPENED;
1116
1117 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1118 return rc;
1119}
1120
1121/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1122static int parallelsSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1123{
1124 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1125 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1126 int rc;
1127
1128 AssertPtr(pImage);
1129
1130 if (pImage)
1131 {
1132 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1133 rc = VERR_NOT_SUPPORTED;
1134 else
1135 rc = VERR_VD_IMAGE_READ_ONLY;
1136 }
1137 else
1138 rc = VERR_VD_NOT_OPENED;
1139
1140 LogFlowFunc(("returns %Rrc\n", rc));
1141 return rc;
1142}
1143
1144/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1145static int parallelsGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1146{
1147 LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1148 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1149 int rc;
1150
1151 AssertPtr(pImage);
1152
1153 if (pImage)
1154 rc = VERR_NOT_SUPPORTED;
1155 else
1156 rc = VERR_VD_NOT_OPENED;
1157
1158 LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1159 return rc;
1160}
1161
1162/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
1163static int parallelsSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1164{
1165 LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1166 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1167 int rc;
1168
1169 AssertPtr(pImage);
1170
1171 if (pImage)
1172 {
1173 if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1174 rc = VERR_NOT_SUPPORTED;
1175 else
1176 rc = VERR_VD_IMAGE_READ_ONLY;
1177 }
1178 else
1179 rc = VERR_VD_NOT_OPENED;
1180
1181 LogFlowFunc(("returns %Rrc\n", rc));
1182 return rc;
1183}
1184
1185/** @copydoc VBOXHDDBACKEND::pfnDump */
1186static void parallelsDump(void *pBackendData)
1187{
1188 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1189
1190 AssertPtr(pImage);
1191 if (pImage)
1192 {
1193 parallelsMessage(pImage, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u\n",
1194 pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
1195 pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors);
1196 }
1197}
1198
1199/** @copydoc VBOXHDDBACKEND::pfnIsAsyncIOSupported */
1200static bool parallelsIsAsyncIOSupported(void *pBackendData)
1201{
1202#if 0 /** @todo: Remove when tested */
1203 return true;
1204#else
1205 return false;
1206#endif
1207}
1208
1209/** @copydoc VBOXHDDBACKEND::pfnAsyncRead */
1210static int parallelsAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1211 PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1212{
1213 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
1214 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
1215 int rc = VINF_SUCCESS;
1216 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1217 uint64_t uSector;
1218 uint64_t uOffsetInFile;
1219 uint32_t iIndexInAllocationTable;
1220
1221 AssertPtr(pImage);
1222 Assert(uOffset % 512 == 0);
1223 Assert(cbToRead % 512 == 0);
1224
1225 if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
1226 {
1227 rc = parallelsFileReadUserAsync(pImage, uOffset, pIoCtx, cbToRead);
1228 }
1229 else
1230 {
1231 /* Calculate offset in the real file. */
1232 uSector = uOffset / 512;
1233 /* One chunk in the file is always one track big. */
1234 iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
1235 uSector = uSector % pImage->PCHSGeometry.cSectors;
1236
1237 cbToRead = RT_MIN(cbToRead, (pImage->PCHSGeometry.cSectors - uSector)*512);
1238
1239 if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
1240 {
1241 rc = VERR_VD_BLOCK_FREE;
1242 }
1243 else
1244 {
1245 uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
1246 rc = parallelsFileReadUserAsync(pImage, uOffsetInFile, pIoCtx, cbToRead);
1247 }
1248 }
1249
1250 *pcbActuallyRead = cbToRead;
1251
1252 LogFlowFunc(("returns %Rrc\n", rc));
1253 return rc;
1254}
1255
1256/** @copydoc VBOXHDDBACKEND::pfnAsyncWrite */
1257static int parallelsAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1258 PVDIOCTX pIoCtx,
1259 size_t *pcbWriteProcess, size_t *pcbPreRead,
1260 size_t *pcbPostRead, unsigned fWrite)
1261{
1262 LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p\n",
1263 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess));
1264 int rc = VINF_SUCCESS;
1265 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1266 uint64_t uSector;
1267 uint64_t uOffsetInFile;
1268 uint32_t iIndexInAllocationTable;
1269
1270 AssertPtr(pImage);
1271 Assert(uOffset % 512 == 0);
1272 Assert(cbToWrite % 512 == 0);
1273
1274 if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
1275 {
1276 rc = parallelsFileWriteUserAsync(pImage, uOffset, pIoCtx, cbToWrite, NULL, NULL);
1277 }
1278 else
1279 {
1280 /* Calculate offset in the real file. */
1281 uSector = uOffset / 512;
1282 /* One chunk in the file is always one track big. */
1283 iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
1284 uSector = uSector % pImage->PCHSGeometry.cSectors;
1285
1286 cbToWrite = RT_MIN(cbToWrite, (pImage->PCHSGeometry.cSectors - uSector)*512);
1287
1288 if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
1289 {
1290 if (fWrite & VD_WRITE_NO_ALLOC)
1291 {
1292 *pcbPreRead = uSector * 512;
1293 *pcbPostRead = pImage->PCHSGeometry.cSectors * 512 - cbToWrite - *pcbPreRead;
1294
1295 if (pcbWriteProcess)
1296 *pcbWriteProcess = cbToWrite;
1297 return VERR_VD_BLOCK_FREE;
1298 }
1299
1300 /* Allocate new chunk in the file. */
1301 Assert(uSector == 0);
1302 AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
1303 pImage->pAllocationBitmap[iIndexInAllocationTable] = (uint32_t)(pImage->cbFileCurrent / 512);
1304 pImage->cbFileCurrent += pImage->PCHSGeometry.cSectors * 512;
1305 pImage->fAllocationBitmapChanged = true;
1306 uOffsetInFile = (uint64_t)pImage->pAllocationBitmap[iIndexInAllocationTable] * 512;
1307
1308 /*
1309 * Write the new block at the current end of the file.
1310 */
1311 rc = parallelsFileWriteUserAsync(pImage, uOffsetInFile, pIoCtx, cbToWrite, NULL, NULL);
1312 if (RT_SUCCESS(rc) || (rc == VERR_VD_ASYNC_IO_IN_PROGRESS))
1313 {
1314 /* Write the changed allocation bitmap entry. */
1315 /** @todo: Error handling. */
1316 rc = parallelsFileWriteMetaAsync(pImage,
1317 sizeof(ParallelsHeader) + iIndexInAllocationTable * sizeof(uint32_t),
1318 &pImage->pAllocationBitmap[iIndexInAllocationTable],
1319 sizeof(uint32_t), pIoCtx,
1320 NULL, NULL);
1321 }
1322 }
1323 else
1324 {
1325 uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
1326 rc = parallelsFileWriteUserAsync(pImage, uOffsetInFile, pIoCtx, cbToWrite, NULL, NULL);
1327 }
1328 }
1329
1330 if (pcbWriteProcess)
1331 *pcbWriteProcess = cbToWrite;
1332
1333 LogFlowFunc(("returns %Rrc\n", rc));
1334 return rc;
1335}
1336
1337/** @copydoc VBOXHDDBACKEND::pfnAsyncFlush */
1338static int parallelsAsyncFlush(void *pBackendData, PVDIOCTX pIoCtx)
1339{
1340 int rc = VINF_SUCCESS;
1341 PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1342
1343 LogFlowFunc(("pImage=#%p\n", pImage));
1344
1345 /* Flush the file, everything is up to date already. */
1346 rc = parallelsFileFlushAsync(pImage, pIoCtx, NULL, NULL);
1347
1348 LogFlowFunc(("returns %Rrc\n", rc));
1349 return rc;
1350}
1351
1352
1353VBOXHDDBACKEND g_ParallelsBackend =
1354{
1355 /* pszBackendName */
1356 "Parallels",
1357 /* cbSize */
1358 sizeof(VBOXHDDBACKEND),
1359 /* uBackendCaps */
1360 VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
1361 /* papszFileExtensions */
1362 s_apszParallelsFileExtensions,
1363 /* paConfigInfo */
1364 NULL,
1365 /* hPlugin */
1366 NIL_RTLDRMOD,
1367 /* pfnCheckIfValid */
1368 parallelsCheckIfValid,
1369 /* pfnOpen */
1370 parallelsOpen,
1371 /* pfnCreate */
1372 parallelsCreate,
1373 /* pfnRename */
1374 parallelsRename,
1375 /* pfnClose */
1376 parallelsClose,
1377 /* pfnRead */
1378 parallelsRead,
1379 /* pfnWrite */
1380 parallelsWrite,
1381 /* pfnFlush */
1382 parallelsFlush,
1383 /* pfnGetVersion */
1384 parallelsGetVersion,
1385 /* pfnGetSize */
1386 parallelsGetSize,
1387 /* pfnGetFileSize */
1388 parallelsGetFileSize,
1389 /* pfnGetPCHSGeometry */
1390 parallelsGetPCHSGeometry,
1391 /* pfnSetPCHSGeometry */
1392 parallelsSetPCHSGeometry,
1393 /* pfnGetLCHSGeometry */
1394 parallelsGetLCHSGeometry,
1395 /* pfnSetLCHSGeometry */
1396 parallelsSetLCHSGeometry,
1397 /* pfnGetImageFlags */
1398 parallelsGetImageFlags,
1399 /* pfnGetOpenFlags */
1400 parallelsGetOpenFlags,
1401 /* pfnSetOpenFlags */
1402 parallelsSetOpenFlags,
1403 /* pfnGetComment */
1404 parallelsGetComment,
1405 /* pfnSetComment */
1406 parallelsSetComment,
1407 /* pfnGetUuid */
1408 parallelsGetUuid,
1409 /* pfnSetUuid */
1410 parallelsSetUuid,
1411 /* pfnGetModificationUuid */
1412 parallelsGetModificationUuid,
1413 /* pfnSetModificationUuid */
1414 parallelsSetModificationUuid,
1415 /* pfnGetParentUuid */
1416 parallelsGetParentUuid,
1417 /* pfnSetParentUuid */
1418 parallelsSetParentUuid,
1419 /* pfnGetParentModificationUuid */
1420 parallelsGetParentModificationUuid,
1421 /* pfnSetParentModificationUuid */
1422 parallelsSetParentModificationUuid,
1423 /* pfnDump */
1424 parallelsDump,
1425 /* pfnGetTimeStamp */
1426 NULL,
1427 /* pfnGetParentTimeStamp */
1428 NULL,
1429 /* pfnSetParentTimeStamp */
1430 NULL,
1431 /* pfnGetParentFilename */
1432 NULL,
1433 /* pfnSetParentFilename */
1434 NULL,
1435 /* pfnIsAsyncIOSupported */
1436 parallelsIsAsyncIOSupported,
1437 /* pfnAsyncRead */
1438 parallelsAsyncRead,
1439 /* pfnAsyncWrite */
1440 parallelsAsyncWrite,
1441 /* pfnAsyncFlush */
1442 parallelsAsyncFlush,
1443 /* pfnComposeLocation */
1444 genericFileComposeLocation,
1445 /* pfnComposeName */
1446 genericFileComposeName,
1447 /* pfnCompact */
1448 NULL,
1449 /* pfnResize */
1450 NULL
1451};
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use