VirtualBox

Changeset 44983 in vbox


Ignore:
Timestamp:
Mar 11, 2013 1:34:31 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84204
Message:

VBoxGuest-win*: cleanups.

Location:
trunk/src/VBox/Additions/common/VBoxGuest
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win-legacy.cpp

    r44980 r44983  
    115115            if (NT_SUCCESS(rc))
    116116            {
    117                 rc = vboxguestwinInit(pDrvObj, pDeviceObject, pRegPath);
     117                rc = vbgdNtInit(pDrvObj, pDeviceObject, pRegPath);
    118118                if (NT_SUCCESS(rc))
    119119                {
  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win-pnp.cpp

    r44529 r44983  
    2828*   Defined Constants And Macros                                               *
    2929*******************************************************************************/
    30 extern winVersion_t g_winVersion;
    31 
    3230RT_C_DECLS_BEGIN
    33 static NTSTATUS vboxguestwinSendIrpSynchronously(PDEVICE_OBJECT pDevObj, PIRP pIrp, BOOLEAN fStrict);
    34 static NTSTATUS vboxguestwinPnPIrpComplete(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent);
    35 static VOID     vboxguestwinShowDeviceResources(PCM_PARTIAL_RESOURCE_LIST pResourceList);
     31static NTSTATUS vbgdNtSendIrpSynchronously(PDEVICE_OBJECT pDevObj, PIRP pIrp, BOOLEAN fStrict);
     32static NTSTATUS vbgdNtPnPIrpComplete(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent);
     33static VOID     vbgdNtShowDeviceResources(PCM_PARTIAL_RESOURCE_LIST pResourceList);
    3634RT_C_DECLS_END
    3735
    3836#ifdef ALLOC_PRAGMA
    39 #pragma alloc_text (PAGE, vboxguestwinPnP)
    40 #pragma alloc_text (PAGE, vboxguestwinPower)
    41 #pragma alloc_text (PAGE, vboxguestwinSendIrpSynchronously)
    42 #pragma alloc_text (PAGE, vboxguestwinShowDeviceResources)
     37#pragma alloc_text (PAGE, vbgdNtPnP)
     38#pragma alloc_text (PAGE, vbgdNtPower)
     39#pragma alloc_text (PAGE, vbgdNtSendIrpSynchronously)
     40#pragma alloc_text (PAGE, vbgdNtShowDeviceResources)
    4341#endif
    4442
     
    4644#define LOG_ENABLED
    4745
    48 
    49 /*******************************************************************************
    50 *   Internal Functions                                                         *
    51 *******************************************************************************/
    5246
    5347/**
     
    5953 * @return   NT status code
    6054 */
    61 static NTSTATUS vboxguestwinPnpIrpComplete(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent)
     55static NTSTATUS vbgdNtPnpIrpComplete(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent)
    6256{
    6357    KeSetEvent(pEvent, 0, FALSE);
     
    7468 * @return   NT status code
    7569 */
    76 static NTSTATUS vboxguestwinSendIrpSynchronously(PDEVICE_OBJECT pDevObj, PIRP pIrp, BOOLEAN fStrict)
     70static NTSTATUS vbgdNtSendIrpSynchronously(PDEVICE_OBJECT pDevObj, PIRP pIrp, BOOLEAN fStrict)
    7771{
    7872    KEVENT event;
     
    8175
    8276    IoCopyCurrentIrpStackLocationToNext(pIrp);
    83     IoSetCompletionRoutine(pIrp, (PIO_COMPLETION_ROUTINE)vboxguestwinPnpIrpComplete,
     77    IoSetCompletionRoutine(pIrp, (PIO_COMPLETION_ROUTINE)vbgdNtPnpIrpComplete,
    8478                           &event, TRUE, TRUE, TRUE);
    8579
     
    9892    }
    9993
    100     Log(("VBoxGuest::vboxguestwinSendIrpSynchronously: Returning 0x%x\n", rc));
     94    Log(("VBoxGuest::vbgdNtSendIrpSynchronously: Returning 0x%x\n", rc));
    10195    return rc;
    10296}
     
    109103 * @param  pIrp       Request packet.
    110104 */
    111 NTSTATUS vboxguestwinPnP(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     105NTSTATUS vbgdNtPnP(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    112106{
    113107    PVBOXGUESTDEVEXT   pDevExt = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
     
    142136        "IRP_MN_SURPRISE_REMOVAL",
    143137    };
    144     Log(("VBoxGuest::vboxguestwinGuestPnp: MinorFunction: %s\n",
     138    Log(("VBoxGuest::vbgdNtGuestPnp: MinorFunction: %s\n",
    145139           pStack->MinorFunction < (sizeof(aszFnctName) / sizeof(aszFnctName[0]))
    146140         ? aszFnctName[pStack->MinorFunction]
     
    153147        case IRP_MN_START_DEVICE:
    154148        {
    155             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: START_DEVICE\n"));
     149            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: START_DEVICE\n"));
    156150
    157151            /* This must be handled first by the lower driver. */
    158             rc = vboxguestwinSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
     152            rc = vbgdNtSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
    159153
    160154            if (   NT_SUCCESS(rc)
    161155                && NT_SUCCESS(pIrp->IoStatus.Status))
    162156            {
    163                 Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: START_DEVICE: pStack->Parameters.StartDevice.AllocatedResources = %p\n",
     157                Log(("VBoxGuest::vbgdNtVBoxGuestPnP: START_DEVICE: pStack->Parameters.StartDevice.AllocatedResources = %p\n",
    164158                     pStack->Parameters.StartDevice.AllocatedResources));
    165159
    166160                if (!pStack->Parameters.StartDevice.AllocatedResources)
    167161                {
    168                     Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: START_DEVICE: No resources, pDevExt = %p, nextLowerDriver = %p!\n",
     162                    Log(("VBoxGuest::vbgdNtVBoxGuestPnP: START_DEVICE: No resources, pDevExt = %p, nextLowerDriver = %p!\n",
    169163                         pDevExt, pDevExt ? pDevExt->win.s.pNextLowerDriver : NULL));
    170164                    rc = STATUS_UNSUCCESSFUL;
     
    172166                else
    173167                {
    174                     rc = vboxguestwinInit(pDevObj, pIrp);
     168                    rc = vbgdNtInit(pDevObj, pIrp);
    175169                }
    176170            }
     
    178172            if (NT_ERROR(rc))
    179173            {
    180                 Log(("VBoxGuest::vboxguestwinGuestPnp: START_DEVICE: Error: rc = 0x%x\n", rc));
     174                Log(("VBoxGuest::vbgdNtGuestPnp: START_DEVICE: Error: rc = 0x%x\n", rc));
    181175
    182176                /* Need to unmap memory in case of errors ... */
    183                 vboxguestwinUnmapVMMDevMemory(pDevExt);
     177                vbgdNtUnmapVMMDevMemory(pDevExt);
    184178            }
    185179            break;
     
    188182        case IRP_MN_CANCEL_REMOVE_DEVICE:
    189183        {
    190             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: CANCEL_REMOVE_DEVICE\n"));
     184            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: CANCEL_REMOVE_DEVICE\n"));
    191185
    192186            /* This must be handled first by the lower driver. */
    193             rc = vboxguestwinSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
     187            rc = vbgdNtSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
    194188
    195189            if (NT_SUCCESS(rc) && pDevExt->win.s.devState == PENDINGREMOVE)
     
    205199        case IRP_MN_SURPRISE_REMOVAL:
    206200        {
    207             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: IRP_MN_SURPRISE_REMOVAL\n"));
     201            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: IRP_MN_SURPRISE_REMOVAL\n"));
    208202
    209203            VBOXGUEST_UPDATE_DEVSTATE(pDevExt, SURPRISEREMOVED);
     
    227221        case IRP_MN_QUERY_REMOVE_DEVICE:
    228222        {
    229             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: QUERY_REMOVE_DEVICE\n"));
     223            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: QUERY_REMOVE_DEVICE\n"));
    230224
    231225#ifdef VBOX_REBOOT_ON_UNINSTALL
    232             Log(("VBoxGuest::vboxguestwinGuestPnp: QUERY_REMOVE_DEVICE: Device cannot be removed without a reboot.\n"));
     226            Log(("VBoxGuest::vbgdNtGuestPnp: QUERY_REMOVE_DEVICE: Device cannot be removed without a reboot.\n"));
    233227            rc = STATUS_UNSUCCESSFUL;
    234228#endif /* VBOX_REBOOT_ON_UNINSTALL */
     
    244238
    245239                rc = IoCallDriver(pDevExt->win.s.pNextLowerDriver, pIrp);
    246                 Log(("VBoxGuest::vboxguestwinGuestPnp: QUERY_REMOVE_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
     240                Log(("VBoxGuest::vbgdNtGuestPnp: QUERY_REMOVE_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
    247241
    248242                /* we must not do anything the IRP after doing IoSkip & CallDriver
     
    258252        case IRP_MN_REMOVE_DEVICE:
    259253        {
    260             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: REMOVE_DEVICE\n"));
     254            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: REMOVE_DEVICE\n"));
    261255
    262256            VBOXGUEST_UPDATE_DEVSTATE(pDevExt, REMOVED);
     
    264258            /* Free hardware resources. */
    265259            /* @todo this should actually free I/O ports, interrupts, etc. */
    266             rc = vboxguestwinCleanup(pDevObj);
    267             Log(("VBoxGuest::vboxguestwinGuestPnp: REMOVE_DEVICE: vboxguestwinCleanup rc = 0x%08X\n", rc));
     260            rc = vbgdNtCleanup(pDevObj);
     261            Log(("VBoxGuest::vbgdNtGuestPnp: REMOVE_DEVICE: vbgdNtCleanup rc = 0x%08X\n", rc));
    268262
    269263            /*
     
    277271
    278272            rc = IoCallDriver(pDevExt->win.s.pNextLowerDriver, pIrp);
    279             Log(("VBoxGuest::vboxguestwinGuestPnp: REMOVE_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
     273            Log(("VBoxGuest::vbgdNtGuestPnp: REMOVE_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
    280274
    281275            IoDetachDevice(pDevExt->win.s.pNextLowerDriver);
    282276
    283             Log(("VBoxGuest::vboxguestwinGuestPnp: REMOVE_DEVICE: Removing device ...\n"));
     277            Log(("VBoxGuest::vbgdNtGuestPnp: REMOVE_DEVICE: Removing device ...\n"));
    284278
    285279            /* Destroy device extension and clean up everything else. */
     
    291285            IoDeleteSymbolicLink(&win32Name);
    292286
    293             Log(("VBoxGuest::vboxguestwinGuestPnp: REMOVE_DEVICE: Deleting device ...\n"));
     287            Log(("VBoxGuest::vbgdNtGuestPnp: REMOVE_DEVICE: Deleting device ...\n"));
    294288
    295289            /* Last action: Delete our device! pDevObj is *not* failed
     
    297291            IoDeleteDevice(pDevObj);
    298292
    299             Log(("VBoxGuest::vboxguestwinGuestPnp: REMOVE_DEVICE: Device removed!\n"));
     293            Log(("VBoxGuest::vbgdNtGuestPnp: REMOVE_DEVICE: Device removed!\n"));
    300294
    301295            /* Propagating rc from IoCallDriver. */
     
    305299        case IRP_MN_CANCEL_STOP_DEVICE:
    306300        {
    307             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: CANCEL_STOP_DEVICE\n"));
     301            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: CANCEL_STOP_DEVICE\n"));
    308302
    309303            /* This must be handled first by the lower driver. */
    310             rc = vboxguestwinSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
     304            rc = vbgdNtSendIrpSynchronously(pDevExt->win.s.pNextLowerDriver, pIrp, TRUE);
    311305
    312306            if (NT_SUCCESS(rc) && pDevExt->win.s.devState == PENDINGSTOP)
     
    322316        case IRP_MN_QUERY_STOP_DEVICE:
    323317        {
    324             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: QUERY_STOP_DEVICE\n"));
     318            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: QUERY_STOP_DEVICE\n"));
    325319
    326320#ifdef VBOX_REBOOT_ON_UNINSTALL
    327             Log(("VBoxGuest::vboxguestwinGuestPnp: QUERY_STOP_DEVICE: Device cannot be stopped without a reboot!\n"));
     321            Log(("VBoxGuest::vbgdNtGuestPnp: QUERY_STOP_DEVICE: Device cannot be stopped without a reboot!\n"));
    328322            pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
    329323#endif /* VBOX_REBOOT_ON_UNINSTALL */
     
    339333
    340334                rc = IoCallDriver(pDevExt->win.s.pNextLowerDriver, pIrp);
    341                 Log(("VBoxGuest::vboxguestwinGuestPnp: QUERY_STOP_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
     335                Log(("VBoxGuest::vbgdNtGuestPnp: QUERY_STOP_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
    342336
    343337                /* we must not do anything with the IRP after doing IoSkip & CallDriver
     
    353347        case IRP_MN_STOP_DEVICE:
    354348        {
    355             Log(("VBoxGuest::vboxguestwinVBoxGuestPnP: STOP_DEVICE\n"));
     349            Log(("VBoxGuest::vbgdNtVBoxGuestPnP: STOP_DEVICE\n"));
    356350
    357351            VBOXGUEST_UPDATE_DEVSTATE(pDevExt, STOPPED);
     
    359353            /* Free hardware resources. */
    360354            /* @todo this should actually free I/O ports, interrupts, etc. */
    361             rc = vboxguestwinCleanup(pDevObj);
    362             Log(("VBoxGuest::vboxguestwinGuestPnp: STOP_DEVICE: cleaning up, rc = 0x%x\n", rc));
     355            rc = vbgdNtCleanup(pDevObj);
     356            Log(("VBoxGuest::vbgdNtGuestPnp: STOP_DEVICE: cleaning up, rc = 0x%x\n", rc));
    363357
    364358            /* Pass to the lower driver. */
     
    368362
    369363            rc = IoCallDriver(pDevExt->win.s.pNextLowerDriver, pIrp);
    370             Log(("VBoxGuest::vboxguestwinGuestPnp: STOP_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
     364            Log(("VBoxGuest::vbgdNtGuestPnp: STOP_DEVICE: Next lower driver replied rc = 0x%x\n", rc));
    371365
    372366            return rc;
     
    384378    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    385379
    386     Log(("VBoxGuest::vboxguestwinGuestPnp: Returning with rc = 0x%x\n", rc));
     380    Log(("VBoxGuest::vbgdNtGuestPnp: Returning with rc = 0x%x\n", rc));
    387381    return rc;
    388382}
     
    397391 * @param pContext  Context value passed to IoSetCompletionRoutine in VBoxGuestPower.
    398392 */
    399 NTSTATUS vboxguestwinPowerComplete(IN PDEVICE_OBJECT pDevObj,
    400                                    IN PIRP pIrp, IN PVOID pContext)
     393static NTSTATUS vbgdNtPowerComplete(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pContext)
    401394{
    402395    PIO_STACK_LOCATION pIrpSp;
     
    442435 * @param     pIrp      IRP
    443436 */
    444 NTSTATUS vboxguestwinPower(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     437NTSTATUS vbgdNtPower(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    445438{
    446439    PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
     
    450443    POWER_ACTION       powerAction;
    451444
    452     Log(("VBoxGuest::vboxguestwinGuestPower\n"));
     445    Log(("VBoxGuest::vbgdNtGuestPower\n"));
    453446
    454447    powerType   = pStack->Parameters.Power.Type;
     
    460453        case IRP_MN_SET_POWER:
    461454        {
    462             Log(("VBoxGuest::vboxguestwinGuestPower: IRP_MN_SET_POWER, type= %d\n", powerType));
     455            Log(("VBoxGuest::vbgdNtGuestPower: IRP_MN_SET_POWER, type= %d\n", powerType));
    463456            switch (powerType)
    464457            {
    465458                case SystemPowerState:
    466459                {
    467                     Log(("VBoxGuest::vboxguestwinGuestPower: SystemPowerState, action = %d, state = %d\n", powerAction, powerState));
     460                    Log(("VBoxGuest::vbgdNtGuestPower: SystemPowerState, action = %d, state = %d\n", powerAction, powerState));
    468461
    469462                    switch (powerAction)
     
    477470                                    && pDevExt->win.s.LastSystemPowerAction == PowerActionHibernate)
    478471                                {
    479                                     Log(("VBoxGuest::vboxguestwinGuestPower: Returning from hibernation!\n"));
    480                                     int rc = VBoxGuestReinitDevExtAfterHibernation(pDevExt, vboxguestwinVersionToOSType(g_winVersion));
     472                                    Log(("VBoxGuest::vbgdNtGuestPower: Returning from hibernation!\n"));
     473                                    int rc = VBoxGuestReinitDevExtAfterHibernation(pDevExt,
     474                                                                                   vbgdNtVersionToOSType(g_enmVbgdNtVer));
    481475                                    if (RT_FAILURE(rc))
    482                                         Log(("VBoxGuest::vboxguestwinGuestPower: Cannot re-init VMMDev chain, rc = %d!\n", rc));
     476                                        Log(("VBoxGuest::vbgdNtGuestPower: Cannot re-init VMMDev chain, rc = %d!\n", rc));
    483477                                }
    484478                            }
     
    487481                        case PowerActionShutdownReset:
    488482                        {
    489                             Log(("VBoxGuest::vboxguestwinGuestPower: Power action reset!\n"));
     483                            Log(("VBoxGuest::vbgdNtGuestPower: Power action reset!\n"));
    490484
    491485                            /* Tell the VMM that we no longer support mouse pointer integration. */
     
    516510                        case PowerActionShutdownOff:
    517511                        {
    518                             Log(("VBoxGuest::vboxguestwinGuestPower: Power action shutdown!\n"));
     512                            Log(("VBoxGuest::vbgdNtGuestPower: Power action shutdown!\n"));
    519513                            if (powerState.SystemState >= PowerSystemShutdown)
    520514                            {
    521                                 Log(("VBoxGuest::vboxguestwinGuestPower: Telling the VMMDev to close the VM ...\n"));
     515                                Log(("VBoxGuest::vbgdNtGuestPower: Telling the VMMDev to close the VM ...\n"));
    522516
    523517                                VMMDevPowerStateRequest *pReq = pDevExt->win.s.pPowerStateRequest;
     
    544538                        case PowerActionHibernate:
    545539
    546                             Log(("VBoxGuest::vboxguestwinGuestPower: Power action hibernate!\n"));
     540                            Log(("VBoxGuest::vbgdNtGuestPower: Power action hibernate!\n"));
    547541                            break;
    548542                    }
     
    578572    IoCopyCurrentIrpStackLocationToNext(pIrp);
    579573    IoSetCompletionRoutine(pIrp,
    580                            vboxguestwinPowerComplete,
     574                           vbgdNtPowerComplete,
    581575                           (PVOID)pDevExt,
    582576                           TRUE,
  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win.cpp

    r44979 r44983  
     1/* $Id$ */
    12/** @file
    2  *
    33 * VBoxGuest - Windows specifics.
    4  *
    5  * Copyright (C) 2010-2012 Oracle Corporation
     4 */
     5
     6/*
     7 * Copyright (C) 2010-2013 Oracle Corporation
    68 *
    79 * This file is part of VirtualBox Open Source Edition (OSE), as
     
    3638#endif
    3739
     40
    3841/*******************************************************************************
    3942*   Internal Functions                                                         *
    4043*******************************************************************************/
    4144RT_C_DECLS_BEGIN
    42 static NTSTATUS vboxguestwinAddDevice(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj);
    43 static void     vboxguestwinUnload(PDRIVER_OBJECT pDrvObj);
    44 static NTSTATUS vboxguestwinCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    45 static NTSTATUS vboxguestwinClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    46 static NTSTATUS vboxguestwinIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    47 static NTSTATUS vboxguestwinInternalIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    48 static NTSTATUS vboxguestwinRegistryReadDWORD(ULONG ulRoot, PCWSTR pwszPath, PWSTR pwszName, PULONG puValue);
    49 static NTSTATUS vboxguestwinSystemControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    50 static NTSTATUS vboxguestwinShutdown(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    51 static NTSTATUS vboxguestwinNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     45static NTSTATUS vbgdNtAddDevice(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj);
     46static void     vbgdNtUnload(PDRIVER_OBJECT pDrvObj);
     47static NTSTATUS vbgdNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     48static NTSTATUS vbgdNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     49static NTSTATUS vbgdNtIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     50static NTSTATUS vbgdNtInternalIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     51static NTSTATUS vbgdNtRegistryReadDWORD(ULONG ulRoot, PCWSTR pwszPath, PWSTR pwszName, PULONG puValue);
     52static NTSTATUS vbgdNtSystemControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     53static NTSTATUS vbgdNtShutdown(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     54static NTSTATUS vbgdNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    5255#ifdef DEBUG
    53 static void     vboxguestwinDoTests(void);
     56static void     vbgdNtDoTests(void);
    5457#endif
    5558RT_C_DECLS_END
     
    6467
    6568#ifdef ALLOC_PRAGMA
    66 #pragma alloc_text (INIT, DriverEntry)
    67 #pragma alloc_text (PAGE, vboxguestwinAddDevice)
    68 #pragma alloc_text (PAGE, vboxguestwinUnload)
    69 #pragma alloc_text (PAGE, vboxguestwinCreate)
    70 #pragma alloc_text (PAGE, vboxguestwinClose)
    71 #pragma alloc_text (PAGE, vboxguestwinIOCtl)
    72 #pragma alloc_text (PAGE, vboxguestwinShutdown)
    73 #pragma alloc_text (PAGE, vboxguestwinNotSupportedStub)
    74 #pragma alloc_text (PAGE, vboxguestwinScanPCIResourceList)
    75 #endif
    76 
    77 /** The detected Windows version. */
    78 winVersion_t g_winVersion;
     69# pragma alloc_text(INIT, DriverEntry)
     70# pragma alloc_text(PAGE, vbgdNtAddDevice)
     71# pragma alloc_text(PAGE, vbgdNtUnload)
     72# pragma alloc_text(PAGE, vbgdNtCreate)
     73# pragma alloc_text(PAGE, vbgdNtClose)
     74# pragma alloc_text(PAGE, vbgdNtIOCtl)
     75# pragma alloc_text(PAGE, vbgdNtShutdown)
     76# pragma alloc_text(PAGE, vbgdNtNotSupportedStub)
     77# pragma alloc_text(PAGE, vbgdNtScanPCIResourceList)
     78#endif
     79
     80
     81/*******************************************************************************
     82*   Global Variables                                                           *
     83*******************************************************************************/
     84/** The detected NT (windows) version. */
     85VBGDNTVER g_enmVbgdNtVer = VBGDNTVER_INVALID;
     86
     87
    7988
    8089/**
     
    91100    Log(("VBoxGuest::DriverEntry. Driver built: %s %s\n", __DATE__, __TIME__));
    92101
    93     ULONG majorVersion;
    94     ULONG minorVersion;
    95     ULONG buildNumber;
    96     BOOLEAN bCheckedBuild = PsGetVersion(&majorVersion, &minorVersion, &buildNumber, NULL);
    97     Log(("VBoxGuest::DriverEntry: Running on Windows NT version %d.%d, build %d\n", majorVersion, minorVersion, buildNumber));
    98     if (bCheckedBuild)
     102    /*
     103     * Check if the the NT version is supported and initializing
     104     * g_enmVbgdNtVer in the process.
     105     */
     106    ULONG ulMajorVer;
     107    ULONG ulMinorVer;
     108    ULONG ulBuildNo;
     109    BOOLEAN fCheckedBuild = PsGetVersion(&ulMajorVer, &ulMinorVer, &ulBuildNo, NULL);
     110    Log(("VBoxGuest::DriverEntry: Running on Windows NT version %u.%u, build %u\n", ulMajorVer, ulMinorVer, ulBuildNo));
     111    if (fCheckedBuild)
    99112        Log(("VBoxGuest::DriverEntry: Running on a Windows checked build (debug)!\n"));
    100113#ifdef DEBUG
    101     vboxguestwinDoTests();
    102 #endif
    103     switch (majorVersion)
     114    vbgdNtDoTests();
     115#endif
     116    switch (ulMajorVer)
    104117    {
    105118        case 6: /* Windows Vista or Windows 7 (based on minor ver) */
    106             switch (minorVersion)
     119            switch (ulMinorVer)
    107120            {
    108121                case 0: /* Note: Also could be Windows 2008 Server! */
    109                     g_winVersion = WINVISTA;
     122                    g_enmVbgdNtVer = VBGDNTVER_WINVISTA;
    110123                    break;
    111124                case 1: /* Note: Also could be Windows 2008 Server R2! */
    112                     g_winVersion = WIN7;
     125                    g_enmVbgdNtVer = VBGDNTVER_WIN7;
    113126                    break;
    114127                case 2:
    115                     g_winVersion = WIN8;
     128                    g_enmVbgdNtVer = VBGDNTVER_WIN8;
    116129                    break;
    117130                default:
    118                     Log(("VBoxGuest::DriverEntry: Unknown version of Windows (%u.%u), refusing!\n",
    119                          majorVersion, minorVersion));
     131                    Log(("VBoxGuest::DriverEntry: Unknown version of Windows (%u.%u), refusing!\n", ulMajorVer, ulMinorVer));
    120132                    rc = STATUS_DRIVER_UNABLE_TO_LOAD;
    121133                    break;
     
    123135            break;
    124136        case 5:
    125             switch (minorVersion)
     137            switch (ulMinorVer)
    126138            {
    127139                case 2:
    128                     g_winVersion = WIN2K3;
     140                    g_enmVbgdNtVer = VBGDNTVER_WIN2K3;
    129141                    break;
    130142                case 1:
    131                     g_winVersion = WINXP;
     143                    g_enmVbgdNtVer = VBGDNTVER_WINXP;
    132144                    break;
    133145                case 0:
    134                     g_winVersion = WIN2K;
     146                    g_enmVbgdNtVer = VBGDNTVER_WIN2K;
    135147                    break;
    136148                default:
    137                     Log(("VBoxGuest::DriverEntry: Unknown version of Windows (%u.%u), refusing!\n",
    138                          majorVersion, minorVersion));
     149                    Log(("VBoxGuest::DriverEntry: Unknown version of Windows (%u.%u), refusing!\n", ulMajorVer, ulMinorVer));
    139150                    rc = STATUS_DRIVER_UNABLE_TO_LOAD;
    140151            }
    141152            break;
    142153        case 4:
    143             g_winVersion = WINNT4;
     154            g_enmVbgdNtVer = VBGDNTVER_WINNT4;
    144155            break;
    145156        default:
    146             Log(("VBoxGuest::DriverEntry: At least Windows NT4 required!\n"));
     157            if (ulMajorVer < 4)
     158                Log(("VBoxGuest::DriverEntry: At least Windows NT4 required! (%u.%u)\n", ulMajorVer, ulMinorVer));
     159            else
     160                Log(("VBoxGuest::DriverEntry: Too new version %u.%u!\n", ulMajorVer, ulMinorVer));
    147161            rc = STATUS_DRIVER_UNABLE_TO_LOAD;
     162            break;
    148163    }
    149164
     
    153168         * Setup the driver entry points in pDrvObj.
    154169         */
    155         pDrvObj->DriverUnload                                  = vboxguestwinUnload;
    156         pDrvObj->MajorFunction[IRP_MJ_CREATE]                  = vboxguestwinCreate;
    157         pDrvObj->MajorFunction[IRP_MJ_CLOSE]                   = vboxguestwinClose;
    158         pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]          = vboxguestwinIOCtl;
    159         pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = vboxguestwinInternalIOCtl;
    160         pDrvObj->MajorFunction[IRP_MJ_SHUTDOWN]                = vboxguestwinShutdown;
    161         pDrvObj->MajorFunction[IRP_MJ_READ]                    = vboxguestwinNotSupportedStub;
    162         pDrvObj->MajorFunction[IRP_MJ_WRITE]                   = vboxguestwinNotSupportedStub;
     170        pDrvObj->DriverUnload                                  = vbgdNtUnload;
     171        pDrvObj->MajorFunction[IRP_MJ_CREATE]                  = vbgdNtCreate;
     172        pDrvObj->MajorFunction[IRP_MJ_CLOSE]                   = vbgdNtClose;
     173        pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]          = vbgdNtIOCtl;
     174        pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = vbgdNtInternalIOCtl;
     175        pDrvObj->MajorFunction[IRP_MJ_SHUTDOWN]                = vbgdNtShutdown;
     176        pDrvObj->MajorFunction[IRP_MJ_READ]                    = vbgdNtNotSupportedStub;
     177        pDrvObj->MajorFunction[IRP_MJ_WRITE]                   = vbgdNtNotSupportedStub;
    163178#ifdef TARGET_NT4
    164179        rc = vbgdNt4CreateDevice(pDrvObj, NULL /* pDevObj */, pRegPath);
    165180#else
    166         pDrvObj->MajorFunction[IRP_MJ_PNP]                     = vboxguestwinPnP;
    167         pDrvObj->MajorFunction[IRP_MJ_POWER]                   = vboxguestwinPower;
    168         pDrvObj->MajorFunction[IRP_MJ_SYSTEM_CONTROL]          = vboxguestwinSystemControl;
    169         pDrvObj->DriverExtension->AddDevice                    = (PDRIVER_ADD_DEVICE)vboxguestwinAddDevice;
     181        pDrvObj->MajorFunction[IRP_MJ_PNP]                     = vbgdNtPnP;
     182        pDrvObj->MajorFunction[IRP_MJ_POWER]                   = vbgdNtPower;
     183        pDrvObj->MajorFunction[IRP_MJ_SYSTEM_CONTROL]          = vbgdNtSystemControl;
     184        pDrvObj->DriverExtension->AddDevice                    = (PDRIVER_ADD_DEVICE)vbgdNtAddDevice;
    170185#endif
    171186    }
     
    184199 * @param  pDevObj   Device object
    185200 */
    186 static NTSTATUS vboxguestwinAddDevice(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj)
     201static NTSTATUS vbgdNtAddDevice(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj)
    187202{
    188203    NTSTATUS rc;
    189     Log(("VBoxGuest::vboxguestwinGuestAddDevice\n"));
     204    Log(("VBoxGuest::vbgdNtGuestAddDevice\n"));
    190205
    191206    /*
     
    222237            if (pDevExt->win.s.pNextLowerDriver == NULL)
    223238            {
    224                 Log(("VBoxGuest::vboxguestwinGuestAddDevice: IoAttachDeviceToDeviceStack did not give a nextLowerDriver!\n"));
     239                Log(("VBoxGuest::vbgdNtGuestAddDevice: IoAttachDeviceToDeviceStack did not give a nextLowerDriver!\n"));
    225240                rc = STATUS_DEVICE_NOT_CONNECTED;
    226241            }
    227242        }
    228243        else
    229             Log(("VBoxGuest::vboxguestwinGuestAddDevice: IoCreateSymbolicLink failed with rc=%#x!\n", rc));
     244            Log(("VBoxGuest::vbgdNtGuestAddDevice: IoCreateSymbolicLink failed with rc=%#x!\n", rc));
    230245    }
    231246    else
    232         Log(("VBoxGuest::vboxguestwinGuestAddDevice: IoCreateDevice failed with rc=%#x!\n", rc));
     247        Log(("VBoxGuest::vbgdNtGuestAddDevice: IoCreateDevice failed with rc=%#x!\n", rc));
    233248
    234249    if (NT_SUCCESS(rc))
     
    239254         */
    240255#ifdef VBOX_WITH_GUEST_BUGCHECK_DETECTION
    241         vboxguestwinBugCheckCallback(pDevExt); /* Ignore failure! */
     256        vbgdNtBugCheckCallback(pDevExt); /* Ignore failure! */
    242257#endif
    243258        /* VBoxGuestPower is pageable; ensure we are not called at elevated IRQL */
     
    261276    }
    262277
    263     Log(("VBoxGuest::vboxguestwinGuestAddDevice: returning with rc = 0x%x\n", rc));
     278    Log(("VBoxGuest::vbgdNtGuestAddDevice: returning with rc = 0x%x\n", rc));
    264279    return rc;
    265280}
     
    272287 * @param pResourceList  list of device resources.
    273288 */
    274 static void vboxguestwinShowDeviceResources(PCM_PARTIAL_RESOURCE_LIST pResourceList)
     289static void vbgdNtShowDeviceResources(PCM_PARTIAL_RESOURCE_LIST pResourceList)
    275290{
    276291#ifdef LOG_ENABLED
     
    296311        };
    297312
    298         Log(("VBoxGuest::vboxguestwinShowDeviceResources: Type %s",
     313        Log(("VBoxGuest::vbgdNtShowDeviceResources: Type %s",
    299314               uType < (sizeof(aszName) / sizeof(aszName[0]))
    300315             ? aszName[uType] : "Unknown"));
     
    304319            case CmResourceTypePort:
    305320            case CmResourceTypeMemory:
    306                 Log(("VBoxGuest::vboxguestwinShowDeviceResources: Start %8X%8.8lX length %X\n",
     321                Log(("VBoxGuest::vbgdNtShowDeviceResources: Start %8X%8.8lX length %X\n",
    307322                         resource->u.Port.Start.HighPart, resource->u.Port.Start.LowPart,
    308323                         resource->u.Port.Length));
     
    310325
    311326            case CmResourceTypeInterrupt:
    312                 Log(("VBoxGuest::vboxguestwinShowDeviceResources: Level %X, Vector %X, Affinity %X\n",
     327                Log(("VBoxGuest::vbgdNtShowDeviceResources: Level %X, Vector %X, Affinity %X\n",
    313328                         resource->u.Interrupt.Level, resource->u.Interrupt.Vector,
    314329                         resource->u.Interrupt.Affinity));
     
    316331
    317332            case CmResourceTypeDma:
    318                 Log(("VBoxGuest::vboxguestwinShowDeviceResources: Channel %d, Port %X\n",
     333                Log(("VBoxGuest::vbgdNtShowDeviceResources: Channel %d, Port %X\n",
    319334                         resource->u.Dma.Channel, resource->u.Dma.Port));
    320335                break;
     
    336351 */
    337352#ifndef TARGET_NT4
    338 NTSTATUS vboxguestwinInit(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     353NTSTATUS vbgdNtInit(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    339354#else
    340 NTSTATUS vboxguestwinInit(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj, PUNICODE_STRING pRegPath)
     355NTSTATUS vbgdNtInit(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj, PUNICODE_STRING pRegPath)
    341356#endif
    342357{
     
    346361#endif
    347362
    348     Log(("VBoxGuest::vboxguestwinInit\n"));
     363    Log(("VBoxGuest::vbgdNtInit\n"));
    349364
    350365    int rc = STATUS_SUCCESS;
     
    353368     * Let's have a look at what our PCI adapter offers.
    354369     */
    355     Log(("VBoxGuest::vboxguestwinInit: Starting to scan PCI resources of VBoxGuest ...\n"));
     370    Log(("VBoxGuest::vbgdNtInit: Starting to scan PCI resources of VBoxGuest ...\n"));
    356371
    357372    /* Assign the PCI resources. */
     
    364379                                &pResourceList);
    365380    if (pResourceList && pResourceList->Count > 0)
    366         vboxguestwinShowDeviceResources(&pResourceList->List[0].PartialResourceList);
     381        vbgdNtShowDeviceResources(&pResourceList->List[0].PartialResourceList);
    367382    if (NT_SUCCESS(rc))
    368         rc = vboxguestwinScanPCIResourceList(pResourceList, pDevExt);
     383        rc = vbgdNtScanPCIResourceList(pResourceList, pDevExt);
    369384#else
    370385    if (pStack->Parameters.StartDevice.AllocatedResources->Count > 0)
    371         vboxguestwinShowDeviceResources(&pStack->Parameters.StartDevice.AllocatedResources->List[0].PartialResourceList);
     386        vbgdNtShowDeviceResources(&pStack->Parameters.StartDevice.AllocatedResources->List[0].PartialResourceList);
    372387    if (NT_SUCCESS(rc))
    373         rc = vboxguestwinScanPCIResourceList(pStack->Parameters.StartDevice.AllocatedResourcesTranslated,
     388        rc = vbgdNtScanPCIResourceList(pStack->Parameters.StartDevice.AllocatedResourcesTranslated,
    374389                                             pDevExt);
    375390#endif
     
    382397        void *pvMMIOBase = NULL;
    383398        uint32_t cbMMIO = 0;
    384         rc = vboxguestwinMapVMMDevMemory(pDevExt,
    385                                          pDevExt->win.s.vmmDevPhysMemoryAddress,
    386                                          pDevExt->win.s.vmmDevPhysMemoryLength,
    387                                          &pvMMIOBase,
    388                                          &cbMMIO);
     399        rc = vbgdNtMapVMMDevMemory(pDevExt,
     400                                   pDevExt->win.s.vmmDevPhysMemoryAddress,
     401                                   pDevExt->win.s.vmmDevPhysMemoryLength,
     402                                   &pvMMIOBase,
     403                                   &cbMMIO);
    389404        if (NT_SUCCESS(rc))
    390405        {
    391406            pDevExt->pVMMDevMemory = (VMMDevMemory *)pvMMIOBase;
    392407
    393             Log(("VBoxGuest::vboxguestwinInit: pvMMIOBase = 0x%p, pDevExt = 0x%p, pDevExt->pVMMDevMemory = 0x%p\n",
     408            Log(("VBoxGuest::vbgdNtInit: pvMMIOBase = 0x%p, pDevExt = 0x%p, pDevExt->pVMMDevMemory = 0x%p\n",
    394409                 pvMMIOBase, pDevExt, pDevExt ? pDevExt->pVMMDevMemory : NULL));
    395410
     
    397412                                          pDevExt->IOPortBase,
    398413                                          pvMMIOBase, cbMMIO,
    399                                           vboxguestwinVersionToOSType(g_winVersion),
     414                                          vbgdNtVersionToOSType(g_enmVbgdNtVer),
    400415                                          VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
    401416            if (RT_FAILURE(vrc))
    402417            {
    403                 Log(("VBoxGuest::vboxguestwinInit: Could not init device extension, rc = %Rrc!\n", vrc));
     418                Log(("VBoxGuest::vbgdNtInit: Could not init device extension, rc = %Rrc!\n", vrc));
    404419                rc = STATUS_DEVICE_CONFIGURATION_ERROR;
    405420            }
    406421        }
    407422        else
    408             Log(("VBoxGuest::vboxguestwinInit: Could not map physical address of VMMDev, rc = 0x%x!\n", rc));
     423            Log(("VBoxGuest::vbgdNtInit: Could not map physical address of VMMDev, rc = 0x%x!\n", rc));
    409424    }
    410425
     
    415430        if (RT_FAILURE(vrc))
    416431        {
    417             Log(("VBoxGuest::vboxguestwinInit: Alloc for pPowerStateRequest failed, rc = %Rrc\n", vrc));
     432            Log(("VBoxGuest::vbgdNtInit: Alloc for pPowerStateRequest failed, rc = %Rrc\n", vrc));
    418433            rc = STATUS_UNSUCCESSFUL;
    419434        }
     
    425440         * Register DPC and ISR.
    426441         */
    427         Log(("VBoxGuest::vboxguestwinInit: Initializing DPC/ISR ...\n"));
    428 
    429         IoInitializeDpcRequest(pDevExt->win.s.pDeviceObject, vboxguestwinDpcHandler);
     442        Log(("VBoxGuest::vbgdNtInit: Initializing DPC/ISR ...\n"));
     443
     444        IoInitializeDpcRequest(pDevExt->win.s.pDeviceObject, vbgdNtDpcHandler);
    430445#ifdef TARGET_NT4
    431446        ULONG uInterruptVector;
     
    436451            || pDevExt->win.s.interruptVector)
    437452        {
    438             Log(("VBoxGuest::vboxguestwinInit: Getting interrupt vector (HAL): Bus: %u, IRQL: %u, Vector: %u\n",
     453            Log(("VBoxGuest::vbgdNtInit: Getting interrupt vector (HAL): Bus: %u, IRQL: %u, Vector: %u\n",
    439454                 pDevExt->win.s.busNumber, pDevExt->win.s.interruptLevel, pDevExt->win.s.interruptVector));
    440455
     
    445460                                                     &irqLevel,
    446461                                                     &pDevExt->win.s.interruptAffinity);
    447             Log(("VBoxGuest::vboxguestwinInit: HalGetInterruptVector returns vector %u\n", uInterruptVector));
     462            Log(("VBoxGuest::vbgdNtInit: HalGetInterruptVector returns vector %u\n", uInterruptVector));
    448463            if (uInterruptVector == 0)
    449                 Log(("VBoxGuest::vboxguestwinInit: No interrupt vector found!\n"));
     464                Log(("VBoxGuest::vbgdNtInit: No interrupt vector found!\n"));
    450465        }
    451466        else
    452             Log(("VBoxGuest::vboxguestwinInit: Device does not provide an interrupt!\n"));
     467            Log(("VBoxGuest::vbgdNtInit: Device does not provide an interrupt!\n"));
    453468#endif
    454469        if (pDevExt->win.s.interruptVector)
    455470        {
    456             Log(("VBoxGuest::vboxguestwinInit: Connecting interrupt ...\n"));
    457 
    458             rc = IoConnectInterrupt(&pDevExt->win.s.pInterruptObject,          /* Out: interrupt object. */
    459                                     (PKSERVICE_ROUTINE)vboxguestwinIsrHandler, /* Our ISR handler. */
    460                                     pDevExt,                                   /* Device context. */
    461                                     NULL,                                      /* Optional spinlock. */
     471            Log(("VBoxGuest::vbgdNtInit: Connecting interrupt ...\n"));
     472
     473            rc = IoConnectInterrupt(&pDevExt->win.s.pInterruptObject,         /* Out: interrupt object. */
     474                                    (PKSERVICE_ROUTINE)vbgdNtIsrHandler,      /* Our ISR handler. */
     475                                    pDevExt,                                  /* Device context. */
     476                                    NULL,                                     /* Optional spinlock. */
    462477#ifdef TARGET_NT4
    463                                     uInterruptVector,                          /* Interrupt vector. */
    464                                     irqLevel,                                  /* Interrupt level. */
    465                                     irqLevel,                                  /* Interrupt level. */
     478                                    uInterruptVector,                         /* Interrupt vector. */
     479                                    irqLevel,                                 /* Interrupt level. */
     480                                    irqLevel,                                 /* Interrupt level. */
    466481#else
    467                                     pDevExt->win.s.interruptVector,            /* Interrupt vector. */
    468                                     (KIRQL)pDevExt->win.s.interruptLevel,      /* Interrupt level. */
    469                                     (KIRQL)pDevExt->win.s.interruptLevel,      /* Interrupt level. */
    470 #endif
    471                                     pDevExt->win.s.interruptMode,              /* LevelSensitive or Latched. */
    472                                     TRUE,                                      /* Shareable interrupt. */
    473                                     pDevExt->win.s.interruptAffinity,          /* CPU affinity. */
    474                                     FALSE);                                    /* Don't save FPU stack. */
     482                                    pDevExt->win.s.interruptVector,           /* Interrupt vector. */
     483                                    (KIRQL)pDevExt->win.s.interruptLevel,     /* Interrupt level. */
     484                                    (KIRQL)pDevExt->win.s.interruptLevel,     /* Interrupt level. */
     485#endif
     486                                    pDevExt->win.s.interruptMode,             /* LevelSensitive or Latched. */
     487                                    TRUE,                                     /* Shareable interrupt. */
     488                                    pDevExt->win.s.interruptAffinity,         /* CPU affinity. */
     489                                    FALSE);                                   /* Don't save FPU stack. */
    475490            if (NT_ERROR(rc))
    476                 Log(("VBoxGuest::vboxguestwinInit: Could not connect interrupt, rc = 0x%x\n", rc));
     491                Log(("VBoxGuest::vbgdNtInit: Could not connect interrupt, rc = 0x%x\n", rc));
    477492        }
    478493        else
    479             Log(("VBoxGuest::vboxguestwinInit: No interrupt vector found!\n"));
     494            Log(("VBoxGuest::vbgdNtInit: No interrupt vector found!\n"));
    480495    }
    481496
    482497
    483498#ifdef VBOX_WITH_HGCM
    484     Log(("VBoxGuest::vboxguestwinInit: Allocating kernel session data ...\n"));
     499    Log(("VBoxGuest::vbgdNtInit: Allocating kernel session data ...\n"));
    485500    int vrc = VBoxGuestCreateKernelSession(pDevExt, &pDevExt->win.s.pKernelSession);
    486501    if (RT_FAILURE(vrc))
    487502    {
    488         Log(("VBoxGuest::vboxguestwinInit: Failed to allocated kernel session data! rc = %Rrc\n", rc));
     503        Log(("VBoxGuest::vbgdNtInit: Failed to allocated kernel session data! rc = %Rrc\n", rc));
    489504        rc = STATUS_UNSUCCESSFUL;
    490505    }
     
    494509    {
    495510        ULONG ulValue = 0;
    496         NTSTATUS s = vboxguestwinRegistryReadDWORD(RTL_REGISTRY_SERVICES, L"VBoxGuest", L"LoggingEnabled",
    497                                                    &ulValue);
    498         if (NT_SUCCESS(s))
     511        NTSTATUS rcNt = vbgdNtRegistryReadDWORD(RTL_REGISTRY_SERVICES, L"VBoxGuest", L"LoggingEnabled", &ulValue);
     512        if (NT_SUCCESS(rcNt))
    499513        {
    500514            pDevExt->fLoggingEnabled = ulValue >= 0xFF;
     
    504518
    505519        /* Ready to rumble! */
    506         Log(("VBoxGuest::vboxguestwinInit: Device is ready!\n"));
     520        Log(("VBoxGuest::vbgdNtInit: Device is ready!\n"));
    507521        VBOXGUEST_UPDATE_DEVSTATE(pDevExt, WORKING);
    508522    }
     
    512526    }
    513527
    514     Log(("VBoxGuest::vboxguestwinInit: Returned with rc = 0x%x\n", rc));
     528    Log(("VBoxGuest::vbgdNtInit: Returned with rc = 0x%x\n", rc));
    515529    return rc;
    516530}
     
    523537 * @param   pDrvObj     Driver object.
    524538 */
    525 NTSTATUS vboxguestwinCleanup(PDEVICE_OBJECT pDevObj)
    526 {
    527     Log(("VBoxGuest::vboxguestwinCleanup\n"));
     539NTSTATUS vbgdNtCleanup(PDEVICE_OBJECT pDevObj)
     540{
     541    Log(("VBoxGuest::vbgdNtCleanup\n"));
    528542
    529543    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
     
    554568#endif
    555569        /* According to MSDN we have to unmap previously mapped memory. */
    556         vboxguestwinUnmapVMMDevMemory(pDevExt);
     570        vbgdNtUnmapVMMDevMemory(pDevExt);
    557571    }
    558572    return STATUS_SUCCESS;
     
    565579 * @param   pDrvObj     Driver object.
    566580 */
    567 static void vboxguestwinUnload(PDRIVER_OBJECT pDrvObj)
    568 {
    569     Log(("VBoxGuest::vboxguestwinGuestUnload\n"));
     581static void vbgdNtUnload(PDRIVER_OBJECT pDrvObj)
     582{
     583    Log(("VBoxGuest::vbgdNtGuestUnload\n"));
    570584#ifdef TARGET_NT4
    571     vboxguestwinCleanup(pDrvObj->DeviceObject);
     585    vbgdNtCleanup(pDrvObj->DeviceObject);
    572586
    573587    /* Destroy device extension and clean up everything else. */
     
    590604#endif
    591605
    592     Log(("VBoxGuest::vboxguestwinGuestUnload: returning\n"));
     606    Log(("VBoxGuest::vbgdNtGuestUnload: returning\n"));
    593607}
    594608
     
    600614 * @param   pIrp        Request packet.
    601615 */
    602 static NTSTATUS vboxguestwinCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     616static NTSTATUS vbgdNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    603617{
    604618    /** @todo AssertPtrReturn(pIrp); */
     
    611625    if (pDevExt->win.s.devState != WORKING)
    612626    {
    613         Log(("VBoxGuest::vboxguestwinGuestCreate: device is not working currently: %d!\n",
     627        Log(("VBoxGuest::vbgdNtGuestCreate: device is not working currently: %d!\n",
    614628             pDevExt->win.s.devState));
    615629        rc = STATUS_UNSUCCESSFUL;
     
    621635         * (But this is possible.)
    622636         */
    623         Log(("VBoxGuest::vboxguestwinGuestCreate: Uhm, we're not a directory!\n"));
     637        Log(("VBoxGuest::vbgdNtGuestCreate: Uhm, we're not a directory!\n"));
    624638        rc = STATUS_NOT_A_DIRECTORY;
    625639    }
     
    629643        if (pFileObj)
    630644        {
    631             Log(("VBoxGuest::vboxguestwinGuestCreate: File object type = %d\n",
     645            Log(("VBoxGuest::vbgdNtGuestCreate: File object type = %d\n",
    632646                 pFileObj->Type));
    633647
     
    658672    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    659673
    660     Log(("VBoxGuest::vboxguestwinGuestCreate: Returning 0x%x\n", rc));
     674    Log(("VBoxGuest::vbgdNtGuestCreate: Returning 0x%x\n", rc));
    661675    return rc;
    662676}
     
    669683 * @param   pIrp        Request packet.
    670684 */
    671 static NTSTATUS vboxguestwinClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     685static NTSTATUS vbgdNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    672686{
    673687    PVBOXGUESTDEVEXT   pDevExt  = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
     
    675689    PFILE_OBJECT       pFileObj = pStack->FileObject;
    676690
    677     Log(("VBoxGuest::vboxguestwinGuestClose: pDevExt=0x%p pFileObj=0x%p FsContext=0x%p\n",
     691    Log(("VBoxGuest::vbgdNtGuestClose: pDevExt=0x%p pFileObj=0x%p FsContext=0x%p\n",
    678692         pDevExt, pFileObj, pFileObj->FsContext));
    679693
     
    700714 * @param   pIrp        Request packet.
    701715 */
    702 static NTSTATUS vboxguestwinIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     716static NTSTATUS vbgdNtIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    703717{
    704718    NTSTATUS            Status   = STATUS_SUCCESS;
     
    717731        pSession = (PVBOXGUESTSESSION)pFileObj->FsContext;
    718732
    719     Log(("VBoxGuest::vboxguestwinIOCtl: uCmd=%u, pDevExt=0x%p, pSession=0x%p\n",
     733    Log(("VBoxGuest::vbgdNtIOCtl: uCmd=%u, pDevExt=0x%p, pSession=0x%p\n",
    720734         uCmd, pDevExt, pSession));
    721735
     
    726740    if (pSession == NULL)
    727741    {
    728         Log(("VBoxGuest::vboxguestwinIOCtl: Using kernel session data ...\n"));
     742        Log(("VBoxGuest::vbgdNtIOCtl: Using kernel session data ...\n"));
    729743        pSession = pDevExt->win.s.pKernelSession;
    730744    }
     
    740754        case VBOXGUEST_IOCTL_ENABLE_VRDP_SESSION:
    741755        {
    742             LogRel(("VBoxGuest::vboxguestwinIOCtl: ENABLE_VRDP_SESSION: Currently: %sabled\n",
     756            LogRel(("VBoxGuest::vbgdNtIOCtl: ENABLE_VRDP_SESSION: Currently: %sabled\n",
    743757                    pDevExt->fVRDPEnabled? "en": "dis"));
    744758            if (!pDevExt->fVRDPEnabled)
     
    747761
    748762                pDevExt->fVRDPEnabled            = true;
    749                 LogRel(("VBoxGuest::vboxguestwinIOCtl: ENABLE_VRDP_SESSION: Current active console ID: 0x%08X\n",
     763                LogRel(("VBoxGuest::vbgdNtIOCtl: ENABLE_VRDP_SESSION: Current active console ID: 0x%08X\n",
    750764                        pSharedUserData->ActiveConsoleId));
    751765                pDevExt->ulOldActiveConsoleId    = pSharedUserData->ActiveConsoleId;
     
    757771        case VBOXGUEST_IOCTL_DISABLE_VRDP_SESSION:
    758772        {
    759             LogRel(("VBoxGuest::vboxguestwinIOCtl: DISABLE_VRDP_SESSION: Currently: %sabled\n",
     773            LogRel(("VBoxGuest::vbgdNtIOCtl: DISABLE_VRDP_SESSION: Currently: %sabled\n",
    760774                    pDevExt->fVRDPEnabled? "en": "dis"));
    761775            if (pDevExt->fVRDPEnabled)
     
    764778
    765779                pDevExt->fVRDPEnabled            = false;
    766                 Log(("VBoxGuest::vboxguestwinIOCtl: DISABLE_VRDP_SESSION: Current active console ID: 0x%08X\n",
     780                Log(("VBoxGuest::vbgdNtIOCtl: DISABLE_VRDP_SESSION: Current active console ID: 0x%08X\n",
    767781                     pSharedUserData->ActiveConsoleId));
    768782                pSharedUserData->ActiveConsoleId = pDevExt->ulOldActiveConsoleId;
     
    783797            int vrc = VBoxGuestCommonIOCtl(uCmd, pDevExt, pSession, pBuf, cbData, &cbDataReturned);
    784798
    785             Log(("VBoxGuest::vboxguestwinGuestDeviceControl: rc=%Rrc, pBuf=0x%p, cbData=%u, cbDataReturned=%u\n",
     799            Log(("VBoxGuest::vbgdNtGuestDeviceControl: rc=%Rrc, pBuf=0x%p, cbData=%u, cbDataReturned=%u\n",
    786800                 vrc, pBuf, cbData, cbDataReturned));
    787801
     
    790804                if (RT_UNLIKELY(cbDataReturned > cbData))
    791805                {
    792                     Log(("VBoxGuest::vboxguestwinGuestDeviceControl: Too much output data %u - expected %u!\n", cbDataReturned, cbData));
     806                    Log(("VBoxGuest::vbgdNtGuestDeviceControl: Too much output data %u - expected %u!\n", cbDataReturned, cbData));
    793807                    cbDataReturned = cbData;
    794808                    Status = STATUS_BUFFER_TOO_SMALL;
     
    818832    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    819833
    820     //Log(("VBoxGuest::vboxguestwinGuestDeviceControl: returned cbOut=%d rc=%#x\n", cbOut, Status));
     834    //Log(("VBoxGuest::vbgdNtGuestDeviceControl: returned cbOut=%d rc=%#x\n", cbOut, Status));
    821835    return Status;
    822836}
     
    835849 *       has a way to do this already, see VBOXGUEST_IOCTL_GETVMMDEVPORT.
    836850 */
    837 static NTSTATUS vboxguestwinInternalIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     851static NTSTATUS vbgdNtInternalIOCtl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    838852{
    839853    NTSTATUS            Status      = STATUS_SUCCESS;
     
    884898    }
    885899
    886     return vboxguestwinIOCtl(pDevObj, pIrp);
     900    return vbgdNtIOCtl(pDevObj, pIrp);
    887901}
    888902
     
    895909 * @param   pIrp        IRP.
    896910 */
    897 NTSTATUS vboxguestwinSystemControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     911NTSTATUS vbgdNtSystemControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    898912{
    899913    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
    900914
    901     Log(("VBoxGuest::vboxguestwinGuestSystemControl\n"));
     915    Log(("VBoxGuest::vbgdNtGuestSystemControl\n"));
    902916
    903917    /* Always pass it on to the next driver. */
     
    915929 * @param pIrp       IRP.
    916930 */
    917 NTSTATUS vboxguestwinShutdown(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     931NTSTATUS vbgdNtShutdown(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    918932{
    919933    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
    920934
    921     Log(("VBoxGuest::vboxguestwinGuestShutdown\n"));
     935    Log(("VBoxGuest::vbgdNtGuestShutdown\n"));
    922936
    923937    VMMDevPowerStateRequest *pReq = pDevExt->win.s.pPowerStateRequest;
     
    930944        if (RT_FAILURE(rc))
    931945        {
    932             Log(("VBoxGuest::vboxguestwinGuestShutdown: Error performing request to VMMDev! "
     946            Log(("VBoxGuest::vbgdNtGuestShutdown: Error performing request to VMMDev! "
    933947                     "rc = %Rrc\n", rc));
    934948        }
     
    945959 * @param   pIrp        IRP.
    946960 */
    947 NTSTATUS vboxguestwinNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    948 {
    949     Log(("VBoxGuest::vboxguestwinGuestNotSupportedStub\n"));
     961NTSTATUS vbgdNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
     962{
     963    Log(("VBoxGuest::vbgdNtGuestNotSupportedStub\n"));
    950964
    951965    pIrp->IoStatus.Information = 0;
     
    965979 * @param   pContext    Context specific pointer.
    966980 */
    967 void vboxguestwinDpcHandler(PKDPC pDPC, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVOID pContext)
     981void vbgdNtDpcHandler(PKDPC pDPC, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVOID pContext)
    968982{
    969983    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pDevObj->DeviceExtension;
    970     Log(("VBoxGuest::vboxguestwinGuestDpcHandler: pDevExt=0x%p\n", pDevExt));
     984    Log(("VBoxGuest::vbgdNtGuestDpcHandler: pDevExt=0x%p\n", pDevExt));
    971985
    972986    /* test & reset the counter */
     
    985999
    9861000    /* Process the wake-up list we were asked by the scheduling a DPC
    987      * in vboxguestwinIsrHandler(). */
     1001     * in vbgdNtIsrHandler(). */
    9881002    VBoxGuestWaitDoWakeUps(pDevExt);
    9891003}
     
    9971011 * @param   pServiceContext Context specific pointer.
    9981012 */
    999 BOOLEAN vboxguestwinIsrHandler(PKINTERRUPT pInterrupt, PVOID pServiceContext)
     1013BOOLEAN vbgdNtIsrHandler(PKINTERRUPT pInterrupt, PVOID pServiceContext)
    10001014{
    10011015    PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pServiceContext;
     
    10031017        return FALSE;
    10041018
    1005     /*Log(("VBoxGuest::vboxguestwinGuestIsrHandler: pDevExt = 0x%p, pVMMDevMemory = 0x%p\n",
     1019    /*Log(("VBoxGuest::vbgdNtGuestIsrHandler: pDevExt = 0x%p, pVMMDevMemory = 0x%p\n",
    10061020             pDevExt, pDevExt ? pDevExt->pVMMDevMemory : NULL));*/
    10071021
     
    10131027    if (fIRQTaken)
    10141028    {
    1015         Log(("VBoxGuest::vboxguestwinGuestIsrHandler: IRQ was taken! pInterrupt = 0x%p, pDevExt = 0x%p\n",
     1029        Log(("VBoxGuest::vbgdNtGuestIsrHandler: IRQ was taken! pInterrupt = 0x%p, pDevExt = 0x%p\n",
    10161030             pInterrupt, pDevExt));
    10171031        if (ASMAtomicUoReadU32(&pDevExt->u32MousePosChangedSeq) || !RTListIsEmpty(&pDevExt->WakeUpList))
    10181032        {
    1019             Log(("VBoxGuest::vboxguestwinGuestIsrHandler: Requesting DPC ...\n"));
     1033            Log(("VBoxGuest::vbgdNtGuestIsrHandler: Requesting DPC ...\n"));
    10201034            IoRequestDpc(pDevExt->win.s.pDeviceObject, pDevExt->win.s.pCurrentIrp, NULL);
    10211035        }
     
    10501064 *                      registry value if found.
    10511065 */
    1052 NTSTATUS vboxguestwinRegistryReadDWORD(ULONG ulRoot, PCWSTR pwszPath, PWSTR pwszName,
    1053                                        PULONG puValue)
     1066NTSTATUS vbgdNtRegistryReadDWORD(ULONG ulRoot, PCWSTR pwszPath, PWSTR pwszName, PULONG puValue)
    10541067{
    10551068    if (!pwszPath || !pwszName || !puValue)
     
    10821095 * @param pDevExt   Device extension
    10831096 */
    1084 NTSTATUS vboxguestwinScanPCIResourceList(PCM_RESOURCE_LIST pResList, PVBOXGUESTDEVEXT pDevExt)
     1097NTSTATUS vbgdNtScanPCIResourceList(PCM_RESOURCE_LIST pResList, PVBOXGUESTDEVEXT pDevExt)
    10851098{
    10861099    /* Enumerate the resource list. */
    1087     Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Found %d resources\n",
     1100    Log(("VBoxGuest::vbgdNtScanPCIResourceList: Found %d resources\n",
    10881101         pResList->List->PartialResourceList.Count));
    10891102
     
    11031116                if (rangeCount < PCI_TYPE0_ADDRESSES)
    11041117                {
    1105                     Log(("VBoxGuest::vboxguestwinScanPCIResourceList: I/O range: Base = %08x:%08x, Length = %08x\n",
     1118                    Log(("VBoxGuest::vbgdNtScanPCIResourceList: I/O range: Base = %08x:%08x, Length = %08x\n",
    11061119                            pPartialData->u.Port.Start.HighPart,
    11071120                            pPartialData->u.Port.Start.LowPart,
     
    11181131                    pBaseAddress->ResourceMapped = FALSE;
    11191132
    1120                     Log(("VBoxGuest::vboxguestwinScanPCIResourceList: I/O range for VMMDev found! Base = %08x:%08x, Length = %08x\n",
     1133                    Log(("VBoxGuest::vbgdNtScanPCIResourceList: I/O range for VMMDev found! Base = %08x:%08x, Length = %08x\n",
    11211134                            pPartialData->u.Port.Start.HighPart,
    11221135                            pPartialData->u.Port.Start.LowPart,
     
    11311144            case CmResourceTypeInterrupt:
    11321145            {
    1133                 Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Interrupt: Level = %x, Vector = %x, Mode = %x\n",
     1146                Log(("VBoxGuest::vbgdNtScanPCIResourceList: Interrupt: Level = %x, Vector = %x, Mode = %x\n",
    11341147                     pPartialData->u.Interrupt.Level,
    11351148                     pPartialData->u.Interrupt.Vector,
     
    11581171                if (rangeCount < PCI_TYPE0_ADDRESSES)
    11591172                {
    1160                     Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Memory range: Base = %08x:%08x, Length = %08x\n",
     1173                    Log(("VBoxGuest::vbgdNtScanPCIResourceList: Memory range: Base = %08x:%08x, Length = %08x\n",
    11611174                         pPartialData->u.Memory.Start.HighPart,
    11621175                         pPartialData->u.Memory.Start.LowPart,
     
    11781191                        pBaseAddress->ResourceMapped = FALSE;
    11791192
    1180                         Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Memory range for VMMDev found! Base = %08x:%08x, Length = %08x\n",
     1193                        Log(("VBoxGuest::vbgdNtScanPCIResourceList: Memory range for VMMDev found! Base = %08x:%08x, Length = %08x\n",
    11811194                             pPartialData->u.Memory.Start.HighPart,
    11821195                             pPartialData->u.Memory.Start.LowPart,
     
    11881201                    else
    11891202                    {
    1190                         Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Ignoring memory: Flags = %08x\n",
     1203                        Log(("VBoxGuest::vbgdNtScanPCIResourceList: Ignoring memory: Flags = %08x\n",
    11911204                             pPartialData->Flags));
    11921205                    }
     
    11971210            default:
    11981211            {
    1199                 Log(("VBoxGuest::vboxguestwinScanPCIResourceList: Unhandled resource found, type = %d\n", pPartialData->Type));
     1212                Log(("VBoxGuest::vbgdNtScanPCIResourceList: Unhandled resource found, type = %d\n", pPartialData->Type));
    12001213                break;
    12011214            }
     
    12201233 * @param pcbMMIO           Length of mapped I/O base.
    12211234 */
    1222 NTSTATUS vboxguestwinMapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt, PHYSICAL_ADDRESS physicalAdr, ULONG ulLength,
    1223                                      void **ppvMMIOBase, uint32_t *pcbMMIO)
     1235NTSTATUS vbgdNtMapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt, PHYSICAL_ADDRESS physicalAdr, ULONG ulLength,
     1236                               void **ppvMMIOBase, uint32_t *pcbMMIO)
    12241237{
    12251238    AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
     
    12311244    {
    12321245         VMMDevMemory *pVMMDevMemory = (VMMDevMemory *)MmMapIoSpace(physicalAdr, ulLength, MmNonCached);
    1233          Log(("VBoxGuest::vboxguestwinMapVMMDevMemory: pVMMDevMemory = 0x%x\n", pVMMDevMemory));
     1246         Log(("VBoxGuest::vbgdNtMapVMMDevMemory: pVMMDevMemory = 0x%x\n", pVMMDevMemory));
    12341247         if (pVMMDevMemory)
    12351248         {
    1236              Log(("VBoxGuest::vboxguestwinMapVMMDevMemory: VMMDevMemory: Version = 0x%x, Size = %d\n",
     1249             Log(("VBoxGuest::vbgdNtMapVMMDevMemory: VMMDevMemory: Version = 0x%x, Size = %d\n",
    12371250                  pVMMDevMemory->u32Version, pVMMDevMemory->u32Size));
    12381251
     
    12401253             if (pVMMDevMemory->u32Version != VMMDEV_MEMORY_VERSION)
    12411254             {
    1242                  Log(("VBoxGuest::vboxguestwinMapVMMDevMemory: Wrong version (%u), refusing operation!\n",
     1255                 Log(("VBoxGuest::vbgdNtMapVMMDevMemory: Wrong version (%u), refusing operation!\n",
    12431256                      pVMMDevMemory->u32Version));
    12441257
    12451258                 /* Not our version, refuse operation and unmap the memory. */
    1246                  vboxguestwinUnmapVMMDevMemory(pDevExt);
     1259                 vbgdNtUnmapVMMDevMemory(pDevExt);
    12471260                 rc = STATUS_UNSUCCESSFUL;
    12481261             }
     
    12541267                     *pcbMMIO = pVMMDevMemory->u32Size;
    12551268
    1256                  Log(("VBoxGuest::vboxguestwinMapVMMDevMemory: VMMDevMemory found and mapped! pvMMIOBase = 0x%p\n",
     1269                 Log(("VBoxGuest::vbgdNtMapVMMDevMemory: VMMDevMemory found and mapped! pvMMIOBase = 0x%p\n",
    12571270                      *ppvMMIOBase));
    12581271             }
     
    12701283 * @param   pDevExt     The device extension.
    12711284 */
    1272 void vboxguestwinUnmapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt)
    1273 {
    1274     Log(("VBoxGuest::vboxguestwinUnmapVMMDevMemory: pVMMDevMemory = 0x%x\n", pDevExt->pVMMDevMemory));
     1285void vbgdNtUnmapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt)
     1286{
     1287    Log(("VBoxGuest::vbgdNtUnmapVMMDevMemory: pVMMDevMemory = 0x%x\n", pDevExt->pVMMDevMemory));
    12751288    if (pDevExt->pVMMDevMemory)
    12761289    {
     
    12841297
    12851298
    1286 VBOXOSTYPE vboxguestwinVersionToOSType(winVersion_t winVer)
     1299VBOXOSTYPE vbgdNtVersionToOSType(VBGDNTVER enmNtVer)
    12871300{
    12881301    VBOXOSTYPE enmOsType;
    1289     switch (winVer)
    1290     {
    1291         case WINNT4:
     1302    switch (enmNtVer)
     1303    {
     1304        case VBGDNTVER_WINNT4:
    12921305            enmOsType = VBOXOSTYPE_WinNT4;
    12931306            break;
    12941307
    1295         case WIN2K:
     1308        case VBGDNTVER_WIN2K:
    12961309            enmOsType = VBOXOSTYPE_Win2k;
    12971310            break;
    12981311
    1299         case WINXP:
     1312        case VBGDNTVER_WINXP:
    13001313#if ARCH_BITS == 64
    13011314            enmOsType = VBOXOSTYPE_WinXP_x64;
     
    13051318            break;
    13061319
    1307         case WIN2K3:
     1320        case VBGDNTVER_WIN2K3:
    13081321#if ARCH_BITS == 64
    13091322            enmOsType = VBOXOSTYPE_Win2k3_x64;
     
    13131326            break;
    13141327
    1315         case WINVISTA:
     1328        case VBGDNTVER_WINVISTA:
    13161329#if ARCH_BITS == 64
    13171330            enmOsType = VBOXOSTYPE_WinVista_x64;
     
    13211334            break;
    13221335
    1323         case WIN7:
     1336        case VBGDNTVER_WIN7:
    13241337#if ARCH_BITS == 64
    13251338            enmOsType = VBOXOSTYPE_Win7_x64;
     
    13291342            break;
    13301343
    1331         case WIN8:
     1344        case VBGDNTVER_WIN8:
    13321345#if ARCH_BITS == 64
    13331346            enmOsType = VBOXOSTYPE_Win8_x64;
     
    13721385
    13731386
    1374 static void vboxguestwinTestAtomicTestAndClearBitsU32(uint32_t u32Mask, uint32_t u32Bits,
    1375                                                       uint32_t u32Exp)
     1387static void vbgdNtTestAtomicTestAndClearBitsU32(uint32_t u32Mask, uint32_t u32Bits, uint32_t u32Exp)
    13761388{
    13771389    ULONG u32Bits2 = u32Bits;
     
    13881400
    13891401
    1390 static void vboxguestwinDoTests()
    1391 {
    1392     vboxguestwinTestAtomicTestAndClearBitsU32(0x00, 0x23, 0);
    1393     vboxguestwinTestAtomicTestAndClearBitsU32(0x11, 0, 0);
    1394     vboxguestwinTestAtomicTestAndClearBitsU32(0x11, 0x22, 0);
    1395     vboxguestwinTestAtomicTestAndClearBitsU32(0x11, 0x23, 0x1);
    1396     vboxguestwinTestAtomicTestAndClearBitsU32(0x11, 0x32, 0x10);
    1397     vboxguestwinTestAtomicTestAndClearBitsU32(0x22, 0x23, 0x22);
     1402static void vbgdNtDoTests(void)
     1403{
     1404    vbgdNtTestAtomicTestAndClearBitsU32(0x00, 0x23, 0);
     1405    vbgdNtTestAtomicTestAndClearBitsU32(0x11, 0, 0);
     1406    vbgdNtTestAtomicTestAndClearBitsU32(0x11, 0x22, 0);
     1407    vbgdNtTestAtomicTestAndClearBitsU32(0x11, 0x23, 0x1);
     1408    vbgdNtTestAtomicTestAndClearBitsU32(0x11, 0x32, 0x10);
     1409    vbgdNtTestAtomicTestAndClearBitsU32(0x22, 0x23, 0x22);
    13981410}
    13991411
  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-win.h

    r44979 r44983  
     1/* $Id$ */
    12/** @file
    2  *
    33 * VBoxGuest - Windows specifics.
    4  *
    5  * Copyright (C) 2010-2012 Oracle Corporation
     4 */
     5
     6/*
     7 * Copyright (C) 2010-2013 Oracle Corporation
    68 *
    79 * This file is part of VirtualBox Open Source Edition (OSE), as
     
    1719#define ___VBoxGuest_win_h
    1820
    19 /*******************************************************************************
    20 *   Header Files                                                               *
    21 *******************************************************************************/
    2221
    2322#include <iprt/cdefs.h>
     
    4039
    4140
    42 /*******************************************************************************
    43 *   Structures and Typedefs                                                    *
    44 *******************************************************************************/
    45 
    46 /** Pointer to the VBoxGuest per session data. */
    47 typedef struct VBOXGUESTSESSION *PVBOXGUESTSESSION;
    4841
    4942/** Possible device states for our state machine. */
     
    120113
    121114    /** Pre-allocated kernel session data. This is needed
    122       * for handling kernel IOCtls. */
    123     PVBOXGUESTSESSION pKernelSession;
     115     * for handling kernel IOCtls. */
     116    struct VBOXGUESTSESSION *pKernelSession;
    124117
    125118    /** Spinlock protecting MouseNotifyCallback. Required since the consumer is
     
    128121} VBOXGUESTDEVEXTWIN, *PVBOXGUESTDEVEXTWIN;
    129122
    130 #define VBOXGUEST_UPDATE_DEVSTATE(_pDevExt, _newDevState) do {    \
    131     (_pDevExt)->win.s.prevDevState =  (_pDevExt)->win.s.devState; \
    132     (_pDevExt)->win.s.devState = (_newDevState);                  \
    133 } while (0)
     123
     124/** NT (windows) version identifier. */
     125typedef enum VBGDNTVER
     126{
     127    VBGDNTVER_INVALID = 0,
     128    VBGDNTVER_WINNT4,
     129    VBGDNTVER_WIN2K,
     130    VBGDNTVER_WINXP,
     131    VBGDNTVER_WIN2K3,
     132    VBGDNTVER_WINVISTA,
     133    VBGDNTVER_WIN7,
     134    VBGDNTVER_WIN8
     135} VBGDNTVER;
     136extern VBGDNTVER g_enmVbgdNtVer;
    134137
    135138
    136 /*******************************************************************************
    137 *   Defined Constants And Macros                                               *
    138 *******************************************************************************/
     139#define VBOXGUEST_UPDATE_DEVSTATE(a_pDevExt, a_newDevState) \
     140    do { \
     141        (a_pDevExt)->win.s.prevDevState = (a_pDevExt)->win.s.devState; \
     142        (a_pDevExt)->win.s.devState     = (a_newDevState); \
     143    } while (0)
    139144
    140145/** CM_RESOURCE_MEMORY_* flags which were used on XP or earlier. */
    141146#define VBOX_CM_PRE_VISTA_MASK (0x3f)
    142147
    143 /** Windows version identifier. */
    144 typedef enum
    145 {
    146     WINNT4   = 1,
    147     WIN2K    = 2,
    148     WINXP    = 3,
    149     WIN2K3   = 4,
    150     WINVISTA = 5,
    151     WIN7     = 6,
    152     WIN8     = 7
    153 } winVersion_t;
    154 extern winVersion_t winVersion;
     148
     149/* Include the internal header now as we've declared the internal
     150   structure and stuff. */
     151#include "VBoxGuestInternal.h"
    155152
    156153
    157 /*******************************************************************************
    158 *   Declared prototypes for helper routines used in both (PnP and legacy)      *
    159 *   driver versions.                                                           *
    160 *******************************************************************************/
    161 #include "VBoxGuestInternal.h"
     154RT_C_DECLS_BEGIN
    162155
    163 RT_C_DECLS_BEGIN
    164156#ifdef TARGET_NT4
    165157NTSTATUS   vbgdNt4CreateDevice(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj, PUNICODE_STRING pRegPath);
    166 NTSTATUS   vboxguestwinInit(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj, PUNICODE_STRING pRegPath);
    167158#else
    168 NTSTATUS   vboxguestwinInit(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     159NTSTATUS   vbgdNtInit(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     160NTSTATUS   vbgdNtPnP(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     161NTSTATUS   vbgdNtPower(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    169162#endif
    170 NTSTATUS   vboxguestwinCleanup(PDEVICE_OBJECT pDevObj);
    171 NTSTATUS   vboxguestwinPnP(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    172 VOID       vboxguestwinDpcHandler(PKDPC pDPC, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVOID pContext);
    173 BOOLEAN    vboxguestwinIsrHandler(PKINTERRUPT interrupt, PVOID serviceContext);
    174 NTSTATUS   vboxguestwinScanPCIResourceList(PCM_RESOURCE_LIST pResList, PVBOXGUESTDEVEXT pDevExt);
    175 NTSTATUS   vboxguestwinMapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt, PHYSICAL_ADDRESS physicalAdr, ULONG ulLength,
    176                                        void **ppvMMIOBase, uint32_t *pcbMMIO);
    177 void       vboxguestwinUnmapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt);
    178 VBOXOSTYPE vboxguestwinVersionToOSType(winVersion_t winVer);
    179 NTSTATUS   vboxguestwinPower(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     163
     164/** @name Common routines used in both (PnP and legacy) driver versions.
     165 * @{
     166 */
     167#ifdef TARGET_NT4
     168NTSTATUS   vbgdNtInit(PDRIVER_OBJECT pDrvObj, PDEVICE_OBJECT pDevObj, PUNICODE_STRING pRegPath);
     169#else
     170NTSTATUS   vbgdNtInit(PDEVICE_OBJECT pDevObj, PIRP pIrp);
     171#endif
     172NTSTATUS   vbgdNtCleanup(PDEVICE_OBJECT pDevObj);
     173VOID       vbgdNtDpcHandler(PKDPC pDPC, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVOID pContext);
     174BOOLEAN    vbgdNtIsrHandler(PKINTERRUPT interrupt, PVOID serviceContext);
     175NTSTATUS   vbgdNtScanPCIResourceList(PCM_RESOURCE_LIST pResList, PVBOXGUESTDEVEXT pDevExt);
     176NTSTATUS   vbgdNtMapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt, PHYSICAL_ADDRESS physicalAdr, ULONG ulLength,
     177                                 void **ppvMMIOBase, uint32_t *pcbMMIO);
     178void       vbgdNtUnmapVMMDevMemory(PVBOXGUESTDEVEXT pDevExt);
     179VBOXOSTYPE vbgdNtVersionToOSType(VBGDNTVER enmNtVer);
     180/** @}  */
     181
    180182RT_C_DECLS_END
    181183
     
    185187 * on NT4, so... The same for ExAllocatePool.
    186188 */
    187 #undef ExAllocatePool
    188 #undef ExFreePool
     189# undef ExAllocatePool
     190# undef ExFreePool
    189191#endif
    190192
    191 #endif /* ___VBoxGuest_win_h */
     193#endif /* !___VBoxGuest_win_h */
    192194
     195
  • trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuestInternal.h

    r41722 r44983  
    182182    VBoxGuestMouseSetNotifyCallback MouseNotifyCallback;
    183183
    184     /** Windows part. */
     184    /** Windows part.
     185     * @todo r=bird: Entirely wrong approach. You should create
     186     *       VBOXGUESTDEVEXTWIN as a super structure to VBOXGUESTDEVEXT. If they
     187     *       were classes, class VBOXGUESTDEVEXTWIN : public VBOXGUESTDEVEXT ... */
    185188    union
    186189    {
Note: See TracChangeset for help on using the changeset viewer.

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