/**
* Virtio Net device attach rountine.
*
* @param pDevice Pointer to the Virtio device instance.
*
* @return corresponding solaris error code.
*/
static int VirtioNetDevAttach(PVIRTIODEVICE pDevice)
{
LogFlowFunc((VIRTIOLOGNAME ":VirtioNetDevAttach pDevice=%p\n", pDevice));
virtio_net_t *pNet = pDevice->pvDevice;
mac_register_t *pMacRegHandle = mac_alloc(MAC_VERSION);
if (pMacRegHandle)
{
pMacRegHandle->m_driver = pDevice;
pMacRegHandle->m_dip = pDevice->pDip;
pMacRegHandle->m_callbacks = &g_VirtioNetCallbacks;
pMacRegHandle->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
pMacRegHandle->m_min_sdu = 0;
pMacRegHandle->m_max_sdu = 1500; /* @todo verify */
/* @todo should we set the margin size? */
pMacRegHandle->m_src_addr = pNet->MacAddr.au8;
/*
* Get MAC from the host or generate a random MAC address.
*/
if (pDevice->fHostFeatures & VIRTIO_NET_MAC)
{
pDevice->pHyperOps->pfnGet(pDevice, 0 /* offset */, &pNet->MacAddr.au8, sizeof(pNet->MacAddr));
LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: Obtained MAC address from host: %.6Rhxs\n", pNet->MacAddr.au8));
}
else
{
pNet->MacAddr.au8[0] = 0x08;
pNet->MacAddr.au8[1] = 0x00;
pNet->MacAddr.au8[2] = 0x27;
RTRandBytes(&pNet->MacAddr.au8[3], 3);
LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: Generated MAC address %.6Rhxs\n", pNet->MacAddr.au8));
}
int rc = VirtioNetAttachQueues(pDevice);
if (rc == DDI_SUCCESS)
{
rc = mac_register(pMacRegHandle, &pNet->hMac);
if (rc == 0)
{
mac_link_update(pNet->hMac, LINK_STATE_DOWN);
mac_free(pMacRegHandle);
LogFlow((VIRTIOLOGNAME ":VirtioNetDevAttach: successfully registered mac.\n"));
return DDI_SUCCESS;
}
else
LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: mac_register failed. rc=%d\n", rc));
VirtioNetDetachQueues(pDevice);
}
else
LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: VirtioNetAttachQueues failed. rc=%d\n", rc));
mac_free(pMacRegHandle);
}
else
LogRel((VIRTIOLOGNAME ":VirtioNetDevAttach: mac_alloc failed. Invalid version!?!\n"));
return DDI_FAILURE;
}
static int vboxNetAdpSolarisGenerateMac(PRTMAC pMac)
{
pMac->au8[0] = 0x08;
pMac->au8[1] = 0x00;
pMac->au8[2] = 0x27;
RTRandBytes(&pMac->au8[3], 3);
Log((DEVICE_NAME ":VBoxNetAdpSolarisGenerateMac Generated %.*Rhxs\n", sizeof(RTMAC), &pMac));
return VINF_SUCCESS;
}
RTDECL(int) RTUuidCreate(PRTUUID pUuid)
{
/* validate input. */
AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
RTRandBytes(pUuid, sizeof(*pUuid));
pUuid->Gen.u8ClockSeqHiAndReserved = (pUuid->Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80;
pUuid->Gen.u16TimeHiAndVersion = (pUuid->Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000;
return VINF_SUCCESS;
}
/**
* Inits the test pattern.
*
* @returns VBox status code.
*/
static int tstPDMACStressTestPatternInit(void)
{
RTPrintf(TESTCASE ": Creating test pattern. Please wait...\n");
g_cbTestPattern = TEST_PATTERN_SIZE;
g_pbTestPattern = (uint8_t *)RTMemAlloc(g_cbTestPattern);
if (!g_pbTestPattern)
return VERR_NO_MEMORY;
RTRandBytes(g_pbTestPattern, g_cbTestPattern);
return VINF_SUCCESS;
}
static void doMemSaferAllocation(RTTEST hTest)
{
size_t cbAlloc = RTRandS32Ex(1, _1M) * sizeof(uint8_t);
void *pvBuf = NULL;
int rc = RTMemSaferAllocZEx(&pvBuf, cbAlloc, 0);
if (RT_SUCCESS(rc))
{
/* Fill it with random bytes. */
RTRandBytes(pvBuf, cbAlloc);
/* Scrambling test */
doMemSaferScramble(hTest, pvBuf, cbAlloc);
RTMemSaferFree(pvBuf, cbAlloc);
}
else
RTTestIFailed("Allocating %z bytes of secure memory failed with %Rrc\n", cbAlloc, rc);
}
static void doMemSaferScramble(RTTEST hTest, void *pvBuf, size_t cbAlloc)
{
/*
* Fill it with random bytes and make a reference copy of these.
*/
RTRandBytes(pvBuf, cbAlloc);
void *pvRef = RTMemDup(pvBuf, cbAlloc);
RTTESTI_CHECK_RETV(pvRef);
/*
* Scramble the allocation and check that it no longer matches the refernece bytes.
*/
int rc = RTMemSaferScramble(pvBuf, cbAlloc);
if (RT_SUCCESS(rc))
{
if (!memcmp(pvRef, pvBuf, cbAlloc))
RTTestIFailed("Memory blocks must differ (%z bytes, 0x%p vs. 0x%p)!\n",
cbAlloc, pvRef, pvBuf);
else
{
/*
* Check that unscrambling returns the original content.
*/
rc = RTMemSaferUnscramble(pvBuf, cbAlloc);
if (RT_SUCCESS(rc))
{
if (memcmp(pvRef, pvBuf, cbAlloc))
RTTestIFailed("Memory blocks must not differ (%z bytes, 0x%p vs. 0x%p)!\n",
cbAlloc, pvRef, pvBuf);
}
else
RTTestIFailed("Unscrambling %z bytes failed with %Rrc!\n", cbAlloc, rc);
}
}
else
RTTestIFailed("Scrambling %z bytes failed with %Rrc!\n", cbAlloc, rc);
RTMemFree(pvRef);
}
static void doMemWipeThoroughly(RTTEST hTest)
{
for (uint32_t p = 0; p < RTRandU32Ex(1, 64); p++)
{
size_t cbAlloc = RTRandS32Ex(1, _1M) * sizeof(uint8_t);
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Testing wipe #%.02RU32 (%u bytes) ...\n",
p + 1, cbAlloc);
void *pvBuf = RTMemAlloc(cbAlloc);
if (!pvBuf)
{
RTTestIFailed("No memory for first buffer (%z bytes)\n",
cbAlloc);
continue;
}
RTRandBytes(pvBuf, cbAlloc);
void *pvWipe = RTMemDup(pvBuf, cbAlloc);
if (!pvWipe)
{
RTMemFree(pvBuf);
RTTestIFailed("No memory for second buffer (%z bytes)\n",
cbAlloc);
continue;
}
size_t cbWipeRand = RTRandU32Ex(1, cbAlloc);
RTMemWipeThoroughly(pvWipe, RT_MIN(cbAlloc, cbWipeRand), p /* Passes */);
if (!memcmp(pvWipe, pvBuf, cbAlloc))
RTTestIFailed("Memory blocks must differ (%z bytes, 0x%p vs. 0x%p)!\n",
cbAlloc, pvWipe, pvBuf);
RTMemFree(pvWipe);
RTMemFree(pvBuf);
}
}
