ClientId::rtStrFormat(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
const char *pszType, void const *pvValue,
int cchWidth, int cchPrecision, unsigned fFlags,
void *pvUser)
{
const ClientId *id = static_cast<const ClientId *>(pvValue);
size_t cb = 0;
AssertReturn(strcmp(pszType, "id") == 0, 0);
RT_NOREF(pszType);
RT_NOREF(cchWidth, cchPrecision, fFlags);
RT_NOREF(pvUser);
if (id == NULL)
{
return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
"<NULL>");
}
if (id->m_id.present())
{
const OptClientId::value_t &idopt = id->m_id.value();
cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
"[");
for (size_t i = 0; i < idopt.size(); ++i)
{
cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
"%s%02x", (i == 0 ? "" : ":"), idopt[i]);
}
cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
"] (");
}
cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
"%RTmac", &id->m_mac);
if (id->m_id.present())
{
cb += RTStrFormat(pfnOutput, pvArgOutput, NULL, 0,
")");
}
return 0;
}
static DECLCALLBACK(int) usbProxyWinReset(PUSBPROXYDEV pProxyDev, bool fResetOnLinux)
{
RT_NOREF(fResetOnLinux);
PPRIV_USBW32 pPriv = USBPROXYDEV_2_DATA(pProxyDev, PPRIV_USBW32);
DWORD cbReturned;
int rc;
Assert(pPriv);
Log(("usbproxy: Reset %x\n", pPriv->hDev));
/* Here we just need to assert reset signalling on the USB device */
cbReturned = 0;
if (DeviceIoControl(pPriv->hDev, SUPUSB_IOCTL_USB_RESET, NULL, 0, NULL, 0, &cbReturned, NULL))
{
#if 0 /** @todo this needs to be enabled if windows chooses a default config. Test with the TrekStor GO Stick. */
pProxyDev->iActiveCfg = 1;
pProxyDev->cIgnoreSetConfigs = 2;
#else
pProxyDev->iActiveCfg = -1;
pProxyDev->cIgnoreSetConfigs = 0;
#endif
return VINF_SUCCESS;
}
rc = GetLastError();
if (rc == ERROR_DEVICE_REMOVED)
{
Log(("usbproxy: device %p unplugged!!\n", pPriv->hDev));
pProxyDev->fDetached = true;
}
return RTErrConvertFromWin32(rc);
}
DECLHIDDEN(size_t) rtStrFormatKernelAddress(char *pszBuf, size_t cbBuf, RTR0INTPTR uPtr, signed int cchWidth,
signed int cchPrecision, unsigned int fFlags)
{
#ifndef DEBUG
RT_NOREF(uPtr, cchWidth, cchPrecision);
# if R0_ARCH_BITS == 64
static const char s_szObfuscated[] = "0xXXXXXXXXXXXXXXXX";
# else
static const char s_szObfuscated[] = "0xXXXXXXXX";
# endif
size_t cbSrc = sizeof(s_szObfuscated);
const char *pszSrc = s_szObfuscated;
if (!(fFlags & RTSTR_F_SPECIAL))
{
pszSrc += 2;
cbSrc -= 2;
}
if (cbSrc <= cbBuf)
{
memcpy(pszBuf, pszSrc, cbSrc);
return cbSrc - 1;
}
AssertFailed();
memcpy(pszBuf, pszSrc, cbBuf);
pszBuf[cbBuf - 1] = '\0';
return cbBuf - 1;
#else /* DEBUG */
Assert(cbBuf >= 64);
return RTStrFormatNumber(pszBuf, uPtr, 16, cchWidth, cchPrecision, fFlags);
#endif /* DEBUG */
}
/**
* Receive thread loop.
*
* @returns VINF_SUCCESS
* @param hThreadSelf Thread handle to this thread.
* @param pvUser User argument.
*/
static DECLCALLBACK(int) drvTCPListenLoop(RTTHREAD hThreadSelf, void *pvUser)
{
RT_NOREF(hThreadSelf);
PDRVTCP pThis = (PDRVTCP)pvUser;
while (RT_LIKELY(!pThis->fShutdown))
{
RTSOCKET hTcpSockNew = NIL_RTSOCKET;
int rc = RTTcpServerListen2(pThis->hTcpServ, &hTcpSockNew);
if (RT_SUCCESS(rc))
{
if (pThis->hTcpSock != NIL_RTSOCKET)
{
LogRel(("DrvTCP%d: only single connection supported\n", pThis->pDrvIns->iInstance));
RTTcpServerDisconnectClient2(hTcpSockNew);
}
else
{
pThis->hTcpSock = hTcpSockNew;
/* Inform the poller about the new socket. */
drvTcpPollerKick(pThis, DRVTCP_WAKEUP_REASON_NEW_CONNECTION);
}
}
}
return VINF_SUCCESS;
}
void VBoxDispDumpPSO(SURFOBJ *pso, char *s)
{
RT_NOREF(pso, s);
if (pso)
{
LOG(("Surface %s: %p\n"
" DHSURF dhsurf = %p\n"
" HSURF hsurf = %p\n"
" DHPDEV dhpdev = %p\n"
" HDEV hdev = %p\n"
" SIZEL sizlBitmap = %dx%d\n"
" ULONG cjBits = %p\n"
" PVOID pvBits = %p\n"
" PVOID pvScan0 = %p\n"
" LONG lDelta = %p\n"
" ULONG iUniq = %p\n"
" ULONG iBitmapFormat = %p\n"
" USHORT iType = %p\n"
" USHORT fjBitmap = %p",
s, pso, pso->dhsurf, pso->hsurf, pso->dhpdev, pso->hdev,
pso->sizlBitmap.cx, pso->sizlBitmap.cy, pso->cjBits, pso->pvBits,
pso->pvScan0, pso->lDelta, pso->iUniq, pso->iBitmapFormat, pso->iType, pso->fjBitmap));
}
else
{
LOG(("Surface %s: %p", s, pso));
}
}
/**
* Writes a frame packet to the buffer.
*
* @returns VBox status code.
* @param pBuf The buffer.
* @param pRingBuf The ring buffer to read from.
* @param cSegs The number of segments.
* @param paSegs The segments.
*/
int VBoxNetIntIfRingWriteFrame(PINTNETBUF pBuf, PINTNETRINGBUF pRingBuf, size_t cSegs, PCINTNETSEG paSegs)
{
RT_NOREF(pBuf);
/*
* Validate input.
*/
AssertPtr(pBuf);
AssertPtr(pRingBuf);
AssertPtr(paSegs);
Assert(cSegs > 0);
/*
* Calc frame size.
*/
uint32_t cbFrame = 0;
for (size_t iSeg = 0; iSeg < cSegs; iSeg++)
cbFrame += paSegs[iSeg].cb;
Assert(cbFrame >= sizeof(RTMAC) * 2);
/*
* Allocate a frame, copy the data and commit it.
*/
PINTNETHDR pHdr = NULL;
void *pvFrame = NULL;
int rc = IntNetRingAllocateFrame(pRingBuf, cbFrame, &pHdr, &pvFrame);
if (RT_SUCCESS(rc))
{
vboxnetIntIfCopySG(pvFrame, cSegs, paSegs);
IntNetRingCommitFrame(pRingBuf, pHdr);
return VINF_SUCCESS;
}
return rc;
}
VOID APIENTRY VBoxDispDrvDisableDirectDraw(DHPDEV dhpdev)
{
RT_NOREF(dhpdev);
LOGF_ENTER();
LOGF_LEAVE();
return;
}
int vboxVhwaHlpPopulateSurInfo(VBOXVHWA_SURFACEDESC *pInfo, PVBOXWDDM_ALLOCATION pSurf,
uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
{
RT_NOREF(VidPnSourceId);
memset(pInfo, 0, sizeof(VBOXVHWA_SURFACEDESC));
#if 0
/**
* The following breaks 2D accelerated video playback because this method is called just after the surface was created
* and most its members are still 0.
*
* @todo: Not 100% sure this is the correct way. It looks like the SegmentId specifies where the memory
* for the surface is stored (VRAM vs. system memory) but because this method is only used
* to query some parameters (using VBOXVHWACMD_SURF_GETINFO) and this command doesn't access any surface memory
* on the host it should be safe.
*/
if (pSurf->AllocData.Addr.SegmentId != 1)
{
WARN(("invalid segment id!"));
return VERR_INVALID_PARAMETER;
}
#endif
pInfo->height = pSurf->AllocData.SurfDesc.height;
pInfo->width = pSurf->AllocData.SurfDesc.width;
pInfo->flags |= VBOXVHWA_SD_HEIGHT | VBOXVHWA_SD_WIDTH;
if (fFlags & VBOXVHWA_SD_PITCH)
{
pInfo->pitch = pSurf->AllocData.SurfDesc.pitch;
pInfo->flags |= VBOXVHWA_SD_PITCH;
pInfo->sizeX = pSurf->AllocData.SurfDesc.cbSize;
pInfo->sizeY = 1;
}
if (cBackBuffers)
{
pInfo->cBackBuffers = cBackBuffers;
pInfo->flags |= VBOXVHWA_SD_BACKBUFFERCOUNT;
}
else
pInfo->cBackBuffers = 0;
pInfo->Reserved = 0;
/** @todo color keys */
// pInfo->DstOverlayCK;
// pInfo->DstBltCK;
// pInfo->SrcOverlayCK;
// pInfo->SrcBltCK;
int rc = vboxVhwaHlpTranslateFormat(&pInfo->PixelFormat, pSurf->AllocData.SurfDesc.format);
AssertRC(rc);
if (RT_SUCCESS(rc))
{
pInfo->flags |= VBOXVHWA_SD_PIXELFORMAT;
pInfo->surfCaps = fSCaps;
pInfo->flags |= VBOXVHWA_SD_CAPS;
pInfo->offSurface = pSurf->AllocData.Addr.offVram;
}
return rc;
}
NTSTATUS VBoxMRxCreateSrvCall(PMRX_SRV_CALL pSrvCall, PMRX_SRVCALL_CALLBACK_CONTEXT pCallbackContext)
{
PMRX_SRVCALLDOWN_STRUCTURE SrvCalldownStructure = (PMRX_SRVCALLDOWN_STRUCTURE)(pCallbackContext->SrvCalldownStructure);
RT_NOREF(pSrvCall);
Log(("VBOXSF: MRxCreateSrvCall: %p.\n", pSrvCall));
if (IoGetCurrentProcess() == RxGetRDBSSProcess())
{
Log(("VBOXSF: MRxCreateSrvCall: Called in context of RDBSS process\n"));
vbsfExecuteCreateSrvCall(pCallbackContext);
}
else
{
NTSTATUS Status;
Log(("VBOXSF: MRxCreateSrvCall: Dispatching to worker thread\n"));
Status = RxDispatchToWorkerThread(VBoxMRxDeviceObject, DelayedWorkQueue,
(PWORKER_THREAD_ROUTINE)vbsfExecuteCreateSrvCall,
pCallbackContext);
if (Status == STATUS_SUCCESS)
Log(("VBOXSF: MRxCreateSrvCall: queued\n"));
else
{
pCallbackContext->Status = Status;
SrvCalldownStructure->CallBack(pCallbackContext);
}
}
/* RDBSS expect this. */
return STATUS_PENDING;
}
/**
* Starts a worker thread and wait for it to complete.
*
* We cannot use RTThreadCreate since we're already owner of the RW lock.
*/
static int rtSchedRunThread(void *(*pfnThread)(void *pvArg), void *pvArg, bool fUsePriorityProxy)
{
/*
* Create the thread.
*/
pthread_t Thread;
int rc;
#ifndef RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY
RT_NOREF(fUsePriorityProxy);
#else
if ( fUsePriorityProxy
&& rtThreadPosixPriorityProxyStart())
rc = rtThreadPosixPriorityProxyCall(NULL, (PFNRT)rtSchedRunThreadCallback, 3, &Thread, pfnThread, pvArg);
else
#endif
rc = rtSchedRunThreadCallback(&Thread, pfnThread, pvArg);
if (RT_SUCCESS(rc))
{
/*
* Wait for the thread to finish.
*/
void *pvRet = (void *)-1;
do
{
rc = pthread_join(Thread, &pvRet);
} while (rc == EINTR);
if (rc)
return RTErrConvertFromErrno(rc);
return (int)(uintptr_t)pvRet;
}
return rc;
}
NTSTATUS VBoxMRxFinalizeVNetRoot(IN PMRX_V_NET_ROOT pVNetRoot, IN PBOOLEAN ForceDisconnect)
{
RT_NOREF(pVNetRoot, ForceDisconnect);
Log(("VBOXSF: MRxFinalizeVNetRoot: V_NET_ROOT %p, NET_ROOT %p\n", pVNetRoot, pVNetRoot->pNetRoot));
return STATUS_SUCCESS;
}
/* Called to reset adapter to a given character mode. */
static BOOLEAN
VBoxDrvResetHW(PVOID HwDeviceExtension, ULONG Columns, ULONG Rows)
{
RT_NOREF(Columns, Rows);
PVBOXMP_DEVEXT pExt = (PVBOXMP_DEVEXT) HwDeviceExtension;
LOGF_ENTER();
if (pExt->iDevice==0) /* Primary device */
{
VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ENABLE);
VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_DATA, VBE_DISPI_DISABLED);
#if 0
/* ResetHW is not the place to do such cleanup. See MSDN. */
if (pExt->u.primary.pvReqFlush != NULL)
{
VbglR0GRFree((VMMDevRequestHeader *)pExt->u.primary.pvReqFlush);
pExt->u.primary.pvReqFlush = NULL;
}
VbglR0TerminateClient();
VBoxFreeDisplaysHGSMI(VBoxCommonFromDeviceExt(pExt));
#endif
}
else
{
LOG(("ignoring non primary device %d", pExt->iDevice));
}
LOGF_LEAVE();
/* Tell the system to use VGA BIOS to set the text video mode. */
return FALSE;
}
/**
* Queries information about the object using a specific view, internal version.
*
* @return IPRT status code.
* @param enmView View to use for querying information. Currently ignored.
*/
int DnDURIObject::queryInfoInternal(View enmView)
{
RT_NOREF(enmView);
int rc;
switch (m_enmType)
{
case Type_File:
AssertMsgReturn(RTFileIsValid(u.File.hFile), ("Object has invalid file handle\n"), VERR_INVALID_STATE);
rc = RTFileQueryInfo(u.File.hFile, &u.File.objInfo, RTFSOBJATTRADD_NOTHING);
break;
case Type_Directory:
AssertMsgReturn(RTDirIsValid(u.Dir.hDir), ("Object has invalid directory handle\n"), VERR_INVALID_STATE);
rc = RTDirQueryInfo(u.Dir.hDir, &u.Dir.objInfo, RTFSOBJATTRADD_NOTHING);
break;
default:
rc = VERR_NOT_IMPLEMENTED;
break;
}
return rc;
}
/* Called to enumerate child devices of our adapter, attached monitor(s) in our case */
static VP_STATUS
VBoxDrvGetVideoChildDescriptor(PVOID HwDeviceExtension, PVIDEO_CHILD_ENUM_INFO ChildEnumInfo,
PVIDEO_CHILD_TYPE VideoChildType, PUCHAR pChildDescriptor, PULONG pUId,
PULONG pUnused)
{
RT_NOREF(pChildDescriptor, pUnused);
PVBOXMP_DEVEXT pExt = (PVBOXMP_DEVEXT) HwDeviceExtension;
PAGED_CODE();
LOGF_ENTER();
if (ChildEnumInfo->ChildIndex>0)
{
if ((int)ChildEnumInfo->ChildIndex <= VBoxCommonFromDeviceExt(pExt)->cDisplays)
{
*VideoChildType = Monitor;
*pUId = ChildEnumInfo->ChildIndex;
LOGF_LEAVE();
return VIDEO_ENUM_MORE_DEVICES;
}
}
LOGF_LEAVE();
return ERROR_NO_MORE_DEVICES;
}
static CRMessageOpcodes *
__prependHeader( CRPackBuffer *buf, unsigned int *len, unsigned int senderID )
{
int num_opcodes;
CRMessageOpcodes *hdr;
RT_NOREF(senderID);
CRASSERT( buf );
CRASSERT( buf->opcode_current < buf->opcode_start );
CRASSERT( buf->opcode_current >= buf->opcode_end );
CRASSERT( buf->data_current > buf->data_start );
CRASSERT( buf->data_current <= buf->data_end );
num_opcodes = buf->opcode_start - buf->opcode_current;
hdr = (CRMessageOpcodes *)
( buf->data_start - ( ( num_opcodes + 3 ) & ~0x3 ) - sizeof(*hdr) );
CRASSERT( (void *) hdr >= buf->pack );
hdr->header.type = CR_MESSAGE_OPCODES;
hdr->numOpcodes = num_opcodes;
*len = buf->data_current - (unsigned char *) hdr;
return hdr;
}
/**
* Executes one (or perhaps a few more) IO instruction(s).
*
* @returns VBox status code suitable for EM.
* @param pVM The cross context VM structure.
* @param pVCpu The cross context virtual CPU structure.
*/
static int emR3HmExecuteIOInstruction(PVM pVM, PVMCPU pVCpu)
{
RT_NOREF(pVM);
STAM_PROFILE_START(&pVCpu->em.s.StatIOEmu, a);
VBOXSTRICTRC rcStrict;
uint32_t idxContinueExitRec = pVCpu->em.s.idxContinueExitRec;
RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
if (idxContinueExitRec >= RT_ELEMENTS(pVCpu->em.s.aExitRecords))
{
/*
* Hand it over to the interpreter.
*/
CPUM_IMPORT_EXTRN_RET(pVCpu, IEM_CPUMCTX_EXTRN_MUST_MASK);
rcStrict = IEMExecOne(pVCpu);
LogFlow(("emR3HmExecuteIOInstruction: %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
}
else
{
RT_UNTRUSTED_VALIDATED_FENCE();
CPUM_IMPORT_EXTRN_RET(pVCpu, IEM_CPUMCTX_EXTRN_MUST_MASK);
rcStrict = EMHistoryExec(pVCpu, &pVCpu->em.s.aExitRecords[idxContinueExitRec], 0);
LogFlow(("emR3HmExecuteIOInstruction: %Rrc (EMHistoryExec)\n", VBOXSTRICTRC_VAL(rcStrict)));
STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIoRestarted);
}
STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->StatIoIem);
STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
return VBOXSTRICTRC_TODO(rcStrict);
}
/**
* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
*/
static DECLCALLBACK(bool) rtVfsChainGzip_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
{
RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
return false;
}
STDMETHODIMP VBoxDnDDropTarget::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
RT_NOREF(pt);
AssertPtrReturn(pdwEffect, E_INVALIDARG);
#ifdef DEBUG_andy
LogFlowFunc(("cfFormat=%RI16, grfKeyState=0x%x, x=%ld, y=%ld\n",
mFormatEtc.cfFormat, grfKeyState, pt.x, pt.y));
#endif
if (mFormatEtc.cfFormat)
{
/* Note: pt is not used since we don't need to differentiate within our
* proxy window. */
*pdwEffect = VBoxDnDDropTarget::GetDropEffect(grfKeyState, *pdwEffect);
}
else
{
*pdwEffect = DROPEFFECT_NONE;
}
#ifdef DEBUG_andy
LogFlowFunc(("Returning *pdwEffect=%ld\n", *pdwEffect));
#endif
return S_OK;
}
int CrFbDisplayBase::UpdateBegin(struct CR_FRAMEBUFFER *pFb)
{
RT_NOREF(pFb);
++mcUpdates;
Assert(!mFlags.fRegionsShanged || mcUpdates > 1);
return VINF_SUCCESS;
}
/**
* Read a MMIO register.
*
* @returns VBox status code suitable for scheduling.
* @param pDevIns The device instance.
* @param pvUser A user argument (ignored).
* @param GCPhysAddr The physical address being written to. (This is within our MMIO memory range.)
* @param pv Where to put the data we read.
* @param cb The size of the read.
*/
PDMBOTHCBDECL(int) ox958MmioRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr, void *pv, unsigned cb)
{
PDEVOX958 pThis = PDMINS_2_DATA(pDevIns, PDEVOX958);
uint32_t offReg = (GCPhysAddr - pThis->GCPhysMMIO);
int rc = VINF_SUCCESS;
RT_NOREF(pThis, pvUser);
if (offReg < OX958_REG_UART_REGION_OFFSET)
{
uint32_t *pu32 = (uint32_t *)pv;
Assert(cb == 4);
switch (offReg)
{
case OX958_REG_CC_REV_ID:
*pu32 = 0x00070002;
break;
case OX958_REG_UART_CNT:
*pu32 = pThis->cUarts;
break;
case OX958_REG_UART_IRQ_STS:
*pu32 = ASMAtomicReadU32(&pThis->u32RegIrqStsGlob);
break;
case OX958_REG_UART_IRQ_ENABLE:
*pu32 = ASMAtomicReadU32(&pThis->u32RegIrqEnGlob);
break;
case OX958_REG_UART_IRQ_DISABLE:
*pu32 = ~ASMAtomicReadU32(&pThis->u32RegIrqEnGlob);
break;
case OX958_REG_UART_WAKE_IRQ_ENABLE:
*pu32 = ASMAtomicReadU32(&pThis->u32RegIrqEnWake);
break;
case OX958_REG_UART_WAKE_IRQ_DISABLE:
*pu32 = ~ASMAtomicReadU32(&pThis->u32RegIrqEnWake);
break;
default:
rc = VINF_IOM_MMIO_UNUSED_00;
}
}
else
{
/* Figure out the UART accessed from the offset. */
offReg -= OX958_REG_UART_REGION_OFFSET;
uint32_t iUart = offReg / OX958_REG_UART_REGION_SIZE;
uint32_t offUartReg = offReg % OX958_REG_UART_REGION_SIZE;
if (iUart < pThis->cUarts)
{
POX958UART pUart = &pThis->aUarts[iUart];
rc = ox958UartRegRead(pThis, pUart, offUartReg, pv, cb);
if (rc == VINF_IOM_R3_IOPORT_READ)
rc = VINF_IOM_R3_MMIO_READ;
}
else
rc = VINF_IOM_MMIO_UNUSED_00;
}
return rc;
}
void packspuSetVBoxConfiguration( const SPU *child_spu )
{
RT_NOREF(child_spu);
__setDefaults();
pack_spu.emit_GATHER_POST_SWAPBUFFERS = 0;
pack_spu.swapbuffer_sync = 0;
pack_spu.name = crStrdup("vboxhgcm://llp:7000");
pack_spu.buffer_size = 5 * 1024 * 1024;
}
NTSTATUS VBoxMRxFinalizeSrvCall(PMRX_SRV_CALL pSrvCall, BOOLEAN Force)
{
RT_NOREF(Force);
Log(("VBOXSF: MRxFinalizeSrvCall %p, ctx = %p.\n", pSrvCall, pSrvCall->Context));
pSrvCall->Context = NULL;
return STATUS_SUCCESS;
}
void CrFbDisplayBase::UpdateEnd(struct CR_FRAMEBUFFER *pFb)
{
RT_NOREF(pFb);
--mcUpdates;
Assert(mcUpdates < UINT32_MAX/2);
if (!mcUpdates)
onUpdateEnd();
}
/** @interface_method_impl{PDMDEVREG,pfnRelocate} */
static DECLCALLBACK(void) ox958R3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
{
PDEVOX958 pThis = PDMINS_2_DATA(pDevIns, PDEVOX958);
RT_NOREF(offDelta);
pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
for (uint32_t i = 0; i < pThis->cUarts; i++)
uartR3Relocate(&pThis->aUarts[i].UartCore, offDelta);
}
/** @interface_method_impl{PDMDEVREG,pfnDetach} */
static DECLCALLBACK(void) ox958R3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
{
PDEVOX958 pThis = PDMINS_2_DATA(pDevIns, PDEVOX958);
AssertReturnVoid(iLUN >= pThis->cUarts);
RT_NOREF(fFlags);
return uartR3Detach(&pThis->aUarts[iLUN].UartCore);
}
/**
* Start the kernel module.
*/
static kern_return_t vboxSfDwnModuleLoad(struct kmod_info *pKModInfo, void *pvData)
{
RT_NOREF(pKModInfo, pvData);
#ifdef DEBUG
printf("vboxSfDwnModuleLoad\n");
RTLogBackdoorPrintf("vboxSfDwnModuleLoad\n");
#endif
/*
* Initialize IPRT and the ring-0 guest library.
*/
int rc = RTR0Init(0);
if (RT_SUCCESS(rc))
{
rc = VbglR0SfInit();
if (RT_SUCCESS(rc))
{
/*
* Register the file system.
*/
rc = vfs_fsadd(&g_VBoxSfFsEntry, &g_pVBoxSfVfsTableEntry);
if (rc == 0)
{
/*
* Try find VBoxGuest and connect to the shared folders service on the host.
*/
/** @todo should we just ignore the error here and retry at mount time?
* Technically, VBoxGuest should be available since it's one of our
* dependencies... */
vboxSfDwnConnect();
/*
* We're done for now. We'll deal with
*/
LogRel(("VBoxSF: loaded\n"));
return KERN_SUCCESS;
}
printf("VBoxSF: vfs_fsadd failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: vfs_fsadd failed: %d\n", rc);
VbglR0SfTerm();
}
else
{
printf("VBoxSF: VbglR0SfInit failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: VbglR0SfInit failed: %Rrc\n", rc);
}
RTR0Term();
}
else
{
printf("VBoxSF: RTR0Init failed: %d\n", rc);
RTLogBackdoorPrintf("VBoxSF: RTR0Init failed: %Rrc\n", rc);
}
return KERN_FAILURE;
}
static DECLCALLBACK(VOID) vboxMpCrShgsmiTransportSendReadAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pDdiCmd,
PVOID pvContext)
{
RT_NOREF(pDevExt);
/* we should be called from our DPC routine */
Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
PVBOXMP_CRSHGSMITRANSPORT pCon = (PVBOXMP_CRSHGSMITRANSPORT)pvContext;
PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pDdiCmd);
VBOXVDMACMD RT_UNTRUSTED_VOLATILE_HOST *pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
VBOXVDMACMD_CHROMIUM_CMD RT_UNTRUSTED_VOLATILE_HOST *pBody = VBOXMP_CRSHGSMICON_DR_GET_CRCMD(pHdr);
const UINT cBuffers = 2;
Assert(pBody->cBuffers == cBuffers);
VBOXMP_CRHGSMICMD_READ RT_UNTRUSTED_VOLATILE_HOST *pWrData = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pHdr, cBuffers, VBOXMP_CRHGSMICMD_READ);
CRVBOXHGSMIREAD RT_UNTRUSTED_VOLATILE_HOST *pCmd = &pWrData->Cmd;
VBOXVDMACMD_CHROMIUM_BUFFER RT_UNTRUSTED_VOLATILE_HOST *pBufCmd = &pBody->aBuffers[0];
Assert(pBufCmd->cbBuffer == sizeof (CRVBOXHGSMIREAD));
CRVBOXHGSMIREAD RT_UNTRUSTED_VOLATILE_HOST *pWr = (CRVBOXHGSMIREAD*)vboxMpCrShgsmiTransportBufFromOffset(pCon, pBufCmd->offBuffer);
PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION pfnCompletion = (PFNVBOXMP_CRSHGSMITRANSPORT_SENDREADASYNC_COMPLETION)pBufCmd->u64GuestData;
VBOXVDMACMD_CHROMIUM_BUFFER RT_UNTRUSTED_VOLATILE_HOST *pRxBuf = &pBody->aBuffers[1];
VBOXMP_CRSHGSMICON_BUFDR *pWbDr = (PVBOXMP_CRSHGSMICON_BUFDR)pRxBuf->u64GuestData;
void RT_UNTRUSTED_VOLATILE_HOST *pvRx = NULL;
uint32_t cbRx = 0;
int rc = pDr->rc;
if (RT_SUCCESS(rc))
{
rc = pWr->hdr.result;
if (RT_SUCCESS(rc))
{
cbRx = pCmd->cbBuffer;
if (cbRx)
pvRx = pWbDr->pvBuf;
}
else
{
WARN(("CRVBOXHGSMIREAD failed, rc %d", rc));
}
}
else
{
WARN(("dma command buffer failed rc %d!", rc));
}
if (pfnCompletion)
{
void RT_UNTRUSTED_VOLATILE_HOST *pvCtx = VBOXMP_CRSHGSMICON_DR_GET_CMDCTX(pHdr, cBuffers,
sizeof(VBOXMP_CRHGSMICMD_READ), void);
pfnCompletion(pCon, rc, pvRx, cbRx, pvCtx);
}
vboxMpCrShgsmiBufCacheFree(pCon, &pCon->WbDrCache, pWbDr);
}
/** @interface_method_impl{PDMDEVREG,pfnAttach} */
static DECLCALLBACK(int) ox958R3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
{
PDEVOX958 pThis = PDMINS_2_DATA(pDevIns, PDEVOX958);
RT_NOREF(fFlags);
if (iLUN >= pThis->cUarts)
return VERR_PDM_LUN_NOT_FOUND;
return uartR3Attach(&pThis->aUarts[iLUN].UartCore, iLUN);
}
/**
* UART core IRQ request callback.
*
* @returns nothing.
* @param pDevIns The device instance.
* @param pUart The UART requesting an IRQ update.
* @param iLUN The UART index.
* @param iLvl IRQ level requested.
*/
PDMBOTHCBDECL(void) ox958IrqReq(PPDMDEVINS pDevIns, PUARTCORE pUart, unsigned iLUN, int iLvl)
{
RT_NOREF(pUart);
PDEVOX958 pThis = PDMINS_2_DATA(pDevIns, PDEVOX958);
if (iLvl)
ASMAtomicOrU32(&pThis->u32RegIrqStsGlob, RT_BIT_32(iLUN));
else
ASMAtomicAndU32(&pThis->u32RegIrqStsGlob, ~RT_BIT_32(iLUN));
ox958IrqUpdate(pThis);
}
NTSTATUS VBoxMRxSrvCallWinnerNotify(IN PMRX_SRV_CALL pSrvCall, IN BOOLEAN ThisMinirdrIsTheWinner, IN OUT PVOID pSrvCallContext)
{
RT_NOREF(ThisMinirdrIsTheWinner, pSrvCallContext);
Log(("VBOXSF: MRxSrvCallWinnerNotify: pSrvCall %p, pSrvCall->Ctx %p, winner %d, context %p\n",
pSrvCall, pSrvCall->Context, ThisMinirdrIsTheWinner, pSrvCallContext));
/* Set it to not NULL. */
pSrvCall->Context = pSrvCall;
return STATUS_SUCCESS;
}
