VirtualBox

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

Last change on this file since 2676 was 2515, checked in by vboxsync, 17 years ago

Implemented non-IDT patching mode for windows (not used anywhere yet but useful for debugging).
  • 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 InnoTek Systemberatung 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. */
59static HANDLE g_hDevice = INVALID_HANDLE_VALUE;
60/** Flags whether or not we started the service. */
61static bool g_fStartedService = false;
62/** Pointer to the area of memory we reserve for SUPPageAlloc(). */
63static void *g_pvReserved = NULL;
64/** The number of bytes we reserved for SUPPageAlloc(). */
65static size_t g_cbReserved = 0;
66
67
68/*******************************************************************************
69* Internal Functions *
70*******************************************************************************/
71static int suplibOsCreateService(void);
72static int suplibOsUpdateService(void);
73static int suplibOsDeleteService(void);
74static int suplibOsStartService(void);
75static int suplibOsStopService(void);
76static 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 */
90int 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 */
248int 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 */
260int 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 */
275int 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 */
317int 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 */
377int 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 */
422int 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 */
482int 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
576int 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 */
615int 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
629int 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 */
650int 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 */
677int 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 */
691static 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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use