void InitD3DExports(const char *vboxName, const char *msName)
{
const char *dllName;
HANDLE hDLL;
if (isVBox3DEnabled() && checkOptions())
dllName = vboxName;
else
dllName = msName;
hDLL = loadSystemDll(dllName);
FillD3DExports(hDLL);
}
/* Checks if 3D is enabled for VM and it works on host machine */
BOOL isVBox3DEnabled(void)
{
DrvValidateVersionProc pDrvValidateVersion;
HANDLE hDLL;
BOOL result = FALSE;
#ifdef VBOX_WDDM_WOW64
hDLL = loadSystemDll("VBoxOGL-x86.dll");
#else
hDLL = loadSystemDll("VBoxOGL.dll");
#endif
/* note: this isn't really needed as our library will refuse to load if it can't connect to host.
so it's in case we'd change it one day.
*/
pDrvValidateVersion = (DrvValidateVersionProc) GetProcAddress(hDLL, "DrvValidateVersion");
if (pDrvValidateVersion)
{
result = pDrvValidateVersion(0);
}
FreeLibrary(hDLL);
return result;
}
/**
* Disables the Windows File Protection for a specified file
* using an undocumented SFC API call. Don't try this at home!
*
* @param hwndParent Window handle of parent.
* @param string_size Size of variable string.
* @param variables The actual variable string.
* @param stacktop Pointer to a pointer to the current stack.
*/
VBOXINSTALLHELPER_EXPORT DisableWFP(HWND hwndParent, int string_size,
TCHAR *variables, stack_t **stacktop)
{
EXDLL_INIT();
TCHAR szFile[MAX_PATH + 1];
HRESULT hr = vboxPopString(szFile, sizeof(szFile) / sizeof(TCHAR));
if (SUCCEEDED(hr))
{
HMODULE hSFC = loadSystemDll("sfc_os.dll"); /** @todo Replace this by RTLdr APIs. */
if (NULL != hSFC)
{
g_pfnSfcFileException = (PFNSFCFILEEXCEPTION)GetProcAddress(hSFC, "SfcFileException");
if (g_pfnSfcFileException == NULL)
{
/* If we didn't get the proc address with the call above, try it harder with
* the (zero based) index of the function list. */
g_pfnSfcFileException = (PFNSFCFILEEXCEPTION)GetProcAddress(hSFC, (LPCSTR)5);
if (g_pfnSfcFileException == NULL)
hr = HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND);
}
}
else
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
if (SUCCEEDED(hr))
{
WCHAR *pwszFile;
hr = vboxChar2WCharAlloc(szFile, &pwszFile);
if (SUCCEEDED(hr))
{
if (g_pfnSfcFileException(0, pwszFile, -1) != 0)
hr = HRESULT_FROM_WIN32(GetLastError());
vboxChar2WCharFree(pwszFile);
}
}
if (hSFC)
FreeLibrary(hSFC);
}
vboxPushResultAsString(hr);
}
static DWORD vboxMdMinidumpCreate(struct _EXCEPTION_POINTERS *pExceptionInfo)
{
WCHAR aszwMdFileName[MAX_PATH];
HANDLE hProcess = GetCurrentProcess();
DWORD ProcessId = GetCurrentProcessId();
MINIDUMP_EXCEPTION_INFORMATION ExceptionInfo;
HANDLE hFile;
DWORD winErr = ERROR_SUCCESS;
if (!g_pfnVBoxMdMiniDumpWriteDump)
{
if (!g_hVBoxMdDbgHelp)
{
g_hVBoxMdDbgHelp = loadSystemDll("DbgHelp.dll");
if (!g_hVBoxMdDbgHelp)
return GetLastError();
}
g_pfnVBoxMdMiniDumpWriteDump = (PFNVBOXDBG_MINIDUMPWRITEDUMP)GetProcAddress(g_hVBoxMdDbgHelp, "MiniDumpWriteDump");
if (!g_pfnVBoxMdMiniDumpWriteDump)
return GetLastError();
}
++g_aszwVBoxMdDumpCount;
memcpy(aszwMdFileName, g_aszwVBoxMdFilePrefix, g_cVBoxMdFilePrefixLen * sizeof (g_aszwVBoxMdFilePrefix[0]));
swprintf(aszwMdFileName + g_cVBoxMdFilePrefixLen, RT_ELEMENTS(aszwMdFileName) - g_cVBoxMdFilePrefixLen, L"%d_%d.dmp", ProcessId, g_aszwVBoxMdDumpCount);
hFile = CreateFileW(aszwMdFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return GetLastError();
ExceptionInfo.ThreadId = GetCurrentThreadId();
ExceptionInfo.ExceptionPointers = pExceptionInfo;
ExceptionInfo.ClientPointers = FALSE;
if (!g_pfnVBoxMdMiniDumpWriteDump(hProcess, ProcessId, hFile, g_enmVBoxMdDumpType, &ExceptionInfo, NULL, NULL))
winErr = GetLastError();
CloseHandle(hFile);
return winErr;
}
HRESULT vboxDispKmtCallbacksInit(PVBOXDISPKMT_CALLBACKS pCallbacks)
{
HRESULT hr = S_OK;
memset(pCallbacks, 0, sizeof (*pCallbacks));
pCallbacks->hGdi32 = loadSystemDll("gdi32.dll");
if (pCallbacks->hGdi32 != NULL)
{
bool bSupported = true;
bool bSupportedWin8 = true;
pCallbacks->pfnD3DKMTOpenAdapterFromHdc = (PFND3DKMT_OPENADAPTERFROMHDC)GetProcAddress(pCallbacks->hGdi32, "D3DKMTOpenAdapterFromHdc");
LogFunc(("pfnD3DKMTOpenAdapterFromHdc = %p\n", pCallbacks->pfnD3DKMTOpenAdapterFromHdc));
bSupported &= !!(pCallbacks->pfnD3DKMTOpenAdapterFromHdc);
pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName = (PFND3DKMT_OPENADAPTERFROMGDIDISPLAYNAME)GetProcAddress(pCallbacks->hGdi32, "D3DKMTOpenAdapterFromGdiDisplayName");
LogFunc(("pfnD3DKMTOpenAdapterFromGdiDisplayName = %p\n", pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName));
bSupported &= !!(pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName);
pCallbacks->pfnD3DKMTCloseAdapter = (PFND3DKMT_CLOSEADAPTER)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCloseAdapter");
LogFunc(("pfnD3DKMTCloseAdapter = %p\n", pCallbacks->pfnD3DKMTCloseAdapter));
bSupported &= !!(pCallbacks->pfnD3DKMTCloseAdapter);
pCallbacks->pfnD3DKMTEscape = (PFND3DKMT_ESCAPE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTEscape");
LogFunc(("pfnD3DKMTEscape = %p\n", pCallbacks->pfnD3DKMTEscape));
bSupported &= !!(pCallbacks->pfnD3DKMTEscape);
pCallbacks->pfnD3DKMTQueryAdapterInfo = (PFND3DKMT_QUERYADAPTERINFO)GetProcAddress(pCallbacks->hGdi32, "D3DKMTQueryAdapterInfo");
LogFunc(("pfnD3DKMTQueryAdapterInfo = %p\n", pCallbacks->pfnD3DKMTQueryAdapterInfo));
bSupported &= !!(pCallbacks->pfnD3DKMTQueryAdapterInfo);
pCallbacks->pfnD3DKMTCreateDevice = (PFND3DKMT_CREATEDEVICE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateDevice");
LogFunc(("pfnD3DKMTCreateDevice = %p\n", pCallbacks->pfnD3DKMTCreateDevice));
bSupported &= !!(pCallbacks->pfnD3DKMTCreateDevice);
pCallbacks->pfnD3DKMTDestroyDevice = (PFND3DKMT_DESTROYDEVICE)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyDevice");
LogFunc(("pfnD3DKMTDestroyDevice = %p\n", pCallbacks->pfnD3DKMTDestroyDevice));
bSupported &= !!(pCallbacks->pfnD3DKMTDestroyDevice);
pCallbacks->pfnD3DKMTCreateContext = (PFND3DKMT_CREATECONTEXT)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateContext");
LogFunc(("pfnD3DKMTCreateContext = %p\n", pCallbacks->pfnD3DKMTCreateContext));
bSupported &= !!(pCallbacks->pfnD3DKMTCreateContext);
pCallbacks->pfnD3DKMTDestroyContext = (PFND3DKMT_DESTROYCONTEXT)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyContext");
LogFunc(("pfnD3DKMTDestroyContext = %p\n", pCallbacks->pfnD3DKMTDestroyContext));
bSupported &= !!(pCallbacks->pfnD3DKMTDestroyContext);
pCallbacks->pfnD3DKMTRender = (PFND3DKMT_RENDER)GetProcAddress(pCallbacks->hGdi32, "D3DKMTRender");
LogFunc(("pfnD3DKMTRender = %p\n", pCallbacks->pfnD3DKMTRender));
bSupported &= !!(pCallbacks->pfnD3DKMTRender);
pCallbacks->pfnD3DKMTCreateAllocation = (PFND3DKMT_CREATEALLOCATION)GetProcAddress(pCallbacks->hGdi32, "D3DKMTCreateAllocation");
LogFunc(("pfnD3DKMTCreateAllocation = %p\n", pCallbacks->pfnD3DKMTCreateAllocation));
bSupported &= !!(pCallbacks->pfnD3DKMTCreateAllocation);
pCallbacks->pfnD3DKMTDestroyAllocation = (PFND3DKMT_DESTROYALLOCATION)GetProcAddress(pCallbacks->hGdi32, "D3DKMTDestroyAllocation");
LogFunc(("pfnD3DKMTDestroyAllocation = %p\n", pCallbacks->pfnD3DKMTDestroyAllocation));
bSupported &= !!(pCallbacks->pfnD3DKMTDestroyAllocation);
pCallbacks->pfnD3DKMTLock = (PFND3DKMT_LOCK)GetProcAddress(pCallbacks->hGdi32, "D3DKMTLock");
LogFunc(("pfnD3DKMTLock = %p\n", pCallbacks->pfnD3DKMTLock));
bSupported &= !!(pCallbacks->pfnD3DKMTLock);
pCallbacks->pfnD3DKMTUnlock = (PFND3DKMT_UNLOCK)GetProcAddress(pCallbacks->hGdi32, "D3DKMTUnlock");
LogFunc(("pfnD3DKMTUnlock = %p\n", pCallbacks->pfnD3DKMTUnlock));
bSupported &= !!(pCallbacks->pfnD3DKMTUnlock);
pCallbacks->pfnD3DKMTInvalidateActiveVidPn = (PFND3DKMT_INVALIDATEACTIVEVIDPN)GetProcAddress(pCallbacks->hGdi32, "D3DKMTInvalidateActiveVidPn");
LogFunc(("pfnD3DKMTInvalidateActiveVidPn = %p\n", pCallbacks->pfnD3DKMTInvalidateActiveVidPn));
bSupported &= !!(pCallbacks->pfnD3DKMTInvalidateActiveVidPn);
pCallbacks->pfnD3DKMTPollDisplayChildren = (PFND3DKMT_POLLDISPLAYCHILDREN)GetProcAddress(pCallbacks->hGdi32, "D3DKMTPollDisplayChildren");
LogFunc(("pfnD3DKMTPollDisplayChildren = %p\n", pCallbacks->pfnD3DKMTPollDisplayChildren));
bSupported &= !!(pCallbacks->pfnD3DKMTPollDisplayChildren);
pCallbacks->pfnD3DKMTEnumAdapters = (PFND3DKMT_ENUMADAPTERS)GetProcAddress(pCallbacks->hGdi32, "D3DKMTEnumAdapters");
LogFunc(("pfnD3DKMTEnumAdapters = %p\n", pCallbacks->pfnD3DKMTEnumAdapters));
/* this present starting win8 release preview only, so keep going if it is not available,
* i.e. do not clear the bSupported on its absence */
bSupportedWin8 &= !!(pCallbacks->pfnD3DKMTEnumAdapters);
pCallbacks->pfnD3DKMTOpenAdapterFromLuid = (PFND3DKMT_OPENADAPTERFROMLUID)GetProcAddress(pCallbacks->hGdi32, "D3DKMTOpenAdapterFromLuid");
LogFunc(("pfnD3DKMTOpenAdapterFromLuid = %p\n", pCallbacks->pfnD3DKMTOpenAdapterFromLuid));
/* this present starting win8 release preview only, so keep going if it is not available,
* i.e. do not clear the bSupported on its absence */
bSupportedWin8 &= !!(pCallbacks->pfnD3DKMTOpenAdapterFromLuid);
/*Assert(bSupported);*/
if (bSupported)
{
if (bSupportedWin8)
pCallbacks->enmVersion = VBOXDISPKMT_CALLBACKS_VERSION_WIN8;
else
pCallbacks->enmVersion = VBOXDISPKMT_CALLBACKS_VERSION_VISTA_WIN7;
return S_OK;
}
else
{
LogFunc(("one of pfnD3DKMT function pointers failed to initialize\n"));
hr = E_NOINTERFACE;
}
FreeLibrary(pCallbacks->hGdi32);
}
else
{
DWORD winEr = GetLastError();
hr = HRESULT_FROM_WIN32(winEr);
Assert(0);
Assert(hr != S_OK);
Assert(hr != S_FALSE);
if (hr == S_OK || hr == S_FALSE)
hr = E_FAIL;
}
return hr;
}
HRESULT VBoxDispD3DOpen(VBOXDISPD3D *pD3D)
{
#ifdef VBOX_WDDM_WOW64
pD3D->hD3DLib = loadSystemDll("VBoxD3D9wddm-x86.dll");
#else
pD3D->hD3DLib = loadSystemDll("VBoxD3D9wddm.dll");
#endif
if (!pD3D->hD3DLib)
{
DWORD winErr = GetLastError();
WARN((__FUNCTION__": LoadLibrary failed, winErr = (%d)", winErr));
return E_FAIL;
}
do
{
pD3D->pfnDirect3DCreate9Ex = (PFNVBOXDISPD3DCREATE9EX)GetProcAddress(pD3D->hD3DLib, "Direct3DCreate9Ex");
if (!pD3D->pfnDirect3DCreate9Ex)
{
WARN(("no Direct3DCreate9Ex"));
break;
}
pD3D->pfnVBoxWineExD3DDev9CreateTexture = (PFNVBOXWINEEXD3DDEV9_CREATETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateTexture");
if (!pD3D->pfnVBoxWineExD3DDev9CreateTexture)
{
WARN(("no VBoxWineExD3DDev9CreateTexture"));
break;
}
pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture = (PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateCubeTexture");
if (!pD3D->pfnVBoxWineExD3DDev9CreateCubeTexture)
{
WARN(("no VBoxWineExD3DDev9CreateCubeTexture"));
break;
}
pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture = (PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateVolumeTexture");
if (!pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture)
{
WARN(("no VBoxWineExD3DDev9CreateVolumeTexture"));
break;
}
pD3D->pfnVBoxWineExD3DDev9Flush = (PFNVBOXWINEEXD3DDEV9_FLUSH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Flush");
if (!pD3D->pfnVBoxWineExD3DDev9Flush)
{
WARN(("no VBoxWineExD3DDev9Flush"));
break;
}
pD3D->pfnVBoxWineExD3DDev9FlushToHost = (PFNVBOXWINEEXD3DDEV9_FLUSHTOHOST)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9FlushToHost");
if (!pD3D->pfnVBoxWineExD3DDev9FlushToHost)
{
WARN(("no VBoxWineExD3DDev9FlushToHost"));
break;
}
pD3D->pfnVBoxWineExD3DDev9Finish = (PFNVBOXWINEEXD3DDEV9_FINISH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Finish");
if (!pD3D->pfnVBoxWineExD3DDev9Finish)
{
WARN(("no VBoxWineExD3DDev9Finish"));
break;
}
pD3D->pfnVBoxWineExD3DDev9VolBlt = (PFNVBOXWINEEXD3DDEV9_VOLBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolBlt");
if (!pD3D->pfnVBoxWineExD3DDev9VolBlt)
{
WARN(("no VBoxWineExD3DDev9VolBlt"));
break;
}
pD3D->pfnVBoxWineExD3DDev9VolTexBlt = (PFNVBOXWINEEXD3DDEV9_VOLTEXBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolTexBlt");
if (!pD3D->pfnVBoxWineExD3DDev9VolTexBlt)
{
WARN(("no VBoxWineExD3DDev9VolTexBlt"));
break;
}
pD3D->pfnVBoxWineExD3DDev9Term = (PFNVBOXWINEEXD3DDEV9_TERM)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Term");
if (!pD3D->pfnVBoxWineExD3DDev9Term)
{
WARN(("no VBoxWineExD3DDev9Term"));
break;
}
pD3D->pfnVBoxWineExD3DSwapchain9Present = (PFNVBOXWINEEXD3DSWAPCHAIN9_PRESENT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSwapchain9Present");
if (!pD3D->pfnVBoxWineExD3DSwapchain9Present)
{
WARN(("no VBoxWineExD3DSwapchain9Present"));
break;
}
pD3D->pfnVBoxWineExD3DSurf9GetHostId = (PFNVBOXWINEEXD3DSURF9_GETHOSTID)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSurf9GetHostId");
if (!pD3D->pfnVBoxWineExD3DSurf9GetHostId)
{
WARN(("no VBoxWineExD3DSurf9GetHostId"));
break;
}
pD3D->pfnVBoxWineExD3DSurf9SyncToHost = (PFNVBOXWINEEXD3DSURF9_SYNCTOHOST)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSurf9SyncToHost");
if (!pD3D->pfnVBoxWineExD3DSurf9SyncToHost)
{
WARN(("no VBoxWineExD3DSurf9SyncToHost"));
break;
}
pD3D->pfnVBoxWineExD3DSwapchain9GetHostWinID = (PFNVBOXWINEEXD3DSWAPCHAIN9_GETHOSTWINID)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DSwapchain9GetHostWinID");
if (!pD3D->pfnVBoxWineExD3DSwapchain9GetHostWinID)
{
WARN(("no VBoxWineExD3DSwapchain9GetHostWinID"));
break;
}
pD3D->pfnVBoxWineExD3DDev9GetHostId = (PFNVBOXWINEEXD3DDEV9_GETHOSTID)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9GetHostId");
if (!pD3D->pfnVBoxWineExD3DDev9GetHostId)
{
WARN(("no VBoxWineExD3DDev9GetHostId"));
break;
}
return S_OK;
} while (0);
VBoxDispD3DClose(pD3D);
return E_FAIL;
}
