SUPLib-win.cpp@ 98578

最後變更在這個檔案從98578是 98103,由 vboxsync 提交於 2 年前
Copyright year updates by scm.
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 32.0 KB

行
1	/* $Id: SUPLib-win.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VirtualBox Support Library - Windows NT specific parts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.alldomusa.eu.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP LOG_GROUP_SUP
42	#ifdef IN_SUP_HARDENED_R3
43	# undef DEBUG /* Warning: disables RT_STRICT */
44	# undef LOG_DISABLED
45	# define LOG_DISABLED
46	/** @todo RTLOGREL_DISABLED */
47	# include <iprt/log.h>
48	# undef LogRelIt
49	# define LogRelIt(pvInst, fFlags, iGroup, fmtargs) do { } while (0)
50	#endif
51
52	#define USE_NT_DEVICE_IO_CONTROL_FILE
53	#include <iprt/nt/nt-and-windows.h>
54
55	#include <VBox/sup.h>
56	#include <VBox/types.h>
57	#include <VBox/err.h>
58	#include <VBox/param.h>
59	#include <VBox/log.h>
60	#include <iprt/assert.h>
61	#ifndef IN_SUP_HARDENED_R3
62	# include <iprt/env.h>
63	# include <iprt/x86.h>
64	# include <iprt/ldr.h>
65	#endif
66	#include <iprt/path.h>
67	#include <iprt/string.h>
68	#include "../SUPLibInternal.h"
69	#include "../SUPDrvIOC.h"
70	#ifdef VBOX_WITH_HARDENING
71	# include "win/SUPHardenedVerify-win.h"
72	#endif
73
74
75	/*********************************************************************************************************************************
76	* Defined Constants And Macros *
77	*********************************************************************************************************************************/
78	/** The support service name. */
79	#define SERVICE_NAME "VBoxSup"
80
81
82	/*********************************************************************************************************************************
83	* Internal Functions *
84	*********************************************************************************************************************************/
85	#ifndef IN_SUP_HARDENED_R3
86	static int suplibOsCreateService(void);
87	//unused: static int suplibOsUpdateService(void);
88	static int suplibOsDeleteService(void);
89	static int suplibOsStartService(void);
90	static int suplibOsStopService(void);
91	#endif
92	#ifdef USE_NT_DEVICE_IO_CONTROL_FILE
93	static int suplibConvertNtStatus(NTSTATUS rcNt);
94	#else
95	static int suplibConvertWin32Err(int);
96	#endif
97
98
99	/*********************************************************************************************************************************
100	* Global Variables *
101	*********************************************************************************************************************************/
102	static bool g_fHardenedVerifyInited = false;
103
104
105	DECLHIDDEN(int) suplibOsHardenedVerifyInit(void)
106	{
107	if (!g_fHardenedVerifyInited)
108	{
109	#if defined(VBOX_WITH_HARDENING) && !defined(IN_SUP_HARDENED_R3) && !defined(IN_SUP_R3_STATIC)
110	supR3HardenedWinInitVersion(false /fEarly/);
111	int rc = supHardenedWinInitImageVerifier(NULL);
112	if (RT_FAILURE(rc))
113	return rc;
114	supR3HardenedWinResolveVerifyTrustApiAndHookThreadCreation(NULL);
115	#endif
116	g_fHardenedVerifyInited = true;
117	}
118	return VINF_SUCCESS;
119	}
120
121
122	DECLHIDDEN(int) suplibOsHardenedVerifyTerm(void)
123	{
124	/** @todo free resources... */
125	return VINF_SUCCESS;
126	}
127
128
129	DECLHIDDEN(int) suplibOsInit(PSUPLIBDATA pThis, bool fPreInited, uint32_t fFlags, SUPINITOP *penmWhat, PRTERRINFO pErrInfo)
130	{
131	/*
132	* Make sure the image verifier is fully initialized.
133	*/
134	int rc = suplibOsHardenedVerifyInit();
135	if (RT_FAILURE(rc))
136	return RTErrInfoSetF(pErrInfo, rc, "suplibOsHardenedVerifyInit failed: %Rrc", rc);
137
138	/*
139	* Done if of pre-inited.
140	*/
141	if (fPreInited)
142	{
143	#if defined(VBOX_WITH_HARDENING) && !defined(IN_SUP_HARDENED_R3)
144	# ifdef IN_SUP_R3_STATIC
145	return VERR_NOT_SUPPORTED;
146	# else
147	return VINF_SUCCESS;
148	# endif
149	#else
150	return VINF_SUCCESS;
151	#endif
152	}
153
154	/*
155	* Try open the device.
156	*/
157	#ifndef IN_SUP_HARDENED_R3
158	uint32_t cTry = 0;
159	#endif
160	HANDLE hDevice;
161	for (;;)
162	{
163	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
164
165	static const WCHAR s_wszName[] = L"\\Device\\VBoxDrvU";
166	UNICODE_STRING NtName;
167	NtName.Buffer = (PWSTR)s_wszName;
168	NtName.Length = sizeof(s_wszName) - sizeof(WCHAR) * (fFlags & SUPR3INIT_F_UNRESTRICTED ? 2 : 1);
169	NtName.MaximumLength = NtName.Length;
170
171	OBJECT_ATTRIBUTES ObjAttr;
172	InitializeObjectAttributes(&ObjAttr, &NtName, OBJ_CASE_INSENSITIVE, NULL /hRootDir/, NULL /pSecDesc/);
173
174	hDevice = RTNT_INVALID_HANDLE_VALUE;
175
176	NTSTATUS rcNt = NtCreateFile(&hDevice,
177	GENERIC_READ \| GENERIC_WRITE, /* No SYNCHRONIZE. */
178	&ObjAttr,
179	&Ios,
180	NULL /* Allocation Size*/,
181	FILE_ATTRIBUTE_NORMAL,
182	FILE_SHARE_READ \| FILE_SHARE_WRITE,
183	FILE_OPEN,
184	FILE_NON_DIRECTORY_FILE, /* No FILE_SYNCHRONOUS_IO_NONALERT! */
185	NULL /EaBuffer/,
186	0 /EaLength/);
187	if (NT_SUCCESS(rcNt))
188	rcNt = Ios.Status;
189	if (NT_SUCCESS(rcNt))
190	{
191	/*
192	* We're good.
193	*/
194	pThis->hDevice = hDevice;
195	pThis->fUnrestricted = RT_BOOL(fFlags & SUPR3INIT_F_UNRESTRICTED);
196	return VINF_SUCCESS;
197	}
198
199	#ifndef IN_SUP_HARDENED_R3
200	/*
201	* Failed to open, try starting the service and reopen the device
202	* exactly once.
203	*/
204	if (cTry == 0 && !NT_SUCCESS(rcNt))
205	{
206	cTry++;
207	suplibOsStartService();
208	continue;
209	}
210	#endif
211
212	/*
213	* Translate the error code.
214	*/
215	switch (rcNt)
216	{
217	/** @todo someone must test what is actually returned. */
218	case STATUS_DEVICE_DOES_NOT_EXIST:
219	case STATUS_DEVICE_NOT_CONNECTED:
220	//case ERROR_BAD_DEVICE:
221	case STATUS_DEVICE_REMOVED:
222	//case ERROR_DEVICE_NOT_AVAILABLE:
223	rc = VERR_VM_DRIVER_LOAD_ERROR;
224	break;
225	case STATUS_OBJECT_PATH_NOT_FOUND:
226	case STATUS_NO_SUCH_DEVICE:
227	case STATUS_NO_SUCH_FILE:
228	case STATUS_OBJECT_NAME_NOT_FOUND:
229	rc = VERR_VM_DRIVER_NOT_INSTALLED;
230	break;
231	case STATUS_ACCESS_DENIED:
232	case STATUS_SHARING_VIOLATION:
233	rc = VERR_VM_DRIVER_NOT_ACCESSIBLE;
234	break;
235	case STATUS_UNSUCCESSFUL:
236	rc = VERR_SUPLIB_NT_PROCESS_UNTRUSTED_0;
237	break;
238	case STATUS_TRUST_FAILURE:
239	rc = VERR_SUPLIB_NT_PROCESS_UNTRUSTED_1;
240	break;
241	case STATUS_TOO_LATE:
242	rc = VERR_SUPDRV_HARDENING_EVIL_HANDLE;
243	break;
244	default:
245	if (SUP_NT_STATUS_IS_VBOX(rcNt)) /* See VBoxDrvNtErr2NtStatus. */
246	rc = SUP_NT_STATUS_TO_VBOX(rcNt);
247	else
248	rc = VERR_VM_DRIVER_OPEN_ERROR;
249	break;
250	}
251
252	#ifdef IN_SUP_HARDENED_R3
253	/*
254	* Get more details from VBoxDrvErrorInfo if present.
255	*/
256	if (pErrInfo && pErrInfo->cbMsg > 32)
257	{
258	/* Prefix. */
259	size_t cchPrefix;
260	if (RTErrIsKnown(rc))
261	cchPrefix = RTStrPrintf(pErrInfo->pszMsg, pErrInfo->cbMsg / 2, "Integrity error (%#x/%Rrc): ", rcNt, rc);
262	else
263	cchPrefix = RTStrPrintf(pErrInfo->pszMsg, pErrInfo->cbMsg / 2, "Integrity error (%#x/%d): ", rcNt, rc);
264
265	/* Get error info. */
266	supR3HardenedWinReadErrorInfoDevice(pErrInfo->pszMsg + cchPrefix, pErrInfo->cbMsg - cchPrefix, "");
267	if (pErrInfo->pszMsg[cchPrefix] != '\0')
268	{
269	pErrInfo->fFlags \|= RTERRINFO_FLAGS_SET;
270	pErrInfo->rc = rc;
271	*penmWhat = kSupInitOp_Integrity;
272	}
273	else
274	pErrInfo->pszMsg[0] = '\0';
275	}
276	#else
277	RT_NOREF1(penmWhat);
278	#endif
279	return rc;
280	}
281	}
282
283
284	#ifndef IN_SUP_HARDENED_R3
285
286	DECLHIDDEN(int) suplibOsInstall(void)
287	{
288	int rc = suplibOsCreateService();
289	if (RT_SUCCESS(rc))
290	{
291	int rc2 = suplibOsStartService();
292	if (rc2 != VINF_SUCCESS)
293	rc = rc2;
294	}
295	return rc;
296	}
297
298
299	DECLHIDDEN(int) suplibOsUninstall(void)
300	{
301	int rc = suplibOsStopService();
302	if (RT_SUCCESS(rc))
303	rc = suplibOsDeleteService();
304	return rc;
305	}
306
307
308	/**
309	* Creates the service.
310	*
311	* @returns VBox status code.
312	* @retval VWRN_ALREADY_EXISTS if it already exists.
313	*/
314	static int suplibOsCreateService(void)
315	{
316	/*
317	* Assume it didn't exist, so we'll create the service.
318	*/
319	int rc;
320	SC_HANDLE hSMgrCreate = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
321	DWORD dwErr = GetLastError();
322	AssertMsg(hSMgrCreate, ("OpenSCManager(,,create) failed dwErr=%d\n", dwErr));
323	if (hSMgrCreate != NULL)
324	{
325	char szDriver[RTPATH_MAX];
326	rc = RTPathExecDir(szDriver, sizeof(szDriver) - sizeof("\\VBoxSup.sys"));
327	if (RT_SUCCESS(rc))
328	{
329	strcat(szDriver, "\\VBoxSup.sys");
330	SC_HANDLE hService = CreateService(hSMgrCreate,
331	SERVICE_NAME,
332	"VBox Support Driver",
333	SERVICE_QUERY_STATUS,
334	SERVICE_KERNEL_DRIVER,
335	SERVICE_DEMAND_START,
336	SERVICE_ERROR_NORMAL,
337	szDriver,
338	NULL, NULL, NULL, NULL, NULL);
339	dwErr = GetLastError();
340	if (hService)
341	{
342	CloseServiceHandle(hService);
343	rc = VINF_SUCCESS;
344	}
345	else if (dwErr == ERROR_SERVICE_EXISTS)
346	rc = VWRN_ALREADY_EXISTS;
347	else
348	{
349	AssertMsgFailed(("CreateService failed! dwErr=%Rwa szDriver=%s\n", dwErr, szDriver));
350	rc = RTErrConvertFromWin32(dwErr);
351	}
352	}
353	CloseServiceHandle(hSMgrCreate);
354	}
355	else
356	rc = RTErrConvertFromWin32(GetLastError());
357	return rc;
358	}
359
360
361	/**
362	* Stops a possibly running service.
363	*
364	* @returns VBox status code.
365	*/
366	static int suplibOsStopService(void)
367	{
368	/*
369	* Assume it didn't exist, so we'll create the service.
370	*/
371	int rc;
372	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_STOP \| SERVICE_QUERY_STATUS);
373	DWORD dwErr = GetLastError();
374	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed dwErr=%d\n", dwErr));
375	if (hSMgr)
376	{
377	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_STOP \| SERVICE_QUERY_STATUS);
378	if (hService)
379	{
380	/*
381	* Stop the service.
382	*/
383	SERVICE_STATUS Status;
384	QueryServiceStatus(hService, &Status);
385	if (Status.dwCurrentState == SERVICE_STOPPED)
386	rc = VINF_SUCCESS;
387	else if (ControlService(hService, SERVICE_CONTROL_STOP, &Status))
388	{
389	int iWait = 100;
390	while (Status.dwCurrentState == SERVICE_STOP_PENDING && iWait-- > 0)
391	{
392	Sleep(100);
393	QueryServiceStatus(hService, &Status);
394	}
395	if (Status.dwCurrentState == SERVICE_STOPPED)
396	rc = VINF_SUCCESS;
397	else
398	{
399	AssertMsgFailed(("Failed to stop service. status=%d\n", Status.dwCurrentState));
400	rc = VERR_GENERAL_FAILURE;
401	}
402	}
403	else
404	{
405	dwErr = GetLastError();
406	if ( Status.dwCurrentState == SERVICE_STOP_PENDING
407	&& dwErr == ERROR_SERVICE_CANNOT_ACCEPT_CTRL)
408	rc = VERR_RESOURCE_BUSY; /* better than VERR_GENERAL_FAILURE */
409	else
410	{
411	AssertMsgFailed(("ControlService failed with dwErr=%Rwa. status=%d\n", dwErr, Status.dwCurrentState));
412	rc = RTErrConvertFromWin32(dwErr);
413	}
414	}
415	CloseServiceHandle(hService);
416	}
417	else
418	{
419	dwErr = GetLastError();
420	if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
421	rc = VINF_SUCCESS;
422	else
423	{
424	AssertMsgFailed(("OpenService failed dwErr=%Rwa\n", dwErr));
425	rc = RTErrConvertFromWin32(dwErr);
426	}
427	}
428	CloseServiceHandle(hSMgr);
429	}
430	else
431	rc = RTErrConvertFromWin32(dwErr);
432	return rc;
433	}
434
435
436	/**
437	* Deletes the service.
438	*
439	* @returns VBox status code.
440	*/
441	int suplibOsDeleteService(void)
442	{
443	int rcRet = VINF_SUCCESS;
444	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
445	DWORD dwErr = GetLastError();
446	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", dwErr));
447	if (hSMgr)
448	{
449	/*
450	* Old service name.
451	*/
452	SC_HANDLE hService = OpenService(hSMgr, "VBoxDrv", DELETE);
453	if (hService)
454	{
455	if (!DeleteService(hService))
456	{
457	dwErr = GetLastError();
458	AssertMsgFailed(("DeleteService failed for VBoxDrv dwErr=%Rwa\n", dwErr));
459	rcRet = RTErrConvertFromWin32(dwErr);
460	}
461	CloseServiceHandle(hService);
462	}
463	else
464	{
465	dwErr = GetLastError();
466	if (dwErr != ERROR_SERVICE_DOES_NOT_EXIST)
467	{
468	AssertMsgFailed(("OpenService failed for VBoxDrv dwErr=%Rwa\n", dwErr));
469	rcRet = RTErrConvertFromWin32(dwErr);
470	}
471	}
472
473	/*
474	* The new service.
475	*/
476	hService = OpenService(hSMgr, SERVICE_NAME, DELETE);
477	if (hService)
478	{
479	if (!DeleteService(hService))
480	{
481	dwErr = GetLastError();
482	AssertMsgFailed(("DeleteService for " SERVICE_NAME " failed dwErr=%Rwa\n", dwErr));
483	rcRet = RTErrConvertFromWin32(dwErr);
484	}
485	CloseServiceHandle(hService);
486	}
487	else
488	{
489	dwErr = GetLastError();
490	if (dwErr != ERROR_SERVICE_DOES_NOT_EXIST)
491	{
492	AssertMsgFailed(("OpenService failed for " SERVICE_NAME " dwErr=%Rwa\n", dwErr));
493	rcRet = RTErrConvertFromWin32(dwErr);
494	}
495	}
496	CloseServiceHandle(hSMgr);
497	}
498	else
499	rcRet = RTErrConvertFromWin32(dwErr);
500	return rcRet;
501	}
502
503	#if 0
504	/**
505	* Creates the service.
506	*
507	* @returns 0 on success.
508	* @returns -1 on failure.
509	*/
510	static int suplibOsUpdateService(void)
511	{
512	/*
513	* Assume it didn't exist, so we'll create the service.
514	*/
515	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
516	DWORD LastError = GetLastError(); NOREF(LastError);
517	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed LastError=%Rwa\n", LastError));
518	if (hSMgr)
519	{
520	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_CHANGE_CONFIG);
521	if (hService)
522	{
523	char szDriver[RTPATH_MAX];
524	int rc = RTPathExecDir(szDriver, sizeof(szDriver) - sizeof("\\VBoxSup.sys"));
525	if (RT_SUCCESS(rc))
526	{
527	strcat(szDriver, "\\VBoxSup.sys");
528
529	SC_LOCK hLock = LockServiceDatabase(hSMgr);
530	if (ChangeServiceConfig(hService,
531	SERVICE_KERNEL_DRIVER,
532	SERVICE_DEMAND_START,
533	SERVICE_ERROR_NORMAL,
534	szDriver,
535	NULL, NULL, NULL, NULL, NULL, NULL))
536	{
537
538	UnlockServiceDatabase(hLock);
539	CloseServiceHandle(hService);
540	CloseServiceHandle(hSMgr);
541	return 0;
542	}
543	else
544	{
545	DWORD LastError = GetLastError(); NOREF(LastError);
546	AssertMsgFailed(("ChangeServiceConfig failed LastError=%Rwa\n", LastError));
547	}
548	}
549	UnlockServiceDatabase(hLock);
550	CloseServiceHandle(hService);
551	}
552	else
553	{
554	DWORD LastError = GetLastError(); NOREF(LastError);
555	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
556	}
557	CloseServiceHandle(hSMgr);
558	}
559	return -1;
560	}
561	#endif
562
563
564	/**
565	* Attempts to start the service, creating it if necessary.
566	*
567	* @returns VBox status code.
568	*/
569	static int suplibOsStartService(void)
570	{
571	/*
572	* Check if the driver service is there.
573	*/
574	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_QUERY_STATUS \| SERVICE_START);
575	if (hSMgr == NULL)
576	{
577	DWORD dwErr = GetLastError();
578	AssertMsgFailed(("couldn't open service manager in SERVICE_QUERY_CONFIG \| SERVICE_QUERY_STATUS mode! (dwErr=%d)\n", dwErr));
579	return RTErrConvertFromWin32(dwErr);
580	}
581
582	/*
583	* Try open our service to check it's status.
584	*/
585	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
586	if (!hService)
587	{
588	/*
589	* Create the service.
590	*/
591	int rc = suplibOsCreateService();
592	if (RT_FAILURE(rc))
593	return rc;
594
595	/*
596	* Try open the service.
597	*/
598	hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
599	}
600
601	/*
602	* Check if open and on demand create succeeded.
603	*/
604	int rc;
605	if (hService)
606	{
607
608	/*
609	* Query service status to see if we need to start it or not.
610	*/
611	SERVICE_STATUS Status;
612	BOOL fRc = QueryServiceStatus(hService, &Status);
613	Assert(fRc); NOREF(fRc);
614	if (Status.dwCurrentState == SERVICE_RUNNING)
615	rc = VINF_ALREADY_INITIALIZED;
616	else
617	{
618	if (Status.dwCurrentState == SERVICE_START_PENDING)
619	rc = VINF_SUCCESS;
620	else
621	{
622	/*
623	* Start it.
624	*/
625	if (StartService(hService, 0, NULL))
626	rc = VINF_SUCCESS;
627	else
628	{
629	DWORD dwErr = GetLastError();
630	AssertMsg(fRc, ("StartService failed with dwErr=%Rwa\n", dwErr));
631	rc = RTErrConvertFromWin32(dwErr);
632	}
633	}
634
635	/*
636	* Wait for the service to finish starting.
637	* We'll wait for 10 seconds then we'll give up.
638	*/
639	QueryServiceStatus(hService, &Status);
640	if (Status.dwCurrentState == SERVICE_START_PENDING)
641	{
642	int iWait;
643	for (iWait = 100; iWait > 0 && Status.dwCurrentState == SERVICE_START_PENDING; iWait--)
644	{
645	Sleep(100);
646	QueryServiceStatus(hService, &Status);
647	}
648	DWORD dwErr = GetLastError(); NOREF(dwErr);
649	AssertMsg(Status.dwCurrentState != SERVICE_RUNNING,
650	("Failed to start. dwErr=%Rwa iWait=%d status=%d\n", dwErr, iWait, Status.dwCurrentState));
651	}
652
653	if (Status.dwCurrentState == SERVICE_RUNNING)
654	rc = VINF_SUCCESS;
655	else if (RT_SUCCESS_NP(rc))
656	rc = VERR_GENERAL_FAILURE;
657	}
658
659	/*
660	* Close open handles.
661	*/
662	CloseServiceHandle(hService);
663	}
664	else
665	{
666	DWORD dwErr = GetLastError();
667	AssertMsgFailed(("OpenService failed! LastError=%Rwa\n", dwErr));
668	rc = RTErrConvertFromWin32(dwErr);
669	}
670	if (!CloseServiceHandle(hSMgr))
671	AssertFailed();
672
673	return rc;
674	}
675
676	#endif /* !IN_SUP_HARDENED_R3 */
677
678	DECLHIDDEN(int) suplibOsTerm(PSUPLIBDATA pThis)
679	{
680	/*
681	* Check if we're inited at all.
682	*/
683	if (pThis->hDevice != NULL)
684	{
685	NTSTATUS rcNt = NtClose((HANDLE)pThis->hDevice);
686	Assert(NT_SUCCESS(rcNt)); RT_NOREF(rcNt);
687	pThis->hDevice = NIL_RTFILE; /* yes, that's right */
688	}
689
690	return VINF_SUCCESS;
691	}
692
693	#ifndef IN_SUP_HARDENED_R3
694
695	DECLHIDDEN(int) suplibOsIOCtl(PSUPLIBDATA pThis, uintptr_t uFunction, void *pvReq, size_t cbReq)
696	{
697	RT_NOREF1(cbReq);
698
699	/*
700	* Issue the device I/O control.
701	*/
702	PSUPREQHDR pHdr = (PSUPREQHDR)pvReq;
703	Assert(cbReq == RT_MAX(pHdr->cbIn, pHdr->cbOut));
704	# ifdef USE_NT_DEVICE_IO_CONTROL_FILE
705	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
706	NTSTATUS rcNt = NtDeviceIoControlFile((HANDLE)pThis->hDevice, NULL /hEvent/, NULL /pfnApc/, NULL /pvApcCtx/, &Ios,
707	(ULONG)uFunction,
708	pvReq /pvInput /, pHdr->cbIn /* cbInput */,
709	pvReq /pvOutput/, pHdr->cbOut /* cbOutput */);
710	if (NT_SUCCESS(rcNt))
711	{
712	if (NT_SUCCESS(Ios.Status))
713	return VINF_SUCCESS;
714	rcNt = Ios.Status;
715	}
716	return suplibConvertNtStatus(rcNt);
717
718	# else
719	DWORD cbReturned = (ULONG)pHdr->cbOut;
720	if (DeviceIoControl((HANDLE)pThis->hDevice, uFunction, pvReq, pHdr->cbIn, pvReq, cbReturned, &cbReturned, NULL))
721	return 0;
722	return suplibConvertWin32Err(GetLastError());
723	# endif
724	}
725
726
727	DECLHIDDEN(int) suplibOsIOCtlFast(PSUPLIBDATA pThis, uintptr_t uFunction, uintptr_t idCpu)
728	{
729	/*
730	* Issue device I/O control.
731	*/
732	# ifdef USE_NT_DEVICE_IO_CONTROL_FILE
733	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
734	NTSTATUS rcNt = NtDeviceIoControlFile((HANDLE)pThis->hDevice, NULL /hEvent/, NULL /pfnApc/, NULL /pvApcCtx/, &Ios,
735	(ULONG)uFunction,
736	NULL /pvInput /, 0 /* cbInput */,
737	(PVOID)idCpu /pvOutput/, 0 /* cbOutput */);
738	if (NT_SUCCESS(rcNt))
739	{
740	if (NT_SUCCESS(Ios.Status))
741	return VINF_SUCCESS;
742	rcNt = Ios.Status;
743	}
744	return suplibConvertNtStatus(rcNt);
745	# else
746	DWORD cbReturned = 0;
747	if (DeviceIoControl((HANDLE)pThis->hDevice, uFunction, NULL, 0, (LPVOID)idCpu, 0, &cbReturned, NULL))
748	return VINF_SUCCESS;
749	return suplibConvertWin32Err(GetLastError());
750	# endif
751	}
752
753
754	DECLHIDDEN(int) suplibOsPageAlloc(PSUPLIBDATA pThis, size_t cPages, uint32_t fFlags, void **ppvPages)
755	{
756	RT_NOREF(pThis, fFlags);
757
758	/*
759	* Do some one-time init here wrt large pages.
760	*
761	* Large pages requires the SeLockMemoryPrivilege, which by default (Win10,
762	* Win11) isn't even enabled and must be gpedit'ed to be adjustable here.
763	*/
764	if (!(cPages & 511) && (fFlags & SUP_PAGE_ALLOC_F_LARGE_PAGES))
765	{
766	static int volatile s_fCanDoLargePages = -1;
767	int fCanDoLargePages = s_fCanDoLargePages;
768	if (s_fCanDoLargePages != -1)
769	{ /* likely */ }
770	else if (RTEnvExistsUtf8("VBOX_DO_NOT_USE_LARGE_PAGES")) /** @todo add flag for this instead? */
771	s_fCanDoLargePages = fCanDoLargePages = 0;
772	else
773	{
774	HANDLE hToken = NULL;
775	if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY \| TOKEN_ADJUST_PRIVILEGES, &hToken))
776	{
777	union
778	{
779	TOKEN_PRIVILEGES s;
780	uint8_t abPadding[RT_UOFFSETOF(TOKEN_PRIVILEGES, Privileges) + sizeof(LUID_AND_ATTRIBUTES)];
781	} Privileges;
782	RT_ZERO(Privileges);
783	Privileges.s.PrivilegeCount = 1;
784	Privileges.s.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
785	if (LookupPrivilegeValueW(NULL, L"SeLockMemoryPrivilege", &Privileges.s.Privileges[0].Luid))
786	AdjustTokenPrivileges(hToken, FALSE, &Privileges.s, 0, NULL, NULL);
787	else
788	AssertFailed();
789	CloseHandle(hToken);
790	}
791	else
792	AssertFailed();
793	s_fCanDoLargePages = fCanDoLargePages = -2;
794	}
795
796	/*
797	* Try allocate with large pages.
798	*/
799	if (fCanDoLargePages != 0)
800	{
801	*ppvPages = VirtualAlloc(NULL, (size_t)cPages << PAGE_SHIFT, MEM_COMMIT \| MEM_LARGE_PAGES, PAGE_EXECUTE_READWRITE);
802	if (*ppvPages)
803	{
804	if (fCanDoLargePages == -2)
805	{
806	s_fCanDoLargePages = 1;
807	LogRel(("SUPLib: MEM_LARGE_PAGES works!\n"));
808	}
809	LogRel2(("SUPLib: MEM_LARGE_PAGES for %p LB %p\n", *ppvPages, (size_t)cPages << PAGE_SHIFT));
810	return VINF_SUCCESS;
811	}
812
813	/* This can happen if the above AdjustTokenPrivileges failed (non-admin
814	user), or if the privilege isn't present in the token (need gpedit). */
815	if (GetLastError() == ERROR_PRIVILEGE_NOT_HELD)
816	{
817	LogRel(("SUPLib: MEM_LARGE_PAGES privilege not held.\n"));
818	s_fCanDoLargePages = 0;
819	}
820	else
821	LogRel2(("SUPLib: MEM_LARGE_PAGES allocation failed with odd status: %u\n", GetLastError()));
822	}
823	}
824
825	/*
826	* Do a regular allocation w/o large pages.
827	*/
828	*ppvPages = VirtualAlloc(NULL, (size_t)cPages << PAGE_SHIFT, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
829	if (*ppvPages)
830	return VINF_SUCCESS;
831	return RTErrConvertFromWin32(GetLastError());
832	}
833
834
835	DECLHIDDEN(int) suplibOsPageFree(PSUPLIBDATA pThis, void pvPages, size_t / cPages */)
836	{
837	NOREF(pThis);
838	if (VirtualFree(pvPages, 0, MEM_RELEASE))
839	return VINF_SUCCESS;
840	return RTErrConvertFromWin32(GetLastError());
841	}
842
843
844	DECLHIDDEN(bool) suplibOsIsNemSupportedWhenNoVtxOrAmdV(void)
845	{
846	# if ARCH_BITS == 64
847	/*
848	* Check that we're in a VM.
849	*/
850	if (!ASMHasCpuId())
851	return false;
852	if (!RTX86IsValidStdRange(ASMCpuId_EAX(0)))
853	return false;
854	if (!(ASMCpuId_ECX(1) & X86_CPUID_FEATURE_ECX_HVP))
855	return false;
856
857	/*
858	* Try load WinHvPlatform and resolve API for checking.
859	* Note! The two size_t arguments and the ssize_t one are all too big, but who cares.
860	*/
861	RTLDRMOD hLdrMod = NIL_RTLDRMOD;
862	int rc = RTLdrLoadSystem("WinHvPlatform.dll", false, &hLdrMod);
863	if (RT_FAILURE(rc))
864	return false;
865
866	bool fRet = false;
867	typedef HRESULT (WINAPI PFNWHVGETCAPABILITY)(ssize_t, void , size_t, size_t *);
868	PFNWHVGETCAPABILITY pfnWHvGetCapability = (PFNWHVGETCAPABILITY)RTLdrGetFunction(hLdrMod, "WHvGetCapability");
869	if (pfnWHvGetCapability)
870	{
871	/*
872	* Query the API.
873	*/
874	union
875	{
876	BOOL fHypervisorPresent;
877	uint64_t u64Padding;
878	} Caps;
879	RT_ZERO(Caps);
880	size_t cbRetIgn = 0;
881	HRESULT hrc = pfnWHvGetCapability(0 /WHvCapabilityCodeHypervisorPresent/, &Caps, sizeof(Caps), &cbRetIgn);
882	if (SUCCEEDED(hrc) && Caps.fHypervisorPresent)
883	fRet = true;
884	}
885
886	RTLdrClose(hLdrMod);
887	return fRet;
888	# else
889	return false;
890	#endif
891	}
892
893
894	# ifndef USE_NT_DEVICE_IO_CONTROL_FILE
895	/**
896	* Converts a supdrv win32 error code to an IPRT status code.
897	*
898	* @returns corresponding IPRT error code.
899	* @param rc Win32 error code.
900	*/
901	static int suplibConvertWin32Err(int rc)
902	{
903	/* Conversion program (link with ntdll.lib from ddk):
904	#define _WIN32_WINNT 0x0501
905	#include <iprt/win/windows.h>
906	#include <ntstatus.h>
907	#include <winternl.h>
908	#include <stdio.h>
909
910	int main()
911	{
912	#define CONVERT(a) printf(#a " %#x -> %d\n", a, RtlNtStatusToDosError((a)))
913	CONVERT(STATUS_SUCCESS);
914	CONVERT(STATUS_NOT_SUPPORTED);
915	CONVERT(STATUS_INVALID_PARAMETER);
916	CONVERT(STATUS_UNKNOWN_REVISION);
917	CONVERT(STATUS_INVALID_HANDLE);
918	CONVERT(STATUS_INVALID_ADDRESS);
919	CONVERT(STATUS_NOT_LOCKED);
920	CONVERT(STATUS_IMAGE_ALREADY_LOADED);
921	CONVERT(STATUS_ACCESS_DENIED);
922	CONVERT(STATUS_REVISION_MISMATCH);
923
924	return 0;
925	}
926	*/
927
928	switch (rc)
929	{
930	//case 0: return STATUS_SUCCESS;
931	case 0: return VINF_SUCCESS;
932	case ERROR_NOT_SUPPORTED: return VERR_GENERAL_FAILURE;
933	case ERROR_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
934	case ERROR_UNKNOWN_REVISION: return VERR_INVALID_MAGIC;
935	case ERROR_INVALID_HANDLE: return VERR_INVALID_HANDLE;
936	case ERROR_UNEXP_NET_ERR: return VERR_INVALID_POINTER;
937	case ERROR_NOT_LOCKED: return VERR_LOCK_FAILED;
938	case ERROR_SERVICE_ALREADY_RUNNING: return VERR_ALREADY_LOADED;
939	case ERROR_ACCESS_DENIED: return VERR_PERMISSION_DENIED;
940	case ERROR_REVISION_MISMATCH: return VERR_VERSION_MISMATCH;
941	}
942
943	/* fall back on the default conversion. */
944	return RTErrConvertFromWin32(rc);
945	}
946	# else
947	/**
948	* Reverse of VBoxDrvNtErr2NtStatus
949	* returns VBox status code.
950	* @param rcNt NT status code.
951	*/
952	static int suplibConvertNtStatus(NTSTATUS rcNt)
953	{
954	switch (rcNt)
955	{
956	case STATUS_SUCCESS: return VINF_SUCCESS;
957	case STATUS_NOT_SUPPORTED: return VERR_GENERAL_FAILURE;
958	case STATUS_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
959	case STATUS_UNKNOWN_REVISION: return VERR_INVALID_MAGIC;
960	case STATUS_INVALID_HANDLE: return VERR_INVALID_HANDLE;
961	case STATUS_INVALID_ADDRESS: return VERR_INVALID_POINTER;
962	case STATUS_NOT_LOCKED: return VERR_LOCK_FAILED;
963	case STATUS_IMAGE_ALREADY_LOADED: return VERR_ALREADY_LOADED;
964	case STATUS_ACCESS_DENIED: return VERR_PERMISSION_DENIED;
965	case STATUS_REVISION_MISMATCH: return VERR_VERSION_MISMATCH;
966	}
967
968	/* See VBoxDrvNtErr2NtStatus. */
969	if (SUP_NT_STATUS_IS_VBOX(rcNt))
970	return SUP_NT_STATUS_TO_VBOX(rcNt);
971
972	/* Fall back on IPRT for the rest. */
973	return RTErrConvertFromNtStatus(rcNt);
974	}
975	# endif
976
977	#endif /* !IN_SUP_HARDENED_R3 */
978

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/HostDrivers/Support/win/SUPLib-win.cpp@ 98578

以其他格式下載: