/**
* Converts a partition entry to the host endianness.
*
* @returns nothing.
* @param pPartition The partition to decode.
*/
static void rtDvmFmtBsdLblDiskLabelDecodePartition(PBsdLabelPartition pPartition)
{
pPartition->cSectors = RT_LE2H_U32(pPartition->cSectors);
pPartition->offSectorStart = RT_LE2H_U32(pPartition->offSectorStart);
pPartition->cbFsFragment = RT_LE2H_U32(pPartition->cbFsFragment);
pPartition->cFsCylPerGroup = RT_LE2H_U16(pPartition->cFsCylPerGroup);
}
int vboxClipboardDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest)
{
size_t cb = sizeof(BMFILEHEADER) + cbSrc;
PBMFILEHEADER pFileHeader = NULL;
void *pvDest = NULL;
size_t offPixel = 0;
AssertPtrReturn(pvSrc, VERR_INVALID_PARAMETER);
AssertPtrReturn(ppvDest, VERR_INVALID_PARAMETER);
AssertPtrReturn(pcbDest, VERR_INVALID_PARAMETER);
PBMINFOHEADER pBitmapInfoHeader = (PBMINFOHEADER)pvSrc;
/** @todo Support all the many versions of the DIB headers. */
if ( cbSrc < sizeof(BMINFOHEADER)
|| RT_LE2H_U32(pBitmapInfoHeader->u32Size) < sizeof(BMINFOHEADER)
|| RT_LE2H_U32(pBitmapInfoHeader->u32Size) != sizeof(BMINFOHEADER))
{
Log(("vboxClipboardDibToBmp: invalid or unsupported bitmap data.\n"));
return VERR_INVALID_PARAMETER;
}
offPixel = sizeof(BMFILEHEADER)
+ RT_LE2H_U32(pBitmapInfoHeader->u32Size)
+ RT_LE2H_U32(pBitmapInfoHeader->u32ClrUsed) * sizeof(uint32_t);
if (cbSrc < offPixel)
{
Log(("vboxClipboardDibToBmp: invalid bitmap data.\n"));
return VERR_INVALID_PARAMETER;
}
pvDest = RTMemAlloc(cb);
if (!pvDest)
{
Log(("writeToPasteboard: cannot allocate memory for bitmap.\n"));
return VERR_NO_MEMORY;
}
pFileHeader = (PBMFILEHEADER)pvDest;
pFileHeader->u16Type = BITMAPHEADERMAGIC;
pFileHeader->u32Size = RT_H2LE_U32(cb);
pFileHeader->u16Reserved1 = pFileHeader->u16Reserved2 = 0;
pFileHeader->u32OffBits = RT_H2LE_U32(offPixel);
memcpy((uint8_t *)pvDest + sizeof(BMFILEHEADER), pvSrc, cbSrc);
*ppvDest = pvDest;
*pcbDest = cb;
return VINF_SUCCESS;
}
VBOXDDU_DECL(int) VDDbgIoLogEventGetComplete(VDIOLOGGER hIoLogger, uint64_t *pidEvent, int *pRc,
uint64_t *pmsDuration, size_t *pcbIo, size_t cbBuf, void *pvBuf)
{
int rc = VINF_SUCCESS;
PVDIOLOGGERINT pIoLogger = hIoLogger;
AssertPtrReturn(pIoLogger, VERR_INVALID_HANDLE);
AssertPtrReturn(pidEvent, VERR_INVALID_POINTER);
AssertPtrReturn(pmsDuration, VERR_INVALID_POINTER);
AssertPtrReturn(pcbIo, VERR_INVALID_POINTER);
rc = RTSemFastMutexRequest(pIoLogger->hMtx);
AssertRCReturn(rc, rc);
if (pIoLogger->u32EventTypeNext == VDIOLOG_EVENT_COMPLETE)
{
IoLogEntryComplete Entry;
rc = RTFileReadAt(pIoLogger->hFile, pIoLogger->offReadNext, &Entry, sizeof(Entry), NULL);
if (RT_SUCCESS(rc))
{
*pidEvent = RT_LE2H_U64(Entry.u64Id);
*pRc = (int)RT_LE2H_U32((int32_t)Entry.i32Rc);
*pmsDuration = RT_LE2H_U64(Entry.msDuration);
*pcbIo = RT_LE2H_U64(Entry.u64IoBuffer);
if (*pcbIo)
{
/* Read data. */
if (cbBuf < *pcbIo)
rc = VERR_BUFFER_OVERFLOW;
else
rc = RTFileReadAt(pIoLogger->hFile, pIoLogger->offReadNext + sizeof(Entry), pvBuf, *pcbIo, NULL);
if (rc != VERR_BUFFER_OVERFLOW)
pIoLogger->offReadNext += *pcbIo + sizeof(Entry);
}
else
pIoLogger->offReadNext += sizeof(Entry);
}
}
else
rc = VERR_INVALID_STATE;
if (RT_SUCCESS(rc))
pIoLogger->u32EventTypeNext = 0;
RTSemFastMutexRelease(pIoLogger->hMtx);
return rc;
}
int vboxClipboardBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest)
{
AssertPtrReturn(pvSrc, VERR_INVALID_PARAMETER);
AssertPtrReturn(ppvDest, VERR_INVALID_PARAMETER);
AssertPtrReturn(pcbDest, VERR_INVALID_PARAMETER);
PBMFILEHEADER pFileHeader = (PBMFILEHEADER)pvSrc;
if ( cbSrc < sizeof(BMFILEHEADER)
|| pFileHeader->u16Type != BITMAPHEADERMAGIC
|| RT_LE2H_U32(pFileHeader->u32Size) != cbSrc)
{
Log(("vboxClipboardBmpGetDib: invalid bitmap data.\n"));
return VERR_INVALID_PARAMETER;
}
*ppvDest = ((uint8_t *)pvSrc) + sizeof(BMFILEHEADER);
*pcbDest = cbSrc - sizeof(BMFILEHEADER);
return VINF_SUCCESS;
}
VBOXDDU_DECL(int) VDDbgIoLogOpen(PVDIOLOGGER phIoLogger, const char *pszFilename)
{
int rc = VINF_SUCCESS;
PVDIOLOGGERINT pIoLogger = NULL;
AssertPtrReturn(phIoLogger, VERR_INVALID_POINTER);
AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
rc = vddbgIoLoggerCreate(&pIoLogger);
if (RT_SUCCESS(rc))
{
/* open existing log. */
rc = RTFileOpen(&pIoLogger->hFile, pszFilename, RTFILE_O_DENY_NONE | RTFILE_O_OPEN | RTFILE_O_WRITE | RTFILE_O_READ);
if (RT_SUCCESS(rc))
{
IoLogHeader Hdr;
uint64_t cbLog;
rc = RTFileGetSize(pIoLogger->hFile, &cbLog);
/* Read the header. */
if (RT_SUCCESS(rc))
rc = RTFileRead(pIoLogger->hFile, &Hdr, sizeof(Hdr), NULL);
if ( RT_SUCCESS(rc)
&& !memcmp(Hdr.szMagic, VDIOLOG_MAGIC, sizeof(Hdr.szMagic)))
{
pIoLogger->fFlags = RT_LE2H_U32(Hdr.fFlags);
pIoLogger->offWriteNext = cbLog;
pIoLogger->offReadNext = sizeof(Hdr);
pIoLogger->idNext = RT_LE2H_U64(Hdr.u64Id);
*phIoLogger = pIoLogger;
}
else if (RT_SUCCESS(rc))
rc = VERR_INVALID_PARAMETER;
}
}
return rc;
}
RTDECL(int) RTUuidFromUtf16(PRTUUID pUuid, PCRTUTF16 pwszString)
{
bool fHaveBraces;
/*
* Validate parameters.
*/
AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
AssertPtrReturn(pwszString, VERR_INVALID_PARAMETER);
fHaveBraces = pwszString[0] == '{';
pwszString += fHaveBraces;
#define MY_CHECK(expr) do { if (RT_UNLIKELY(!(expr))) return VERR_INVALID_UUID_FORMAT; } while (0)
#define MY_ISXDIGIT(ch) (!((ch) & 0xff00) && g_au8Digits[(ch) & 0xff] != 0xff)
MY_CHECK(MY_ISXDIGIT(pwszString[ 0]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 1]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 2]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 3]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 4]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 5]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 6]));
MY_CHECK(MY_ISXDIGIT(pwszString[ 7]));
MY_CHECK(pwszString[ 8] == '-');
MY_CHECK(MY_ISXDIGIT(pwszString[ 9]));
MY_CHECK(MY_ISXDIGIT(pwszString[10]));
MY_CHECK(MY_ISXDIGIT(pwszString[11]));
MY_CHECK(MY_ISXDIGIT(pwszString[12]));
MY_CHECK(pwszString[13] == '-');
MY_CHECK(MY_ISXDIGIT(pwszString[14]));
MY_CHECK(MY_ISXDIGIT(pwszString[15]));
MY_CHECK(MY_ISXDIGIT(pwszString[16]));
MY_CHECK(MY_ISXDIGIT(pwszString[17]));
MY_CHECK(pwszString[18] == '-');
MY_CHECK(MY_ISXDIGIT(pwszString[19]));
MY_CHECK(MY_ISXDIGIT(pwszString[20]));
MY_CHECK(MY_ISXDIGIT(pwszString[21]));
MY_CHECK(MY_ISXDIGIT(pwszString[22]));
MY_CHECK(pwszString[23] == '-');
MY_CHECK(MY_ISXDIGIT(pwszString[24]));
MY_CHECK(MY_ISXDIGIT(pwszString[25]));
MY_CHECK(MY_ISXDIGIT(pwszString[26]));
MY_CHECK(MY_ISXDIGIT(pwszString[27]));
MY_CHECK(MY_ISXDIGIT(pwszString[28]));
MY_CHECK(MY_ISXDIGIT(pwszString[29]));
MY_CHECK(MY_ISXDIGIT(pwszString[30]));
MY_CHECK(MY_ISXDIGIT(pwszString[31]));
MY_CHECK(MY_ISXDIGIT(pwszString[32]));
MY_CHECK(MY_ISXDIGIT(pwszString[33]));
MY_CHECK(MY_ISXDIGIT(pwszString[34]));
MY_CHECK(MY_ISXDIGIT(pwszString[35]));
if (fHaveBraces)
MY_CHECK(pwszString[36] == '}');
MY_CHECK(!pwszString[36 + fHaveBraces]);
#undef MY_ISXDIGIT
#undef MY_CHECK
/*
* Inverse of RTUuidToUtf8 (see above).
*/
#define MY_TONUM(ch) (g_au8Digits[(ch) & 0xff])
pUuid->Gen.u32TimeLow = RT_LE2H_U32((uint32_t)MY_TONUM(pwszString[ 0]) << 28
| (uint32_t)MY_TONUM(pwszString[ 1]) << 24
| (uint32_t)MY_TONUM(pwszString[ 2]) << 20
| (uint32_t)MY_TONUM(pwszString[ 3]) << 16
| (uint32_t)MY_TONUM(pwszString[ 4]) << 12
| (uint32_t)MY_TONUM(pwszString[ 5]) << 8
| (uint32_t)MY_TONUM(pwszString[ 6]) << 4
| (uint32_t)MY_TONUM(pwszString[ 7]));
pUuid->Gen.u16TimeMid = RT_LE2H_U16((uint16_t)MY_TONUM(pwszString[ 9]) << 12
| (uint16_t)MY_TONUM(pwszString[10]) << 8
| (uint16_t)MY_TONUM(pwszString[11]) << 4
| (uint16_t)MY_TONUM(pwszString[12]));
pUuid->Gen.u16TimeHiAndVersion = RT_LE2H_U16(
(uint16_t)MY_TONUM(pwszString[14]) << 12
| (uint16_t)MY_TONUM(pwszString[15]) << 8
| (uint16_t)MY_TONUM(pwszString[16]) << 4
| (uint16_t)MY_TONUM(pwszString[17]));
pUuid->Gen.u8ClockSeqHiAndReserved =
(uint16_t)MY_TONUM(pwszString[19]) << 4
| (uint16_t)MY_TONUM(pwszString[20]);
pUuid->Gen.u8ClockSeqLow =
(uint16_t)MY_TONUM(pwszString[21]) << 4
| (uint16_t)MY_TONUM(pwszString[22]);
pUuid->Gen.au8Node[0] = (uint8_t)MY_TONUM(pwszString[24]) << 4
| (uint8_t)MY_TONUM(pwszString[25]);
pUuid->Gen.au8Node[1] = (uint8_t)MY_TONUM(pwszString[26]) << 4
| (uint8_t)MY_TONUM(pwszString[27]);
pUuid->Gen.au8Node[2] = (uint8_t)MY_TONUM(pwszString[28]) << 4
| (uint8_t)MY_TONUM(pwszString[29]);
pUuid->Gen.au8Node[3] = (uint8_t)MY_TONUM(pwszString[30]) << 4
| (uint8_t)MY_TONUM(pwszString[31]);
pUuid->Gen.au8Node[4] = (uint8_t)MY_TONUM(pwszString[32]) << 4
| (uint8_t)MY_TONUM(pwszString[33]);
pUuid->Gen.au8Node[5] = (uint8_t)MY_TONUM(pwszString[34]) << 4
| (uint8_t)MY_TONUM(pwszString[35]);
#undef MY_TONUM
return VINF_SUCCESS;
}
/**
* Converts the on disk BSD label to the host endianness.
*
* @returns Whether the given label structure is a valid BSD disklabel.
* @param pBsdLabel Pointer to the BSD disklabel to decode.
*/
static bool rtDvmFmtBsdLblDiskLabelDecode(PBsdLabel pBsdLabel)
{
pBsdLabel->u32Magic = RT_LE2H_U32(pBsdLabel->u32Magic);
pBsdLabel->u16DriveType = RT_LE2H_U16(pBsdLabel->u16DriveType);
pBsdLabel->u16SubType = RT_LE2H_U16(pBsdLabel->u16SubType);
pBsdLabel->cbSector = RT_LE2H_U32(pBsdLabel->cbSector);
pBsdLabel->cSectorsPerTrack = RT_LE2H_U32(pBsdLabel->cSectorsPerTrack);
pBsdLabel->cTracksPerCylinder = RT_LE2H_U32(pBsdLabel->cTracksPerCylinder);
pBsdLabel->cDataCylindersPerUnit = RT_LE2H_U32(pBsdLabel->cDataCylindersPerUnit);
pBsdLabel->cDataSectorsPerCylinder = RT_LE2H_U32(pBsdLabel->cDataSectorsPerCylinder);
pBsdLabel->cSectorsPerUnit = RT_LE2H_U32(pBsdLabel->cSectorsPerUnit);
pBsdLabel->cSpareSectorsPerTrack = RT_LE2H_U16(pBsdLabel->cSpareSectorsPerTrack);
pBsdLabel->cSpareSectorsPerCylinder = RT_LE2H_U16(pBsdLabel->cSpareSectorsPerCylinder);
pBsdLabel->cSpareCylindersPerUnit = RT_LE2H_U32(pBsdLabel->cSpareCylindersPerUnit);
pBsdLabel->cRotationsPerMinute = RT_LE2H_U16(pBsdLabel->cRotationsPerMinute);
pBsdLabel->uSectorInterleave = RT_LE2H_U16(pBsdLabel->uSectorInterleave);
pBsdLabel->uSectorSkewPerTrack = RT_LE2H_U16(pBsdLabel->uSectorSkewPerTrack);
pBsdLabel->uSectorSkewPerCylinder = RT_LE2H_U16(pBsdLabel->uSectorSkewPerCylinder);
pBsdLabel->usHeadSwitch = RT_LE2H_U16(pBsdLabel->usHeadSwitch);
pBsdLabel->usTrackSeek = RT_LE2H_U16(pBsdLabel->usTrackSeek);
pBsdLabel->fFlags = RT_LE2H_U32(pBsdLabel->fFlags);
for (unsigned i = 0; i < RT_ELEMENTS(pBsdLabel->au32DriveData); i++)
pBsdLabel->au32DriveData[i] = RT_LE2H_U32(pBsdLabel->au32DriveData[i]);
for (unsigned i = 0; i < RT_ELEMENTS(pBsdLabel->au32Reserved); i++)
pBsdLabel->au32Reserved[i] = RT_LE2H_U32(pBsdLabel->au32Reserved[i]);
pBsdLabel->u32Magic2 = RT_LE2H_U32(pBsdLabel->u32Magic2);
pBsdLabel->u16ChkSum = RT_LE2H_U16(pBsdLabel->u16ChkSum);
pBsdLabel->cPartitions = RT_LE2H_U16(pBsdLabel->cPartitions);
pBsdLabel->cbBootArea = RT_LE2H_U32(pBsdLabel->cbBootArea);
pBsdLabel->cbFsSuperBlock = RT_LE2H_U32(pBsdLabel->cbFsSuperBlock);
/* Check the magics now. */
if ( pBsdLabel->u32Magic != RTDVM_BSDLBL_MAGIC
|| pBsdLabel->u32Magic2 != RTDVM_BSDLBL_MAGIC
|| pBsdLabel->cPartitions != RTDVM_BSDLBL_MAX_PARTITIONS)
return false;
/* Convert the partitions array. */
for (unsigned i = 0; i < RT_ELEMENTS(pBsdLabel->aPartitions); i++)
rtDvmFmtBsdLblDiskLabelDecodePartition(&pBsdLabel->aPartitions[i]);
/* Check the checksum now. */
uint16_t u16ChkSumSaved = pBsdLabel->u16ChkSum;
pBsdLabel->u16ChkSum = 0;
if (u16ChkSumSaved != rtDvmFmtBsdLblDiskLabelChkSum(pBsdLabel))
return false;
pBsdLabel->u16ChkSum = u16ChkSumSaved;
return true;
}
VBOXDDU_DECL(int) VDDbgIoLogEventGetStartDiscard(VDIOLOGGER hIoLogger, uint64_t *pidEvent, bool *pfAsync,
PRTRANGE *ppaRanges, unsigned *pcRanges)
{
int rc = VINF_SUCCESS;
PVDIOLOGGERINT pIoLogger = hIoLogger;
AssertPtrReturn(pIoLogger, VERR_INVALID_HANDLE);
AssertPtrReturn(pidEvent, VERR_INVALID_POINTER);
AssertPtrReturn(pfAsync, VERR_INVALID_POINTER);
rc = RTSemFastMutexRequest(pIoLogger->hMtx);
AssertRCReturn(rc, rc);
if ( pIoLogger->u32EventTypeNext == VDIOLOG_EVENT_START
&& pIoLogger->enmReqTypeNext == VDDBGIOLOGREQ_DISCARD)
{
IoLogEntryStart Entry;
rc = RTFileReadAt(pIoLogger->hFile, pIoLogger->offReadNext, &Entry, sizeof(Entry), NULL);
if (RT_SUCCESS(rc))
{
PRTRANGE paRanges = NULL;
IoLogEntryDiscard DiscardRange;
pIoLogger->offReadNext += sizeof(Entry);
*pfAsync = RT_BOOL(Entry.u8AsyncIo);
*pidEvent = RT_LE2H_U64(Entry.u64Id);
*pcRanges = RT_LE2H_U32(Entry.Discard.cRanges);
paRanges = (PRTRANGE)RTMemAllocZ(*pcRanges * sizeof(RTRANGE));
if (paRanges)
{
for (unsigned i = 0; i < *pcRanges; i++)
{
rc = RTFileReadAt(pIoLogger->hFile, pIoLogger->offReadNext + i*sizeof(DiscardRange),
&DiscardRange, sizeof(DiscardRange), NULL);
if (RT_FAILURE(rc))
break;
paRanges[i].offStart = RT_LE2H_U64(DiscardRange.u64Off);
paRanges[i].cbRange = RT_LE2H_U32(DiscardRange.u32Discard);
}
if (RT_SUCCESS(rc))
{
pIoLogger->offReadNext += *pcRanges * sizeof(DiscardRange);
*ppaRanges = paRanges;
}
else
{
pIoLogger->offReadNext -= sizeof(Entry);
RTMemFree(paRanges);
}
}
else
rc = VERR_NO_MEMORY;
}
}
else
rc = VERR_INVALID_STATE;
if (RT_SUCCESS(rc))
pIoLogger->u32EventTypeNext = 0;
RTSemFastMutexRelease(pIoLogger->hMtx);
return rc;
}
