VirtualBox

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

Last change on this file since 28855 was 28800, checked in by vboxsync, 14 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use