VirtualBox

source: vbox/trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp@ 10682

Last change on this file since 10682 was 10662, checked in by vboxsync, 17 years ago

Increased the IOC version to 7.4 with the exporting of SUPR0ComponentQueryFactory and friends. Added release logging to darwin, windows and freebsd.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.5 KB
Line 
1/* $Id: SUPDrv-win.cpp 10662 2008-07-15 14:36:00Z vboxsync $ */
2/** @file
3 * VBoxDrv - The VirtualBox Support Driver - Windows NT specifics.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 *
26 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31/*******************************************************************************
32* Header Files *
33*******************************************************************************/
34#define LOG_GROUP LOG_GROUP_SUP_DRV
35#include "../SUPDrvInternal.h"
36#include <excpt.h>
37#include <iprt/assert.h>
38#include <iprt/process.h>
39#include <iprt/initterm.h>
40#include <VBox/log.h>
41
42
43/*******************************************************************************
44* Defined Constants And Macros *
45*******************************************************************************/
46/** The support service name. */
47#define SERVICE_NAME "VBoxDrv"
48/** Win32 Device name. */
49#define DEVICE_NAME "\\\\.\\VBoxDrv"
50/** NT Device name. */
51#define DEVICE_NAME_NT L"\\Device\\VBoxDrv"
52/** Win Symlink name. */
53#define DEVICE_NAME_DOS L"\\DosDevices\\VBoxDrv"
54/** The Pool tag (VBox). */
55#define SUPDRV_NT_POOL_TAG 'xoBV'
56
57
58/*******************************************************************************
59* Structures and Typedefs *
60*******************************************************************************/
61#if 0 //def RT_ARCH_AMD64
62typedef struct SUPDRVEXECMEM
63{
64 PMDL pMdl;
65 void *pvMapping;
66 void *pvAllocation;
67} SUPDRVEXECMEM, *PSUPDRVEXECMEM;
68#endif
69
70
71/*******************************************************************************
72* Internal Functions *
73*******************************************************************************/
74static void _stdcall VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj);
75static NTSTATUS _stdcall VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
76static NTSTATUS _stdcall VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
77static NTSTATUS _stdcall VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
78static int VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack);
79static NTSTATUS _stdcall VBoxDrvNtInternalDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
80static NTSTATUS _stdcall VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
81static NTSTATUS VBoxDrvNtErr2NtStatus(int rc);
82
83
84/*******************************************************************************
85* Exported Functions *
86*******************************************************************************/
87__BEGIN_DECLS
88ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath);
89__END_DECLS
90
91
92/**
93 * Driver entry point.
94 *
95 * @returns appropriate status code.
96 * @param pDrvObj Pointer to driver object.
97 * @param pRegPath Registry base path.
98 */
99ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
100{
101 NTSTATUS rc;
102 dprintf(("VBoxDrv::DriverEntry\n"));
103
104 /*
105 * Create device.
106 * (That means creating a device object and a symbolic link so the DOS
107 * subsystems (OS/2, win32, ++) can access the device.)
108 */
109 UNICODE_STRING DevName;
110 RtlInitUnicodeString(&DevName, DEVICE_NAME_NT);
111 PDEVICE_OBJECT pDevObj;
112 rc = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXT), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj);
113 if (NT_SUCCESS(rc))
114 {
115 UNICODE_STRING DosName;
116 RtlInitUnicodeString(&DosName, DEVICE_NAME_DOS);
117 rc = IoCreateSymbolicLink(&DosName, &DevName);
118 if (NT_SUCCESS(rc))
119 {
120 int vrc = RTR0Init(0);
121 if (RT_SUCCESS(rc))
122 {
123 /*
124 * Initialize the device extension.
125 */
126 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
127 memset(pDevExt, 0, sizeof(*pDevExt));
128
129 vrc = supdrvInitDevExt(pDevExt);
130 if (!vrc)
131 {
132 /*
133 * Setup the driver entry points in pDrvObj.
134 */
135 pDrvObj->DriverUnload = VBoxDrvNtUnload;
136 pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate;
137 pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose;
138 pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl;
139#if 0 /** @todo test IDC on windows. */
140 pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl;
141#endif
142 pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtNotSupportedStub;
143 pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub;
144 /* more? */
145 dprintf(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n"));
146 return STATUS_SUCCESS;
147 }
148
149 dprintf(("supdrvInitDevExit failed with vrc=%d!\n", vrc));
150 rc = VBoxDrvNtErr2NtStatus(vrc);
151
152 IoDeleteSymbolicLink(&DosName);
153 RTR0Term();
154 }
155 else
156 {
157 dprintf(("RTR0Init failed with vrc=%d!\n", vrc));
158 rc = VBoxDrvNtErr2NtStatus(vrc);
159 }
160 }
161 else
162 dprintf(("IoCreateSymbolicLink failed with rc=%#x!\n", rc));
163
164 IoDeleteDevice(pDevObj);
165 }
166 else
167 dprintf(("IoCreateDevice failed with rc=%#x!\n", rc));
168
169 if (NT_SUCCESS(rc))
170 rc = STATUS_INVALID_PARAMETER;
171 dprintf(("VBoxDrv::DriverEntry returning %#x\n", rc));
172 return rc;
173}
174
175
176/**
177 * Unload the driver.
178 *
179 * @param pDrvObj Driver object.
180 */
181void _stdcall VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj)
182{
183 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDrvObj->DeviceObject->DeviceExtension;
184
185 dprintf(("VBoxDrvNtUnload at irql %d\n", KeGetCurrentIrql()));
186
187 /*
188 * We ASSUME that it's not possible to unload a driver with open handles.
189 * Start by deleting the symbolic link
190 */
191 UNICODE_STRING DosName;
192 RtlInitUnicodeString(&DosName, DEVICE_NAME_DOS);
193 NTSTATUS rc = IoDeleteSymbolicLink(&DosName);
194
195 /*
196 * Terminate the GIP page and delete the device extension.
197 */
198 supdrvDeleteDevExt(pDevExt);
199 RTR0Term();
200 IoDeleteDevice(pDrvObj->DeviceObject);
201}
202
203
204/**
205 * Create (i.e. Open) file entry point.
206 *
207 * @param pDevObj Device object.
208 * @param pIrp Request packet.
209 */
210NTSTATUS _stdcall VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
211{
212 dprintf(("VBoxDrvNtCreate\n"));
213 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
214 PFILE_OBJECT pFileObj = pStack->FileObject;
215 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
216
217 /*
218 * We are not remotely similar to a directory...
219 * (But this is possible.)
220 */
221 if (pStack->Parameters.Create.Options & FILE_DIRECTORY_FILE)
222 {
223 pIrp->IoStatus.Status = STATUS_NOT_A_DIRECTORY;
224 pIrp->IoStatus.Information = 0;
225 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
226 return STATUS_NOT_A_DIRECTORY;
227 }
228
229 /*
230 * Call common code for the rest.
231 */
232 pFileObj->FsContext = NULL;
233 PSUPDRVSESSION pSession;
234#if 0 /** @todo check if this works, consider OBJ_KERNEL_HANDLE too. */
235 bool fUser = pIrp->RequestorMode != KernelMode;
236#else
237 bool fUser = true;
238#endif
239 int rc = supdrvCreateSession(pDevExt, fUser, &pSession);
240 if (!rc)
241 pFileObj->FsContext = pSession;
242
243 NTSTATUS rcNt = pIrp->IoStatus.Status = VBoxDrvNtErr2NtStatus(rc);
244 pIrp->IoStatus.Information = 0;
245 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
246
247 return rcNt;
248}
249
250
251/**
252 * Close file entry point.
253 *
254 * @param pDevObj Device object.
255 * @param pIrp Request packet.
256 */
257NTSTATUS _stdcall VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
258{
259 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
260 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
261 PFILE_OBJECT pFileObj = pStack->FileObject;
262 dprintf(("VBoxDrvNtClose: pDevExt=%p pFileObj=%p pSession=%p\n",
263 pDevExt, pFileObj, pFileObj->FsContext));
264 supdrvCloseSession(pDevExt, (PSUPDRVSESSION)pFileObj->FsContext);
265 pFileObj->FsContext = NULL;
266 pIrp->IoStatus.Information = 0;
267 pIrp->IoStatus.Status = STATUS_SUCCESS;
268 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
269
270 return STATUS_SUCCESS;
271}
272
273
274/**
275 * Device I/O Control entry point.
276 *
277 * @param pDevObj Device object.
278 * @param pIrp Request packet.
279 */
280NTSTATUS _stdcall VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
281{
282 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
283 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
284 PSUPDRVSESSION pSession = (PSUPDRVSESSION)pStack->FileObject->FsContext;
285
286 /*
287 * Deal with the two high-speed IOCtl that takes it's arguments from
288 * the session and iCmd, and only returns a VBox status code.
289 */
290 ULONG ulCmd = pStack->Parameters.DeviceIoControl.IoControlCode;
291 if ( ulCmd == SUP_IOCTL_FAST_DO_RAW_RUN
292 || ulCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
293 || ulCmd == SUP_IOCTL_FAST_DO_NOP)
294 {
295 KIRQL oldIrql;
296 int rc;
297
298 /* Raise the IRQL to DISPATCH_LEVEl to prevent Windows from rescheduling us to another CPU/core. */
299 Assert(KeGetCurrentIrql() <= DISPATCH_LEVEL);
300 KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
301 rc = supdrvIOCtlFast(ulCmd, pDevExt, pSession);
302 KeLowerIrql(oldIrql);
303
304 /* Complete the I/O request. */
305 NTSTATUS rcNt = pIrp->IoStatus.Status = STATUS_SUCCESS;
306 pIrp->IoStatus.Information = sizeof(rc);
307 __try
308 {
309 *(int *)pIrp->UserBuffer = rc;
310 }
311 __except(EXCEPTION_EXECUTE_HANDLER)
312 {
313 rcNt = pIrp->IoStatus.Status = GetExceptionCode();
314 dprintf(("VBoxSupDrvDeviceContorl: Exception Code %#x\n", rcNt));
315 }
316 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
317 return rcNt;
318 }
319
320 return VBoxDrvNtDeviceControlSlow(pDevExt, pSession, pIrp, pStack);
321}
322
323
324/**
325 * Worker for VBoxDrvNtDeviceControl that takes the slow IOCtl functions.
326 *
327 * @returns NT status code.
328 *
329 * @param pDevObj Device object.
330 * @param pSession The session.
331 * @param pIrp Request packet.
332 * @param pStack The stack location containing the DeviceControl parameters.
333 */
334static int VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack)
335{
336 NTSTATUS rcNt;
337 unsigned cbOut = 0;
338 int rc = 0;
339 dprintf2(("VBoxDrvNtDeviceControlSlow(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
340 pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
341 pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
342 pStack->Parameters.DeviceIoControl.OutputBufferLength, pSession));
343
344#ifdef RT_ARCH_AMD64
345 /* Don't allow 32-bit processes to do any I/O controls. */
346 if (!IoIs32bitProcess(pIrp))
347#endif
348 {
349 /* Verify that it's a buffered CTL. */
350 if ((pStack->Parameters.DeviceIoControl.IoControlCode & 0x3) == METHOD_BUFFERED)
351 {
352 /* Verify that the sizes in the request header are correct. */
353 PSUPREQHDR pHdr = (PSUPREQHDR)pIrp->AssociatedIrp.SystemBuffer;
354 if ( pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr)
355 && pStack->Parameters.DeviceIoControl.InputBufferLength == pHdr->cbIn
356 && pStack->Parameters.DeviceIoControl.OutputBufferLength == pHdr->cbOut)
357 {
358 /*
359 * Do the job.
360 */
361 rc = supdrvIOCtl(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession, pHdr);
362 if (!rc)
363 {
364 rcNt = STATUS_SUCCESS;
365 cbOut = pHdr->cbOut;
366 if (cbOut > pStack->Parameters.DeviceIoControl.OutputBufferLength)
367 {
368 cbOut = pStack->Parameters.DeviceIoControl.OutputBufferLength;
369 OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n",
370 pHdr->cbOut, cbOut, pStack->Parameters.DeviceIoControl.IoControlCode));
371 }
372 }
373 else
374 rcNt = STATUS_INVALID_PARAMETER;
375 dprintf2(("VBoxDrvNtDeviceControlSlow: returns %#x cbOut=%d rc=%#x\n", rcNt, cbOut, rc));
376 }
377 else
378 {
379 dprintf(("VBoxDrvNtDeviceControlSlow: Mismatching sizes (%#x) - Hdr=%#lx/%#lx Irp=%#lx/%#lx!\n",
380 pStack->Parameters.DeviceIoControl.IoControlCode,
381 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbIn : 0,
382 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbOut : 0,
383 pStack->Parameters.DeviceIoControl.InputBufferLength,
384 pStack->Parameters.DeviceIoControl.OutputBufferLength));
385 rcNt = STATUS_INVALID_PARAMETER;
386 }
387 }
388 else
389 {
390 dprintf(("VBoxDrvNtDeviceControlSlow: not buffered request (%#x) - not supported\n",
391 pStack->Parameters.DeviceIoControl.IoControlCode));
392 rcNt = STATUS_NOT_SUPPORTED;
393 }
394 }
395#ifdef RT_ARCH_AMD64
396 else
397 {
398 dprintf(("VBoxDrvNtDeviceControlSlow: WOW64 req - not supported\n"));
399 rcNt = STATUS_NOT_SUPPORTED;
400 }
401#endif
402
403 /* complete the request. */
404 pIrp->IoStatus.Status = rcNt;
405 pIrp->IoStatus.Information = cbOut;
406 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
407 return rcNt;
408}
409
410
411/**
412 * Internal Device I/O Control entry point, used for IDC.
413 *
414 * @param pDevObj Device object.
415 * @param pIrp Request packet.
416 */
417NTSTATUS _stdcall VBoxDrvNtInternalDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
418{
419 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pDevObj->DeviceExtension;
420 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
421 PFILE_OBJECT pFileObj = pStack ? pStack->FileObject : NULL;
422 PSUPDRVSESSION pSession = pFileObj ? (PSUPDRVSESSION)pFileObj->FsContext : NULL;
423 NTSTATUS rcNt;
424 unsigned cbOut = 0;
425 int rc = 0;
426 dprintf2(("VBoxDrvNtInternalDeviceControl(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
427 pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
428 pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
429 pStack->Parameters.DeviceIoControl.OutputBufferLength, pSession));
430
431/** @todo IDC on NT: figure when to create the session and that stuff... */
432
433 /* Verify that it's a buffered CTL. */
434 if ((pStack->Parameters.DeviceIoControl.IoControlCode & 0x3) == METHOD_BUFFERED)
435 {
436 /* Verify the pDevExt in the session. */
437 if ( ( !pSession
438 && pStack->Parameters.DeviceIoControl.IoControlCode == SUPDRV_IDC_REQ_CONNECT)
439 || ( VALID_PTR(pSession)
440 && pSession->pDevExt == pDevExt))
441 {
442 /* Verify that the size in the request header is correct. */
443 PSUPDRVIDCREQHDR pHdr = (PSUPDRVIDCREQHDR)pIrp->AssociatedIrp.SystemBuffer;
444 if ( pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr)
445 && pStack->Parameters.DeviceIoControl.InputBufferLength == pHdr->cb
446 && pStack->Parameters.DeviceIoControl.OutputBufferLength == pHdr->cb)
447 {
448 /*
449 * Do the job.
450 */
451 rc = supdrvIDC(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession, pHdr);
452 if (!rc)
453 {
454 rcNt = STATUS_SUCCESS;
455 cbOut = pHdr->cb;
456 }
457 else
458 rcNt = STATUS_INVALID_PARAMETER;
459 dprintf2(("VBoxDrvNtInternalDeviceControl: returns %#x/rc=%#x\n", rcNt, rc));
460 }
461 else
462 {
463 dprintf(("VBoxDrvNtInternalDeviceControl: Mismatching sizes (%#x) - Hdr=%#lx Irp=%#lx/%#lx!\n",
464 pStack->Parameters.DeviceIoControl.IoControlCode,
465 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cb : 0,
466 pStack->Parameters.DeviceIoControl.InputBufferLength,
467 pStack->Parameters.DeviceIoControl.OutputBufferLength));
468 rcNt = STATUS_INVALID_PARAMETER;
469 }
470 }
471 else
472 rcNt = STATUS_NOT_SUPPORTED;
473 }
474 else
475 {
476 dprintf(("VBoxDrvNtInternalDeviceControl: not buffered request (%#x) - not supported\n",
477 pStack->Parameters.DeviceIoControl.IoControlCode));
478 rcNt = STATUS_NOT_SUPPORTED;
479 }
480
481 /* complete the request. */
482 pIrp->IoStatus.Status = rcNt;
483 pIrp->IoStatus.Information = cbOut;
484 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
485 return rcNt;
486}
487
488
489/**
490 * Stub function for functions we don't implemented.
491 *
492 * @returns STATUS_NOT_SUPPORTED
493 * @param pDevObj Device object.
494 * @param pIrp IRP.
495 */
496NTSTATUS _stdcall VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
497{
498 dprintf(("VBoxDrvNtNotSupportedStub\n"));
499 pDevObj = pDevObj;
500
501 pIrp->IoStatus.Information = 0;
502 pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
503 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
504
505 return STATUS_NOT_SUPPORTED;
506}
507
508
509/**
510 * Initializes any OS specific object creator fields.
511 */
512void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
513{
514 NOREF(pObj);
515 NOREF(pSession);
516}
517
518
519/**
520 * Checks if the session can access the object.
521 *
522 * @returns true if a decision has been made.
523 * @returns false if the default access policy should be applied.
524 *
525 * @param pObj The object in question.
526 * @param pSession The session wanting to access the object.
527 * @param pszObjName The object name, can be NULL.
528 * @param prc Where to store the result when returning true.
529 */
530bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char *pszObjName, int *prc)
531{
532 NOREF(pObj);
533 NOREF(pSession);
534 NOREF(pszObjName);
535 NOREF(prc);
536 return false;
537}
538
539
540/**
541 * Force async tsc mode (stub).
542 */
543bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
544{
545 return false;
546}
547
548
549/**
550 * Converts a supdrv error code to an nt status code.
551 *
552 * @returns corresponding nt status code.
553 * @param rc supdrv error code (SUPDRV_ERR_* defines).
554 */
555static NTSTATUS VBoxDrvNtErr2NtStatus(int rc)
556{
557 switch (rc)
558 {
559 case 0: return STATUS_SUCCESS;
560 case SUPDRV_ERR_GENERAL_FAILURE: return STATUS_NOT_SUPPORTED;
561 case SUPDRV_ERR_INVALID_PARAM: return STATUS_INVALID_PARAMETER;
562 case SUPDRV_ERR_INVALID_MAGIC: return STATUS_UNKNOWN_REVISION;
563 case SUPDRV_ERR_INVALID_HANDLE: return STATUS_INVALID_HANDLE;
564 case SUPDRV_ERR_INVALID_POINTER: return STATUS_INVALID_ADDRESS;
565 case SUPDRV_ERR_LOCK_FAILED: return STATUS_NOT_LOCKED;
566 case SUPDRV_ERR_ALREADY_LOADED: return STATUS_IMAGE_ALREADY_LOADED;
567 case SUPDRV_ERR_PERMISSION_DENIED: return STATUS_ACCESS_DENIED;
568 case SUPDRV_ERR_VERSION_MISMATCH: return STATUS_REVISION_MISMATCH;
569 }
570
571 return STATUS_UNSUCCESSFUL;
572}
573
574
575
576/** @todo move this to IPRT */
577RTDECL(void) AssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)
578{
579 DbgPrint("\n!!Assertion Failed!!\n"
580 "Expression: %s\n"
581 "Location : %s(%d) %s\n",
582 pszExpr, pszFile, uLine, pszFunction);
583}
584
585/** @todo use the nocrt stuff? */
586int VBOXCALL mymemcmp(const void *pv1, const void *pv2, size_t cb)
587{
588 const uint8_t *pb1 = (const uint8_t *)pv1;
589 const uint8_t *pb2 = (const uint8_t *)pv2;
590 for (; cb > 0; cb--, pb1++, pb2++)
591 if (*pb1 != *pb2)
592 return *pb1 - *pb2;
593 return 0;
594}
595
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette