SUPLib-win32.cpp@ 2981

Last change on this file since 2981 was 2981, checked in by vboxsync, 18 years ago
InnoTek -> innotek: all the headers and comments.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.7 KB

Line
1	/** @file
2	*
3	* VBox host drivers - Ring-0 support drivers - Win32 host:
4	* Win32 implementations for driver support library
5	*/
6
7	/*
8	* Copyright (C) 2006-2007 innotek GmbH
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License as published by the Free Software Foundation,
14	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15	* distribution. VirtualBox OSE is distributed in the hope that it will
16	* be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* If you received this file as part of a commercial VirtualBox
19	* distribution, then only the terms of your commercial VirtualBox
20	* license agreement apply instead of the previous paragraph.
21	*/
22
23
24	/*******************************************************************************
25	* Header Files *
26	*******************************************************************************/
27	#define LOG_GROUP LOG_GROUP_SUP
28	#include <windows.h>
29
30	#include <VBox/sup.h>
31	#include <VBox/types.h>
32	#include <VBox/err.h>
33	#include <VBox/param.h>
34	#include <VBox/log.h>
35	#include <iprt/assert.h>
36	#include <iprt/path.h>
37	#include <iprt/string.h>
38	#include "SUPLibInternal.h"
39
40
41	/*******************************************************************************
42	* Defined Constants And Macros *
43	*******************************************************************************/
44	/** The support service name. */
45	#define SERVICE_NAME "VBoxDrv"
46	/** Win32 Device name. */
47	#define DEVICE_NAME "\\\\.\\VBoxDrv"
48	/** NT Device name. */
49	#define DEVICE_NAME_NT L"\\Device\\VBoxDrv"
50	/** Win32 Symlink name. */
51	#define DEVICE_NAME_DOS L"\\DosDevices\\VBoxDrv"
52
53
54
55	/*******************************************************************************
56	* Global Variables *
57	*******************************************************************************/
58	/** Handle to the open device. */
59	static HANDLE g_hDevice = INVALID_HANDLE_VALUE;
60	/** Flags whether or not we started the service. */
61	static bool g_fStartedService = false;
62	/** Pointer to the area of memory we reserve for SUPPageAlloc(). */
63	static void *g_pvReserved = NULL;
64	/** The number of bytes we reserved for SUPPageAlloc(). */
65	static size_t g_cbReserved = 0;
66
67
68	/*******************************************************************************
69	* Internal Functions *
70	*******************************************************************************/
71	static int suplibOsCreateService(void);
72	static int suplibOsUpdateService(void);
73	static int suplibOsDeleteService(void);
74	static int suplibOsStartService(void);
75	static int suplibOsStopService(void);
76	static int suplibConvertWin32Err(int);
77
78
79	/**
80	* Initialize the OS specific part of the library.
81	* On Win32 this involves:
82	* - registering the device driver
83	* - start device driver.
84	* - open driver.
85	*
86	* @returns 0 on success.
87	* @returns current -1 on failure but this must be changed to proper error codes.
88	* @param cbReserve The number of bytes to reserver for contiguous virtual allocations.
89	*/
90	int suplibOsInit(size_t cbReserve)
91	{
92	/*
93	* Check if already initialized.
94	*/
95	if (g_hDevice != INVALID_HANDLE_VALUE)
96	return 0;
97
98	/*
99	* Try open the device.
100	*/
101	g_hDevice = CreateFile(DEVICE_NAME,
102	GENERIC_READ \| GENERIC_WRITE, FILE_SHARE_READ \| FILE_SHARE_WRITE,
103	NULL,
104	OPEN_EXISTING,
105	FILE_ATTRIBUTE_NORMAL \| FILE_FLAG_OVERLAPPED,
106	NULL);
107	if (g_hDevice == INVALID_HANDLE_VALUE)
108	{
109	/*
110	* Try start the service and retry opening it.
111	*/
112	suplibOsStartService();
113	g_hDevice = CreateFile(DEVICE_NAME,
114	GENERIC_READ \| GENERIC_WRITE, FILE_SHARE_READ \| FILE_SHARE_WRITE,
115	NULL,
116	OPEN_EXISTING,
117	FILE_ATTRIBUTE_NORMAL \| FILE_FLAG_OVERLAPPED,
118	NULL);
119	if (g_hDevice == INVALID_HANDLE_VALUE)
120	{
121	int rc = GetLastError();
122	switch (rc)
123	{
124	/** @todo someone must test what is actually returned. */
125	case ERROR_DEV_NOT_EXIST:
126	case ERROR_DEVICE_NOT_CONNECTED:
127	case ERROR_BAD_DEVICE:
128	case ERROR_DEVICE_REMOVED:
129	case ERROR_DEVICE_NOT_AVAILABLE:
130	return VERR_VM_DRIVER_LOAD_ERROR;
131	case ERROR_PATH_NOT_FOUND:
132	case ERROR_FILE_NOT_FOUND:
133	return VERR_VM_DRIVER_NOT_INSTALLED;
134	case ERROR_ACCESS_DENIED:
135	case ERROR_SHARING_VIOLATION:
136	return VERR_VM_DRIVER_NOT_ACCESSIBLE;
137	default:
138	return VERR_VM_DRIVER_OPEN_ERROR;
139	}
140
141	return -1 /** @todo define proper error codes for suplibOsInit failure. */;
142	}
143	}
144
145	/*
146	* Check driver version.
147	*/
148	/** @todo implement driver version checking. */
149
150	/*
151	* Reserve memory.
152	*/
153	if (cbReserve != 0)
154	{
155	/** 1 1/2 GB - (a bit more than) current VBox max. */
156	#define SUPLIB_MAX_RESERVE (_1G + _1M*512)
157	/*
158	* Find the right size to reserve.
159	*/
160	if ( cbReserve == ~(size_t)0
161	\|\| cbReserve > SUPLIB_MAX_RESERVE)
162	cbReserve = SUPLIB_MAX_RESERVE;
163	char szVar[64] = {0};
164	if (GetEnvironmentVariable("VBOX_RESERVE_MEM_LIMIT", szVar, sizeof(szVar) - 1))
165	{
166	uint64_t cb;
167	char *pszNext;
168	int rc = RTStrToUInt64Ex(szVar, &pszNext, 0, &cb);
169	if (VBOX_SUCCESS(rc))
170	{
171	switch (*pszNext)
172	{
173	case 'K':
174	case 'k':
175	cb *= _1K;
176	pszNext++;
177	break;
178	case 'M':
179	case 'm':
180	cb *= _1M;
181	pszNext++;
182	break;
183	case 'G':
184	case 'g':
185	cb *= _1G;
186	pszNext++;
187	break;
188	case '\0':
189	break;
190	}
191	if (pszNext == 'b' \|\| pszNext == 'B')
192	pszNext++;
193	if (!pszNext)
194	cbReserve = RT_MIN(SUPLIB_MAX_RESERVE, cb);
195	}
196	}
197
198	/*
199	* Try reserve virtual address space, lowering the requirements in by _1M chunks.
200	* Make sure it's possible to get at least 3 chunks of 16MBs extra after the reservation.
201	*/
202	for (cbReserve = RT_ALIGN_Z(cbReserve, _1M); cbReserve >= _1M * 64; cbReserve -= _1M)
203	{
204	void *pv = VirtualAlloc(NULL, cbReserve, MEM_RESERVE, PAGE_NOACCESS);
205	if (pv)
206	{
207	void pv1 = VirtualAlloc(NULL, _1M 16, MEM_RESERVE, PAGE_NOACCESS);
208	void pv2 = VirtualAlloc(NULL, _1M 16, MEM_RESERVE, PAGE_NOACCESS);
209	void pv3 = VirtualAlloc(NULL, _1M 16, MEM_RESERVE, PAGE_NOACCESS);
210	if (pv1)
211	VirtualFree(pv1, 0, MEM_RELEASE);
212	if (pv2)
213	VirtualFree(pv2, 0, MEM_RELEASE);
214	if (pv3)
215	VirtualFree(pv3, 0, MEM_RELEASE);
216	const int cFailures = !pv1 + !pv2 + !pv3;
217	if (!cFailures)
218	{
219	g_pvReserved = pv;
220	g_cbReserved = cbReserve;
221	#if 0 /* too early, no logging. */
222	Log(("suplibOsInit: Reserved %zu bytes at %p\n", cbReserve, g_pvReserved));
223	#endif
224	break;
225	}
226
227	cbReserve -= cFailures > 2 ? _1M * 16 : _1M;
228	}
229	else
230	cbReserve -= _1M;
231	}
232	/* ignore errors */
233	}
234
235	/*
236	* We're done.
237	*/
238	return VINF_SUCCESS;
239	}
240
241
242	/**
243	* Installs anything required by the support library.
244	*
245	* @returns 0 on success.
246	* @returns error code on failure.
247	*/
248	int suplibOsInstall(void)
249	{
250	return suplibOsCreateService();
251	}
252
253
254	/**
255	* Installs anything required by the support library.
256	*
257	* @returns 0 on success.
258	* @returns error code on failure.
259	*/
260	int suplibOsUninstall(void)
261	{
262	int rc = suplibOsStopService();
263	if (!rc)
264	rc = suplibOsDeleteService();
265	return rc;
266	}
267
268
269	/**
270	* Creates the service.
271	*
272	* @returns 0 on success.
273	* @returns -1 on failure.
274	*/
275	int suplibOsCreateService(void)
276	{
277	/*
278	* Assume it didn't exist, so we'll create the service.
279	*/
280	SC_HANDLE hSMgrCreate = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
281	DWORD LastError = GetLastError(); NOREF(LastError);
282	AssertMsg(hSMgrCreate, ("OpenSCManager(,,create) failed rc=%d\n", LastError));
283	if (hSMgrCreate)
284	{
285	char szDriver[RTPATH_MAX];
286	int rc = RTPathProgram(szDriver, sizeof(szDriver) - sizeof("\\VBoxDrv.sys"));
287	if (VBOX_SUCCESS(rc))
288	{
289	strcat(szDriver, "\\VBoxDrv.sys");
290	SC_HANDLE hService = CreateService(hSMgrCreate,
291	SERVICE_NAME,
292	"VBox Support Driver",
293	SERVICE_QUERY_STATUS,
294	SERVICE_KERNEL_DRIVER,
295	SERVICE_DEMAND_START,
296	SERVICE_ERROR_NORMAL,
297	szDriver,
298	NULL, NULL, NULL, NULL, NULL);
299	DWORD LastError = GetLastError(); NOREF(LastError);
300	AssertMsg(hService, ("CreateService failed! LastError=%Rwa szDriver=%s\n", LastError, szDriver));
301	CloseServiceHandle(hService);
302	CloseServiceHandle(hSMgrCreate);
303	return hService ? 0 : -1;
304	}
305	CloseServiceHandle(hSMgrCreate);
306	return rc;
307	}
308	return -1;
309	}
310
311	/**
312	* Stops a possibly running service.
313	*
314	* @returns 0 on success.
315	* @returns -1 on failure.
316	*/
317	int suplibOsStopService(void)
318	{
319	/*
320	* Assume it didn't exist, so we'll create the service.
321	*/
322	int rc = -1;
323	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_STOP \| SERVICE_QUERY_STATUS);
324	DWORD LastError = GetLastError(); NOREF(LastError);
325	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError));
326	if (hSMgr)
327	{
328	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_STOP \| SERVICE_QUERY_STATUS);
329	if (hService)
330	{
331	/*
332	* Stop the service.
333	*/
334	SERVICE_STATUS Status;
335	QueryServiceStatus(hService, &Status);
336	if (Status.dwCurrentState == SERVICE_STOPPED)
337	rc = 0;
338	else if (ControlService(hService, SERVICE_CONTROL_STOP, &Status))
339	{
340	int iWait = 100;
341	while (Status.dwCurrentState == SERVICE_STOP_PENDING && iWait-- > 0)
342	{
343	Sleep(100);
344	QueryServiceStatus(hService, &Status);
345	}
346	if (Status.dwCurrentState == SERVICE_STOPPED)
347	rc = 0;
348	else
349	AssertMsgFailed(("Failed to stop service. status=%d\n", Status.dwCurrentState));
350	}
351	else
352	{
353	DWORD LastError = GetLastError(); NOREF(LastError);
354	AssertMsgFailed(("ControlService failed with LastError=%Rwa. status=%d\n", LastError, Status.dwCurrentState));
355	}
356	CloseServiceHandle(hService);
357	}
358	else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
359	rc = 0;
360	else
361	{
362	DWORD LastError = GetLastError(); NOREF(LastError);
363	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
364	}
365	CloseServiceHandle(hSMgr);
366	}
367	return rc;
368	}
369
370
371	/**
372	* Deletes the service.
373	*
374	* @returns 0 on success.
375	* @returns -1 on failure.
376	*/
377	int suplibOsDeleteService(void)
378	{
379	/*
380	* Assume it didn't exist, so we'll create the service.
381	*/
382	int rc = -1;
383	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
384	DWORD LastError = GetLastError(); NOREF(LastError);
385	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError));
386	if (hSMgr)
387	{
388	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, DELETE);
389	if (hService)
390	{
391	/*
392	* Delete the service.
393	*/
394	if (DeleteService(hService))
395	rc = 0;
396	else
397	{
398	DWORD LastError = GetLastError(); NOREF(LastError);
399	AssertMsgFailed(("DeleteService failed LastError=%Rwa\n", LastError));
400	}
401	CloseServiceHandle(hService);
402	}
403	else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
404	rc = 0;
405	else
406	{
407	DWORD LastError = GetLastError(); NOREF(LastError);
408	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
409	}
410	CloseServiceHandle(hSMgr);
411	}
412	return rc;
413	}
414
415	#if 0
416	/**
417	* Creates the service.
418	*
419	* @returns 0 on success.
420	* @returns -1 on failure.
421	*/
422	int suplibOsUpdateService(void)
423	{
424	/*
425	* Assume it didn't exist, so we'll create the service.
426	*/
427	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
428	DWORD LastError = GetLastError(); NOREF(LastError);
429	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed LastError=%Rwa\n", LastError));
430	if (hSMgr)
431	{
432	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_CHANGE_CONFIG);
433	if (hService)
434	{
435	char szDriver[RTPATH_MAX];
436	int rc = RTPathProgram(szDriver, sizeof(szDriver) - sizeof("\\VBoxDrv.sys"));
437	if (VBOX_SUCCESS(rc))
438	{
439	strcat(szDriver, "\\VBoxDrv.sys");
440
441	SC_LOCK hLock = LockServiceDatabase(hSMgr);
442	if (ChangeServiceConfig(hService,
443	SERVICE_KERNEL_DRIVER,
444	SERVICE_DEMAND_START,
445	SERVICE_ERROR_NORMAL,
446	szDriver,
447	NULL, NULL, NULL, NULL, NULL, NULL))
448	{
449
450	UnlockServiceDatabase(hLock);
451	CloseServiceHandle(hService);
452	CloseServiceHandle(hSMgr);
453	return 0;
454	}
455	else
456	{
457	DWORD LastError = GetLastError(); NOREF(LastError);
458	AssertMsgFailed(("ChangeServiceConfig failed LastError=%Rwa\n", LastError));
459	}
460	}
461	UnlockServiceDatabase(hLock);
462	CloseServiceHandle(hService);
463	}
464	else
465	{
466	DWORD LastError = GetLastError(); NOREF(LastError);
467	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
468	}
469	CloseServiceHandle(hSMgr);
470	}
471	return -1;
472	}
473	#endif
474
475	/**
476	* Attempts to start the service, creating it if necessary.
477	*
478	* @returns 0 on success.
479	* @returns -1 on failure.
480	* @param fRetry Indicates retry call.
481	*/
482	int suplibOsStartService(void)
483	{
484	/*
485	* Check if the driver service is there.
486	*/
487	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_QUERY_STATUS \| SERVICE_START);
488	if (hSMgr == NULL)
489	{
490	AssertMsgFailed(("couldn't open service manager in SERVICE_QUERY_CONFIG \| SERVICE_QUERY_STATUS mode!\n"));
491	return -1;
492	}
493
494	/*
495	* Try open our service to check it's status.
496	*/
497	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
498	if (!hService)
499	{
500	/*
501	* Create the service.
502	*/
503	int rc = suplibOsCreateService();
504	if (rc)
505	return rc;
506
507	/*
508	* Try open the service.
509	*/
510	hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
511	}
512
513	/*
514	* Check if open and on demand create succeeded.
515	*/
516	int rc = -1;
517	if (hService)
518	{
519
520	/*
521	* Query service status to see if we need to start it or not.
522	*/
523	SERVICE_STATUS Status;
524	BOOL fRc = QueryServiceStatus(hService, &Status);
525	Assert(fRc);
526	if ( Status.dwCurrentState != SERVICE_RUNNING
527	&& Status.dwCurrentState != SERVICE_START_PENDING)
528	{
529	/*
530	* Start it.
531	*/
532	fRc = StartService(hService, 0, NULL);
533	DWORD LastError = GetLastError(); NOREF(LastError);
534	AssertMsg(fRc, ("StartService failed with LastError=%Rwa\n", LastError));
535	}
536
537	/*
538	* Wait for the service to finish starting.
539	* We'll wait for 10 seconds then we'll give up.
540	*/
541	QueryServiceStatus(hService, &Status);
542	if (Status.dwCurrentState == SERVICE_START_PENDING)
543	{
544	int iWait;
545	for (iWait = 100; iWait > 0 && Status.dwCurrentState == SERVICE_START_PENDING; iWait--)
546	{
547	Sleep(100);
548	QueryServiceStatus(hService, &Status);
549	}
550	DWORD LastError = GetLastError(); NOREF(LastError);
551	AssertMsg(Status.dwCurrentState != SERVICE_RUNNING,
552	("Failed to start. LastError=%Rwa iWait=%d status=%d\n",
553	LastError, iWait, Status.dwCurrentState));
554	}
555
556	if (Status.dwCurrentState == SERVICE_RUNNING)
557	rc = 0;
558
559	/*
560	* Close open handles.
561	*/
562	CloseServiceHandle(hService);
563	}
564	else
565	{
566	DWORD LastError = GetLastError(); NOREF(LastError);
567	AssertMsgFailed(("OpenService failed! LastError=%Rwa\n", LastError));
568	}
569	if (!CloseServiceHandle(hSMgr))
570	AssertFailed();
571
572	return rc;
573	}
574
575
576	int suplibOsTerm(void)
577	{
578	/*
579	* Check if we're initited at all.
580	*/
581	if (g_hDevice != INVALID_HANDLE_VALUE)
582	{
583	if (!CloseHandle(g_hDevice))
584	AssertFailed();
585	g_hDevice = INVALID_HANDLE_VALUE;
586	}
587
588	/*
589	* If we started the service we might consider stopping it too.
590	*
591	* Since this won't work unless the the process starting it is the
592	* last user we might wanna skip this...
593	*/
594	if (g_fStartedService)
595	{
596	suplibOsStopService();
597	g_fStartedService = false;
598	}
599
600	return 0;
601	}
602
603
604	/**
605	* Send a I/O Control request to the device.
606	*
607	* @returns 0 on success.
608	* @returns VBOX error code on failure.
609	* @param uFunction IO Control function.
610	* @param pvIn Input data buffer.
611	* @param cbIn Size of input data.
612	* @param pvOut Output data buffer.
613	* @param cbOut Size of output data.
614	*/
615	int suplibOsIOCtl(unsigned uFunction, void pvIn, size_t cbIn, void pvOut, size_t cbOut)
616	{
617	AssertMsg(g_hDevice != INVALID_HANDLE_VALUE, ("SUPLIB not initiated successfully!\n"));
618	/*
619	* Issue device I/O control.
620	*/
621	DWORD cbReturned = (ULONG)cbOut;
622	if (DeviceIoControl(g_hDevice, uFunction, pvIn, (ULONG)cbIn, pvOut, (ULONG)cbOut, &cbReturned, NULL))
623	return 0;
624	return suplibConvertWin32Err(GetLastError());
625	}
626
627
628	#ifdef VBOX_WITHOUT_IDT_PATCHING
629	int suplibOSIOCtlFast(unsigned uFunction)
630	{
631	/*
632	* Issue device I/O control.
633	*/
634	int rc = VERR_INTERNAL_ERROR;
635	DWORD cbReturned = (ULONG)sizeof(rc);
636	if (DeviceIoControl(g_hDevice, uFunction, NULL, 0, &rc, (DWORD)sizeof(rc), &cbReturned, NULL))
637	return rc;
638	return suplibConvertWin32Err(GetLastError());
639	}
640	#endif
641
642
643	/**
644	* Allocate a number of zero-filled pages in user space.
645	*
646	* @returns VBox status code.
647	* @param cPages Number of pages to allocate.
648	* @param ppvPages Where to return the base pointer.
649	*/
650	int suplibOsPageAlloc(size_t cPages, void **ppvPages)
651	{
652	if (g_pvReserved)
653	{
654	if (VirtualFree(g_pvReserved, 0, MEM_RELEASE))
655	Log(("suplibOsPageAlloc: Freed %zu bytes of reserved memory at %p.\n", g_cbReserved, g_pvReserved));
656	else
657	{
658	DWORD LastError = GetLastError(); NOREF(LastError);
659	AssertMsgFailed(("LastError=%Rwa g_pvReserved=%p\n", LastError, g_pvReserved));
660	}
661	g_pvReserved = NULL;
662	}
663
664	*ppvPages = VirtualAlloc(NULL, (size_t)cPages << PAGE_SHIFT, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
665	if (*ppvPages)
666	return VINF_SUCCESS;
667	return suplibConvertWin32Err(GetLastError());
668	}
669
670
671	/**
672	* Frees pages allocated by suplibOsPageAlloc().
673	*
674	* @returns VBox status code.
675	* @param pvPages Pointer to pages.
676	*/
677	int suplibOsPageFree(void pvPages, size_t / cPages */)
678	{
679	if (VirtualFree(pvPages, 0, MEM_RELEASE))
680	return VINF_SUCCESS;
681	return suplibConvertWin32Err(GetLastError());
682	}
683
684
685	/**
686	* Converts a supdrv error code to an nt status code.
687	*
688	* @returns corresponding SUPDRV_ERR_*.
689	* @param rc Win32 error code.
690	*/
691	static int suplibConvertWin32Err(int rc)
692	{
693	/* Conversion program (link with ntdll.lib from ddk):
694	#define _WIN32_WINNT 0x0501
695	#include <windows.h>
696	#include <ntstatus.h>
697	#include <winternl.h>
698	#include <stdio.h>
699
700	int main()
701	{
702	#define CONVERT(a) printf(#a " %#x -> %d\n", a, RtlNtStatusToDosError((a)))
703	CONVERT(STATUS_SUCCESS);
704	CONVERT(STATUS_NOT_SUPPORTED);
705	CONVERT(STATUS_INVALID_PARAMETER);
706	CONVERT(STATUS_UNKNOWN_REVISION);
707	CONVERT(STATUS_INVALID_HANDLE);
708	CONVERT(STATUS_INVALID_ADDRESS);
709	CONVERT(STATUS_NOT_LOCKED);
710	CONVERT(STATUS_IMAGE_ALREADY_LOADED);
711	CONVERT(STATUS_ACCESS_DENIED);
712	CONVERT(STATUS_REVISION_MISMATCH);
713
714	return 0;
715	}
716	*/
717
718	switch (rc)
719	{
720	//case 0: return STATUS_SUCCESS;
721	case 0: return VINF_SUCCESS;
722	//case SUPDRV_ERR_GENERAL_FAILURE: return STATUS_NOT_SUPPORTED;
723	case ERROR_NOT_SUPPORTED: return VERR_GENERAL_FAILURE;
724	//case SUPDRV_ERR_INVALID_PARAM: return STATUS_INVALID_PARAMETER;
725	case ERROR_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
726	//case SUPDRV_ERR_INVALID_MAGIC: return STATUS_ACCESS_DENIED;
727	case ERROR_UNKNOWN_REVISION: return VERR_INVALID_MAGIC;
728	//case SUPDRV_ERR_INVALID_HANDLE: return STATUS_INVALID_HANDLE;
729	case ERROR_INVALID_HANDLE: return VERR_INVALID_HANDLE;
730	//case SUPDRV_ERR_INVALID_POINTER: return STATUS_INVALID_ADDRESS;
731	case ERROR_UNEXP_NET_ERR: return VERR_INVALID_POINTER;
732	//case SUPDRV_ERR_LOCK_FAILED: return STATUS_NOT_LOCKED;
733	case ERROR_NOT_LOCKED: return VERR_LOCK_FAILED;
734	//case SUPDRV_ERR_ALREADY_LOADED: return STATUS_IMAGE_ALREADY_LOADED;
735	case ERROR_SERVICE_ALREADY_RUNNING: return VERR_ALREADY_LOADED;
736	//case SUPDRV_ERR_PERMISSION_DENIED: return STATUS_ACCESS_DENIED;
737	case ERROR_ACCESS_DENIED: return VERR_PERMISSION_DENIED;
738	//case SUPDRV_ERR_VERSION_MISMATCH: return STATUS_REVISION_MISMATCH;
739	case ERROR_REVISION_MISMATCH: return VERR_VERSION_MISMATCH;
740	}
741
742	/* fall back on the default conversion. */
743	return RTErrConvertFromWin32(rc);
744	}
745
746
747

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostDrivers/Support/win32/SUPLib-win32.cpp@ 2981

Download in other formats: