Index: /trunk/include/iprt/dvm.h =================================================================== --- /trunk/include/iprt/dvm.h (revision 37023) +++ /trunk/include/iprt/dvm.h (revision 37024) @@ -71,4 +71,6 @@ /** Volume hosts a Solaris volume. */ RTDVMVOLTYPE_SOLARIS, + /** End of the valid values. */ + RTDVMVOLTYPE_END, /** Usual 32bit hack. */ RTDVMVOLTYPE_32BIT_HACK = 0x7fffffff Index: /trunk/src/VBox/Runtime/Makefile.kmk =================================================================== --- /trunk/src/VBox/Runtime/Makefile.kmk (revision 37023) +++ /trunk/src/VBox/Runtime/Makefile.kmk (revision 37024) @@ -2296,6 +2296,4 @@ -e '/^g_enmProcessPriority/d'\ -e '/^g_hDbgModStrCache/d'\ - -e '/^g_DvmFmtGpt/d'\ - -e '/^g_DvmFmtMbr/d'\ \ -e '/^RTDBusLoadLib/d' \ Index: /trunk/src/VBox/Runtime/common/dvm/dvm.cpp =================================================================== --- /trunk/src/VBox/Runtime/common/dvm/dvm.cpp (revision 37023) +++ /trunk/src/VBox/Runtime/common/dvm/dvm.cpp (revision 37024) @@ -25,4 +25,8 @@ */ + +/******************************************************************************* +* Header Files * +*******************************************************************************/ #include #include @@ -77,6 +81,6 @@ * Global variables * *******************************************************************************/ -extern RTDVMFMTOPS g_DvmFmtMbr; -extern RTDVMFMTOPS g_DvmFmtGpt; +extern RTDVMFMTOPS g_rtDvmFmtMbr; +extern RTDVMFMTOPS g_rtDvmFmtGpt; /** @@ -85,10 +89,12 @@ static PCRTDVMFMTOPS g_aDvmFmts[] = { - &g_DvmFmtMbr, - &g_DvmFmtGpt + &g_rtDvmFmtMbr, + &g_rtDvmFmtGpt }; /** * Descriptions of the volume types. + * + * This is indexed by RTDVMVOLTYPE. */ static const char * g_apcszDvmVolTypes[] = @@ -468,5 +474,5 @@ RTDECL(const char *) RTDvmVolumeTypeGetDescr(RTDVMVOLTYPE enmVolType) { - AssertReturn(enmVolType >= RTDVMVOLTYPE_INVALID && enmVolType < RTDVMVOLTYPE_32BIT_HACK, NULL); + AssertReturn(enmVolType >= RTDVMVOLTYPE_INVALID && enmVolType < RTDVMVOLTYPE_END, NULL); return g_apcszDvmVolTypes[enmVolType]; Index: /trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp =================================================================== --- /trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp (revision 37023) +++ /trunk/src/VBox/Runtime/common/dvm/dvmgpt.cpp (revision 37024) @@ -25,4 +25,8 @@ */ + +/******************************************************************************* +* Header Files * +*******************************************************************************/ #include #include @@ -33,4 +37,8 @@ #include "internal/dvm.h" + +/******************************************************************************* +* Structures and Typedefs * +*******************************************************************************/ /** The GPT signature. */ #define RTDVM_GPT_SIGNATURE "EFI PART" @@ -178,4 +186,8 @@ #define RTDVM_GPT_BYTE2LBA(lba, disk) ((lba) / (disk)->cbSector) + +/******************************************************************************* +* Global Variables * +*******************************************************************************/ /** * Mapping of partition types to DVM volume types. @@ -216,5 +228,5 @@ }; -DECLCALLBACK(int) dvmFmtGptProbe(PCRTDVMDISK pDisk, uint32_t *puScore) +static DECLCALLBACK(int) rtDvmFmtGptProbe(PCRTDVMDISK pDisk, uint32_t *puScore) { int rc = VINF_SUCCESS; @@ -223,8 +235,8 @@ *puScore = RTDVM_MATCH_SCORE_UNSUPPORTED; - if (dvmDiskGetSectors(pDisk) >= 2) + if (rtDvmDiskGetSectors(pDisk) >= 2) { /* Read from the disk and check for the signature. */ - rc = dvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GptHdr)); + rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &Hdr, sizeof(GptHdr)); if ( RT_SUCCESS(rc) && !strncmp(&Hdr.abSignature[0], RTDVM_GPT_SIGNATURE, RT_ELEMENTS(Hdr.abSignature)) @@ -237,5 +249,5 @@ } -DECLCALLBACK(int) dvmFmtGptOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) +static DECLCALLBACK(int) rtDvmFmtGptOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) { int rc = VINF_SUCCESS; @@ -249,5 +261,5 @@ /* Read the complete GPT header and convert to host endianess. */ - rc = dvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &pThis->HdrRev1, sizeof(pThis->HdrRev1)); + rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(1, pDisk), &pThis->HdrRev1, sizeof(pThis->HdrRev1)); if (RT_SUCCESS(rc)) { @@ -270,5 +282,5 @@ if (VALID_PTR(pThis->paGptEntries)) { - rc = dvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(pThis->HdrRev1.u64LbaPartitionEntries, pDisk), + rc = rtDvmDiskRead(pDisk, RTDVM_GPT_LBA2BYTE(pThis->HdrRev1.u64LbaPartitionEntries, pDisk), pThis->paGptEntries, pThis->HdrRev1.cPartitionEntries * pThis->HdrRev1.cbPartitionEntry); if (RT_SUCCESS(rc)) @@ -311,10 +323,10 @@ } -DECLCALLBACK(int) dvmFmtGptInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) +static DECLCALLBACK(int) rtDvmFmtGptInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) { return VERR_NOT_IMPLEMENTED; } -DECLCALLBACK(void) dvmFmtGptClose(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(void) rtDvmFmtGptClose(RTDVMFMT hVolMgrFmt) { PRTDVMFMTINTERNAL pThis = hVolMgrFmt; @@ -328,5 +340,5 @@ } -DECLCALLBACK(uint32_t) dvmFmtGptGetValidVolumes(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(uint32_t) rtDvmFmtGptGetValidVolumes(RTDVMFMT hVolMgrFmt) { PRTDVMFMTINTERNAL pThis = hVolMgrFmt; @@ -335,5 +347,5 @@ } -DECLCALLBACK(uint32_t) dvmFmtGptGetMaxVolumes(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(uint32_t) rtDvmFmtGptGetMaxVolumes(RTDVMFMT hVolMgrFmt) { PRTDVMFMTINTERNAL pThis = hVolMgrFmt; @@ -351,5 +363,5 @@ * @param phVolFmt Where to store the volume data on success. */ -static int dvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGptEntry pGptEntry, +static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, PGptEntry pGptEntry, uint32_t idx, PRTDVMVOLUMEFMT phVolFmt) { @@ -373,5 +385,5 @@ } -DECLCALLBACK(int) dvmFmtGptQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt) +static DECLCALLBACK(int) rtDvmFmtGptQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt) { int rc = VINF_SUCCESS; @@ -387,5 +399,5 @@ if (!RTUuidIsNull(&pGptEntry->UuidType)) { - rc = dvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt); + rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmt); break; } @@ -399,5 +411,5 @@ } -DECLCALLBACK(int) dvmFmtGptQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext) +static DECLCALLBACK(int) rtDvmFmtGptQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext) { int rc = VERR_DVM_MAP_NO_VOLUME; @@ -410,5 +422,5 @@ if (!RTUuidIsNull(&pGptEntry->UuidType)) { - rc = dvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext); + rc = rtDvmFmtMbrVolumeCreate(pThis, pGptEntry, i, phVolFmtNext); break; } @@ -419,5 +431,5 @@ } -DECLCALLBACK(void) dvmFmtGptVolumeClose(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(void) rtDvmFmtGptVolumeClose(RTDVMVOLUMEFMT hVolFmt) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; @@ -431,5 +443,5 @@ } -DECLCALLBACK(uint64_t) dvmFmtGptVolumeGetSize(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetSize(RTDVMVOLUMEFMT hVolFmt) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; @@ -438,5 +450,5 @@ } -DECLCALLBACK(int) dvmFmtGptVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName) +static DECLCALLBACK(int) rtDvmFmtGptVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; @@ -450,5 +462,5 @@ } -DECLCALLBACK(RTDVMVOLTYPE) dvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtGptVolumeGetType(RTDVMVOLUMEFMT hVolFmt) { RTDVMVOLTYPE enmVolType = RTDVMVOLTYPE_UNKNOWN; @@ -465,5 +477,5 @@ } -DECLCALLBACK(uint64_t) dvmFmtGptVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(uint64_t) rtDvmFmtGptVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt) { NOREF(hVolFmt); /* No supported flags for now. */ @@ -471,54 +483,54 @@ } -DECLCALLBACK(int) dvmFmtGptVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead) +static DECLCALLBACK(int) rtDvmFmtGptVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; AssertReturn(off + cbRead <= pVol->cbVolume, VERR_INVALID_PARAMETER); - return dvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead); -} - -DECLCALLBACK(int) dvmFmtGptVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite) + return rtDvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead); +} + +static DECLCALLBACK(int) rtDvmFmtGptVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; AssertReturn(off + cbWrite <= pVol->cbVolume, VERR_INVALID_PARAMETER); - return dvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite); -} - -RTDVMFMTOPS g_DvmFmtGpt = + return rtDvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite); +} + +RTDVMFMTOPS g_rtDvmFmtGpt = { /* pcszFmt */ "GPT", /* pfnProbe */ - dvmFmtGptProbe, + rtDvmFmtGptProbe, /* pfnOpen */ - dvmFmtGptOpen, + rtDvmFmtGptOpen, /* pfnInitialize */ - dvmFmtGptInitialize, + rtDvmFmtGptInitialize, /* pfnClose */ - dvmFmtGptClose, + rtDvmFmtGptClose, /* pfnGetValidVolumes */ - dvmFmtGptGetValidVolumes, + rtDvmFmtGptGetValidVolumes, /* pfnGetMaxVolumes */ - dvmFmtGptGetMaxVolumes, + rtDvmFmtGptGetMaxVolumes, /* pfnQueryFirstVolume */ - dvmFmtGptQueryFirstVolume, + rtDvmFmtGptQueryFirstVolume, /* pfnQueryNextVolume */ - dvmFmtGptQueryNextVolume, + rtDvmFmtGptQueryNextVolume, /* pfnVolumeClose */ - dvmFmtGptVolumeClose, + rtDvmFmtGptVolumeClose, /* pfnVolumeGetSize */ - dvmFmtGptVolumeGetSize, + rtDvmFmtGptVolumeGetSize, /* pfnVolumeQueryName */ - dvmFmtGptVolumeQueryName, + rtDvmFmtGptVolumeQueryName, /* pfnVolumeGetType */ - dvmFmtGptVolumeGetType, + rtDvmFmtGptVolumeGetType, /* pfnVolumeGetFlags */ - dvmFmtGptVolumeGetFlags, + rtDvmFmtGptVolumeGetFlags, /* pfnVolumeRead */ - dvmFmtGptVolumeRead, + rtDvmFmtGptVolumeRead, /* pfnVolumeWrite */ - dvmFmtGptVolumeWrite + rtDvmFmtGptVolumeWrite }; Index: /trunk/src/VBox/Runtime/common/dvm/dvmmbr.cpp =================================================================== --- /trunk/src/VBox/Runtime/common/dvm/dvmmbr.cpp (revision 37023) +++ /trunk/src/VBox/Runtime/common/dvm/dvmmbr.cpp (revision 37024) @@ -89,4 +89,8 @@ typedef RTDVMMBRFS2VOLTYPE *PRTDVMMBRFS2VOLTYPE; + +/******************************************************************************* +* Global Variables * +*******************************************************************************/ /** * Mapping of FS types to DVM volume types. @@ -111,5 +115,5 @@ }; -DECLCALLBACK(int) dvmFmtMbrProbe(PCRTDVMDISK pDisk, uint32_t *puScore) +static DECLCALLBACK(int) rtDvmFmtMbrProbe(PCRTDVMDISK pDisk, uint32_t *puScore) { int rc = VINF_SUCCESS; @@ -121,5 +125,5 @@ { /* Read from the disk and check for the 0x55aa signature at the end. */ - rc = dvmDiskRead(pDisk, 0, &abMbr[0], sizeof(abMbr)); + rc = rtDvmDiskRead(pDisk, 0, &abMbr[0], sizeof(abMbr)); if ( RT_SUCCESS(rc) && abMbr[510] == 0x55 @@ -131,5 +135,5 @@ } -DECLCALLBACK(int) dvmFmtMbrOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) +static DECLCALLBACK(int) rtDvmFmtMbrOpen(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) { int rc = VINF_SUCCESS; @@ -143,5 +147,5 @@ /* Read the MBR and count the valid partition entries. */ - rc = dvmDiskRead(pDisk, 0, &pThis->abMbr[0], sizeof(pThis->abMbr)); + rc = rtDvmDiskRead(pDisk, 0, &pThis->abMbr[0], sizeof(pThis->abMbr)); if (RT_SUCCESS(rc)) { @@ -168,5 +172,5 @@ } -DECLCALLBACK(int) dvmFmtMbrInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) +static DECLCALLBACK(int) rtDvmFmtMbrInitialize(PCRTDVMDISK pDisk, PRTDVMFMT phVolMgrFmt) { int rc = VINF_SUCCESS; @@ -181,5 +185,5 @@ pThis->abMbr[511] = 0xaa; - rc = dvmDiskWrite(pDisk, 0, &pThis->abMbr[0], sizeof(pThis->abMbr)); + rc = rtDvmDiskWrite(pDisk, 0, &pThis->abMbr[0], sizeof(pThis->abMbr)); if (RT_SUCCESS(rc)) @@ -198,5 +202,5 @@ } -DECLCALLBACK(void) dvmFmtMbrClose(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(void) rtDvmFmtMbrClose(RTDVMFMT hVolMgrFmt) { PRTDVMFMTINTERNAL pThis = hVolMgrFmt; @@ -208,5 +212,5 @@ } -DECLCALLBACK(uint32_t) dvmFmtMbrGetValidVolumes(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(uint32_t) rtDvmFmtMbrGetValidVolumes(RTDVMFMT hVolMgrFmt) { PRTDVMFMTINTERNAL pThis = hVolMgrFmt; @@ -215,5 +219,5 @@ } -DECLCALLBACK(uint32_t) dvmFmtMbrGetMaxVolumes(RTDVMFMT hVolMgrFmt) +static DECLCALLBACK(uint32_t) rtDvmFmtMbrGetMaxVolumes(RTDVMFMT hVolMgrFmt) { NOREF(hVolMgrFmt); @@ -230,5 +234,5 @@ * @param phVolFmt Where to store the volume data on success. */ -static int dvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, uint8_t *pbMbrEntry, +static int rtDvmFmtMbrVolumeCreate(PRTDVMFMTINTERNAL pThis, uint8_t *pbMbrEntry, uint32_t idx, PRTDVMVOLUMEFMT phVolFmt) { @@ -252,5 +256,5 @@ } -DECLCALLBACK(int) dvmFmtMbrQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt) +static DECLCALLBACK(int) rtDvmFmtMbrQueryFirstVolume(RTDVMFMT hVolMgrFmt, PRTDVMVOLUMEFMT phVolFmt) { int rc = VINF_SUCCESS; @@ -266,5 +270,5 @@ if (pbMbrEntry[0x04] != 0x00) { - rc = dvmFmtMbrVolumeCreate(pThis, pbMbrEntry, i, phVolFmt); + rc = rtDvmFmtMbrVolumeCreate(pThis, pbMbrEntry, i, phVolFmt); break; } @@ -278,5 +282,5 @@ } -DECLCALLBACK(int) dvmFmtMbrQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext) +static DECLCALLBACK(int) rtDvmFmtMbrQueryNextVolume(RTDVMFMT hVolMgrFmt, RTDVMVOLUMEFMT hVolFmt, PRTDVMVOLUMEFMT phVolFmtNext) { int rc = VERR_DVM_MAP_NO_VOLUME; @@ -289,5 +293,5 @@ if (pbMbrEntry[0x04] != 0x00) { - rc = dvmFmtMbrVolumeCreate(pThis, pbMbrEntry, i, phVolFmtNext); + rc = rtDvmFmtMbrVolumeCreate(pThis, pbMbrEntry, i, phVolFmtNext); break; } @@ -298,5 +302,5 @@ } -DECLCALLBACK(void) dvmFmtMbrVolumeClose(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(void) rtDvmFmtMbrVolumeClose(RTDVMVOLUMEFMT hVolFmt) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; @@ -310,5 +314,5 @@ } -DECLCALLBACK(uint64_t) dvmFmtMbrVolumeGetSize(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(uint64_t) rtDvmFmtMbrVolumeGetSize(RTDVMVOLUMEFMT hVolFmt) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; @@ -317,5 +321,5 @@ } -DECLCALLBACK(int) dvmFmtMbrVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName) +static DECLCALLBACK(int) rtDvmFmtMbrVolumeQueryName(RTDVMVOLUMEFMT hVolFmt, char **ppszVolName) { NOREF(hVolFmt); @@ -323,5 +327,5 @@ } -DECLCALLBACK(RTDVMVOLTYPE) dvmFmtMbrVolumeGetType(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(RTDVMVOLTYPE) rtDvmFmtMbrVolumeGetType(RTDVMVOLUMEFMT hVolFmt) { RTDVMVOLTYPE enmVolType = RTDVMVOLTYPE_UNKNOWN; @@ -338,5 +342,5 @@ } -DECLCALLBACK(uint64_t) dvmFmtMbrVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt) +static DECLCALLBACK(uint64_t) rtDvmFmtMbrVolumeGetFlags(RTDVMVOLUMEFMT hVolFmt) { uint64_t fFlags = 0; @@ -349,54 +353,54 @@ } -DECLCALLBACK(int) dvmFmtMbrVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead) +static DECLCALLBACK(int) rtDvmFmtMbrVolumeRead(RTDVMVOLUMEFMT hVolFmt, uint64_t off, void *pvBuf, size_t cbRead) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; AssertReturn(off + cbRead <= pVol->cbVolume, VERR_INVALID_PARAMETER); - return dvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead); -} - -DECLCALLBACK(int) dvmFmtMbrVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite) + return rtDvmDiskRead(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbRead); +} + +static DECLCALLBACK(int) rtDvmFmtMbrVolumeWrite(RTDVMVOLUMEFMT hVolFmt, uint64_t off, const void *pvBuf, size_t cbWrite) { PRTDVMVOLUMEFMTINTERNAL pVol = hVolFmt; AssertReturn(off + cbWrite <= pVol->cbVolume, VERR_INVALID_PARAMETER); - return dvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite); -} - -RTDVMFMTOPS g_DvmFmtMbr = + return rtDvmDiskWrite(pVol->pVolMgr->pDisk, pVol->offStart + off, pvBuf, cbWrite); +} + +RTDVMFMTOPS g_rtDvmFmtMbr = { /* pcszFmt */ "MBR", /* pfnProbe */ - dvmFmtMbrProbe, + rtDvmFmtMbrProbe, /* pfnOpen */ - dvmFmtMbrOpen, + rtDvmFmtMbrOpen, /* pfnInitialize */ - dvmFmtMbrInitialize, + rtDvmFmtMbrInitialize, /* pfnClose */ - dvmFmtMbrClose, + rtDvmFmtMbrClose, /* pfnGetValidVolumes */ - dvmFmtMbrGetValidVolumes, + rtDvmFmtMbrGetValidVolumes, /* pfnGetMaxVolumes */ - dvmFmtMbrGetMaxVolumes, + rtDvmFmtMbrGetMaxVolumes, /* pfnQueryFirstVolume */ - dvmFmtMbrQueryFirstVolume, + rtDvmFmtMbrQueryFirstVolume, /* pfnQueryNextVolume */ - dvmFmtMbrQueryNextVolume, + rtDvmFmtMbrQueryNextVolume, /* pfnVolumeClose */ - dvmFmtMbrVolumeClose, + rtDvmFmtMbrVolumeClose, /* pfnVolumeGetSize */ - dvmFmtMbrVolumeGetSize, + rtDvmFmtMbrVolumeGetSize, /* pfnVolumeQueryName */ - dvmFmtMbrVolumeQueryName, + rtDvmFmtMbrVolumeQueryName, /* pfnVolumeGetType */ - dvmFmtMbrVolumeGetType, + rtDvmFmtMbrVolumeGetType, /* pfnVolumeGetFlags */ - dvmFmtMbrVolumeGetFlags, + rtDvmFmtMbrVolumeGetFlags, /* pfnVolumeRead */ - dvmFmtMbrVolumeRead, + rtDvmFmtMbrVolumeRead, /* pfnVolumeWrite */ - dvmFmtMbrVolumeWrite + rtDvmFmtMbrVolumeWrite }; Index: /trunk/src/VBox/Runtime/include/internal/dvm.h =================================================================== --- /trunk/src/VBox/Runtime/include/internal/dvm.h (revision 37023) +++ /trunk/src/VBox/Runtime/include/internal/dvm.h (revision 37024) @@ -233,5 +233,5 @@ * @param pDisk The disk descriptor. */ -DECLINLINE(uint64_t) dvmDiskGetSectors(PCRTDVMDISK pDisk) +DECLINLINE(uint64_t) rtDvmDiskGetSectors(PCRTDVMDISK pDisk) { return pDisk->cbDisk / pDisk->cbSector; @@ -247,5 +247,5 @@ * @param cbRead How much to read. */ -DECLINLINE(int) dvmDiskRead(PCRTDVMDISK pDisk, uint64_t off, void *pvBuf, size_t cbRead) +DECLINLINE(int) rtDvmDiskRead(PCRTDVMDISK pDisk, uint64_t off, void *pvBuf, size_t cbRead) { AssertPtrReturn(pDisk, VERR_INVALID_POINTER); @@ -266,5 +266,5 @@ * @param cbWrite How much to write. */ -DECLINLINE(int) dvmDiskWrite(PCRTDVMDISK pDisk, uint64_t off, const void *pvBuf, size_t cbWrite) +DECLINLINE(int) rtDvmDiskWrite(PCRTDVMDISK pDisk, uint64_t off, const void *pvBuf, size_t cbWrite) { AssertPtrReturn(pDisk, VERR_INVALID_POINTER);