po.h File Reference

#include <guiddef.h>
#include <poclass.h>

Include dependency graph for po.h:

Go to the source code of this file.

Classes
struct	_PO_HIBER_PERF
struct	_PO_MEMORY_IMAGE
struct	_PO_MEMORY_RANGE_ARRAY_RANGE
struct	_PO_MEMORY_RANGE_ARRAY_LINK
struct	_PO_MEMORY_RANGE_ARRAY
struct	_POP_HIBER_CONTEXT
struct	_PO_NOTIFY_ORDER_LEVEL
struct	_POP_SHUTDOWN_BUG_CHECK
struct	_POP_DEVICE_POWER_IRP
struct	_PO_DEVICE_NOTIFY_ORDER
struct	_POP_DEVICE_SYS_STATE
struct	_POP_POWER_ACTION
struct	_POWER_CHANNEL_SUMMARY
struct	_DEVICE_OBJECT_POWER_EXTENSION
struct	_POP_SHUTDOWN_WAIT_ENTRY

Macros
#define	_PO_DEBUG_   0x00
#define	PO_STATE_DEBUG   0x01
#define	POTRACE(x, fmt, ...)   DPRINT(fmt, ##__VA_ARGS__)

Typedefs
typedef struct _PO_HIBER_PERF	PO_HIBER_PERF
typedef struct _PO_HIBER_PERF *	PPO_HIBER_PERF
typedef struct _PO_MEMORY_IMAGE	PO_MEMORY_IMAGE
typedef struct _PO_MEMORY_IMAGE *	PPO_MEMORY_IMAGE
typedef struct _PO_MEMORY_RANGE_ARRAY_RANGE	PO_MEMORY_RANGE_ARRAY_RANGE
typedef struct _PO_MEMORY_RANGE_ARRAY_LINK	PO_MEMORY_RANGE_ARRAY_LINK
typedef struct _PO_MEMORY_RANGE_ARRAY	PO_MEMORY_RANGE_ARRAY
typedef struct _PO_MEMORY_RANGE_ARRAY *	PPO_MEMORY_RANGE_ARRAY
typedef struct _POP_HIBER_CONTEXT	POP_HIBER_CONTEXT
typedef struct _POP_HIBER_CONTEXT *	PPOP_HIBER_CONTEXT
typedef struct _PO_NOTIFY_ORDER_LEVEL	PO_NOTIFY_ORDER_LEVEL
typedef struct _PO_NOTIFY_ORDER_LEVEL *	PPO_NOTIFY_ORDER_LEVEL
typedef struct _POP_SHUTDOWN_BUG_CHECK	POP_SHUTDOWN_BUG_CHECK
typedef struct _POP_SHUTDOWN_BUG_CHECK *	PPOP_SHUTDOWN_BUG_CHECK
typedef struct _POP_DEVICE_POWER_IRP	POP_DEVICE_POWER_IRP
typedef struct _POP_DEVICE_POWER_IRP *	PPOP_DEVICE_POWER_IRP
typedef struct _PO_DEVICE_NOTIFY_ORDER	PO_DEVICE_NOTIFY_ORDER
typedef struct _PO_DEVICE_NOTIFY_ORDER *	PPO_DEVICE_NOTIFY_ORDER
typedef struct _POP_DEVICE_SYS_STATE	POP_DEVICE_SYS_STATE
typedef struct _POP_DEVICE_SYS_STATE *	PPOP_DEVICE_SYS_STATE
typedef struct _POP_POWER_ACTION	POP_POWER_ACTION
typedef struct _POP_POWER_ACTION *	PPOP_POWER_ACTION
typedef enum _POP_DEVICE_IDLE_TYPE	POP_DEVICE_IDLE_TYPE
typedef enum _POP_DEVICE_IDLE_TYPE *	PPOP_DEVICE_IDLE_TYPE
typedef struct _POWER_CHANNEL_SUMMARY	POWER_CHANNEL_SUMMARY
typedef struct _POWER_CHANNEL_SUMMARY *	PPOWER_CHANNEL_SUMMARY
typedef struct _DEVICE_OBJECT_POWER_EXTENSION	DEVICE_OBJECT_POWER_EXTENSION
typedef struct _DEVICE_OBJECT_POWER_EXTENSION *	PDEVICE_OBJECT_POWER_EXTENSION
typedef struct _POP_SHUTDOWN_WAIT_ENTRY	POP_SHUTDOWN_WAIT_ENTRY
typedef struct _POP_SHUTDOWN_WAIT_ENTRY *	PPOP_SHUTDOWN_WAIT_ENTRY

Enumerations
enum	_POP_DEVICE_IDLE_TYPE { DeviceIdleNormal, DeviceIdleDisk }

Functions
BOOLEAN NTAPI	PoInitSystem (IN ULONG BootPhase)
VOID NTAPI	PoInitializePrcb (IN PKPRCB Prcb)
VOID NTAPI	PopInitShutdownList (VOID)
VOID NTAPI	PoInitializeDeviceObject (IN OUT PDEVOBJ_EXTENSION DeviceObjectExtension)
VOID NTAPI	PoVolumeDevice (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	PoRemoveVolumeDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	PopSetSystemPowerState (SYSTEM_POWER_STATE PowerState, POWER_ACTION PowerAction)
VOID NTAPI	PopCleanupPowerState (IN PPOWER_STATE PowerState)
NTSTATUS NTAPI	PopAddRemoveSysCapsCallback (IN PVOID NotificationStructure, IN PVOID Context)
VOID NTAPI	PoNotifySystemTimeSet (VOID)
VOID NTAPI	PopReadShutdownPolicy (VOID)
VOID NTAPI	PopGracefulShutdown (IN PVOID Context)
VOID NTAPI	PopFlushVolumes (IN BOOLEAN ShuttingDown)

Variables
PDEVICE_NODE	PopSystemPowerDeviceNode
KGUARDED_MUTEX	PopVolumeLock
LIST_ENTRY	PopVolumeDevices
KSPIN_LOCK	PopDopeGlobalLock
POP_POWER_ACTION	PopAction
SYSTEM_POWER_CAPABILITIES	PopCapabilities

Macro Definition Documentation

_PO_DEBUG_

#define _PO_DEBUG_   0x00

Definition at line 15 of file po.h.

PO_STATE_DEBUG

#define PO_STATE_DEBUG   0x01

Definition at line 20 of file po.h.

POTRACE

#define POTRACE	(		x,
			fmt,
			...
	)		DPRINT(fmt, ##__VA_ARGS__)

Definition at line 33 of file po.h.

Typedef Documentation

DEVICE_OBJECT_POWER_EXTENSION

typedef struct _DEVICE_OBJECT_POWER_EXTENSION DEVICE_OBJECT_POWER_EXTENSION

PDEVICE_OBJECT_POWER_EXTENSION

typedef struct _DEVICE_OBJECT_POWER_EXTENSION * PDEVICE_OBJECT_POWER_EXTENSION

PO_DEVICE_NOTIFY_ORDER

typedef struct _PO_DEVICE_NOTIFY_ORDER PO_DEVICE_NOTIFY_ORDER

PO_HIBER_PERF

typedef struct _PO_HIBER_PERF PO_HIBER_PERF

PO_MEMORY_IMAGE

typedef struct _PO_MEMORY_IMAGE PO_MEMORY_IMAGE

PO_MEMORY_RANGE_ARRAY

typedef struct _PO_MEMORY_RANGE_ARRAY PO_MEMORY_RANGE_ARRAY

PO_MEMORY_RANGE_ARRAY_LINK

typedef struct _PO_MEMORY_RANGE_ARRAY_LINK PO_MEMORY_RANGE_ARRAY_LINK

PO_MEMORY_RANGE_ARRAY_RANGE

typedef struct _PO_MEMORY_RANGE_ARRAY_RANGE PO_MEMORY_RANGE_ARRAY_RANGE

PO_NOTIFY_ORDER_LEVEL

typedef struct _PO_NOTIFY_ORDER_LEVEL PO_NOTIFY_ORDER_LEVEL

POP_DEVICE_IDLE_TYPE

typedef enum _POP_DEVICE_IDLE_TYPE POP_DEVICE_IDLE_TYPE

POP_DEVICE_POWER_IRP

typedef struct _POP_DEVICE_POWER_IRP POP_DEVICE_POWER_IRP

POP_DEVICE_SYS_STATE

typedef struct _POP_DEVICE_SYS_STATE POP_DEVICE_SYS_STATE

POP_HIBER_CONTEXT

typedef struct _POP_HIBER_CONTEXT POP_HIBER_CONTEXT

POP_POWER_ACTION

typedef struct _POP_POWER_ACTION POP_POWER_ACTION

POP_SHUTDOWN_BUG_CHECK

typedef struct _POP_SHUTDOWN_BUG_CHECK POP_SHUTDOWN_BUG_CHECK

POP_SHUTDOWN_WAIT_ENTRY

typedef struct _POP_SHUTDOWN_WAIT_ENTRY POP_SHUTDOWN_WAIT_ENTRY

POWER_CHANNEL_SUMMARY

typedef struct _POWER_CHANNEL_SUMMARY POWER_CHANNEL_SUMMARY

PPO_DEVICE_NOTIFY_ORDER

typedef struct _PO_DEVICE_NOTIFY_ORDER * PPO_DEVICE_NOTIFY_ORDER

PPO_HIBER_PERF

typedef struct _PO_HIBER_PERF * PPO_HIBER_PERF

PPO_MEMORY_IMAGE

typedef struct _PO_MEMORY_IMAGE * PPO_MEMORY_IMAGE

PPO_MEMORY_RANGE_ARRAY

typedef struct _PO_MEMORY_RANGE_ARRAY * PPO_MEMORY_RANGE_ARRAY

PPO_NOTIFY_ORDER_LEVEL

typedef struct _PO_NOTIFY_ORDER_LEVEL * PPO_NOTIFY_ORDER_LEVEL

PPOP_DEVICE_IDLE_TYPE

typedef enum _POP_DEVICE_IDLE_TYPE * PPOP_DEVICE_IDLE_TYPE

PPOP_DEVICE_POWER_IRP

typedef struct _POP_DEVICE_POWER_IRP * PPOP_DEVICE_POWER_IRP

PPOP_DEVICE_SYS_STATE

typedef struct _POP_DEVICE_SYS_STATE * PPOP_DEVICE_SYS_STATE

PPOP_HIBER_CONTEXT

typedef struct _POP_HIBER_CONTEXT * PPOP_HIBER_CONTEXT

PPOP_POWER_ACTION

typedef struct _POP_POWER_ACTION * PPOP_POWER_ACTION

PPOP_SHUTDOWN_BUG_CHECK

typedef struct _POP_SHUTDOWN_BUG_CHECK * PPOP_SHUTDOWN_BUG_CHECK

PPOP_SHUTDOWN_WAIT_ENTRY

typedef struct _POP_SHUTDOWN_WAIT_ENTRY * PPOP_SHUTDOWN_WAIT_ENTRY

PPOWER_CHANNEL_SUMMARY

typedef struct _POWER_CHANNEL_SUMMARY * PPOWER_CHANNEL_SUMMARY

Enumeration Type Documentation

_POP_DEVICE_IDLE_TYPE

enum _POP_DEVICE_IDLE_TYPE

Enumerator
DeviceIdleNormal
DeviceIdleDisk

Definition at line 230 of file po.h.

{
    DeviceIdleNormal,
    DeviceIdleDisk,
} POP_DEVICE_IDLE_TYPE, *PPOP_DEVICE_IDLE_TYPE;

Function Documentation

PoInitializeDeviceObject()

VOID NTAPI PoInitializeDeviceObject

(

IN OUT PDEVOBJ_EXTENSION

DeviceObjectExtension

)

Definition at line 363 of file povolume.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension = (PVOID)DeviceObjectExtension;
    PAGED_CODE();

    /* Initialize the power flags */
    DeviceExtension->PowerFlags = PowerSystemUnspecified & 0xF;
    DeviceExtension->PowerFlags |= ((PowerDeviceUnspecified << 4) & 0xF0);

    /* The device object is not on drugs yet */
    DeviceExtension->Dope = NULL;
}

Referenced by IoCreateDevice().

PoInitializePrcb()

VOID NTAPI PoInitializePrcb

(

IN PKPRCB

Prcb

)

Definition at line 498 of file power.c.

{
    /* Initialize the Power State */
    RtlZeroMemory(&Prcb->PowerState, sizeof(Prcb->PowerState));
    Prcb->PowerState.Idle0KernelTimeLimit = 0xFFFFFFFF;
    Prcb->PowerState.CurrentThrottle = 100;
    Prcb->PowerState.CurrentThrottleIndex = 0;
    Prcb->PowerState.IdleFunction = PopIdle0;

    /* Initialize the Perf DPC and Timer */
    KeInitializeDpc(&Prcb->PowerState.PerfDpc, PopPerfIdleDpc, Prcb);
    KeSetTargetProcessorDpc(&Prcb->PowerState.PerfDpc, Prcb->Number);
    KeInitializeTimerEx(&Prcb->PowerState.PerfTimer, SynchronizationTimer);
}

Referenced by KiInitializeKernel(), and KiSystemStartupBootStack().

PoInitSystem()

BOOLEAN NTAPI PoInitSystem

(

IN ULONG

BootPhase

)

Definition at line 397 of file power.c.

{
    PVOID NotificationEntry;
    PCHAR CommandLine;
    BOOLEAN ForceAcpiDisable = FALSE;

    /* Check if this is phase 1 init */
    if (BootPhase == 1)
    {
        NTSTATUS Status;
        /* Register power button notification */
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                                (PVOID)&GUID_DEVICE_SYS_BUTTON,
                                                IopRootDeviceNode->PhysicalDeviceObject->DriverObject,
                                                PopAddRemoveSysCapsCallback,
                                                NULL,
                                                &NotificationEntry);
        if (!NT_SUCCESS(Status))
            return FALSE;

        /* Register lid notification */
        Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                                (PVOID)&GUID_DEVICE_LID,
                                                IopRootDeviceNode->PhysicalDeviceObject->DriverObject,
                                                PopAddRemoveSysCapsCallback,
                                                NULL,
                                                &NotificationEntry);
        return NT_SUCCESS(Status);
    }

    /* Initialize the power capabilities */
    RtlZeroMemory(&PopCapabilities, sizeof(SYSTEM_POWER_CAPABILITIES));

    /* Get the Command Line */
    CommandLine = KeLoaderBlock->LoadOptions;

    /* Upcase it */
    _strupr(CommandLine);

    /* Check for ACPI disable */
    if (strstr(CommandLine, "NOACPI")) ForceAcpiDisable = TRUE;

    if (ForceAcpiDisable)
    {
        /* Set the ACPI State to False if it's been forced that way */
        PopAcpiPresent = FALSE;
    }
    else
    {
        /* Otherwise check if the LoaderBlock has a ACPI Table  */
        PopAcpiPresent = KeLoaderBlock->Extension->AcpiTable != NULL ? TRUE : FALSE;
    }

    /* Enable shutdown by power button */
    if (PopAcpiPresent)
        PopCapabilities.SystemS5 = TRUE;

    /* Initialize volume support */
    InitializeListHead(&PopVolumeDevices);
    KeInitializeGuardedMutex(&PopVolumeLock);

    /* Initialize support for dope */
    KeInitializeSpinLock(&PopDopeGlobalLock);

    /* Initialize support for shutdown waits and work-items */
    PopInitShutdownList();

    return TRUE;
}

Referenced by Phase1InitializationDiscard().

PoNotifySystemTimeSet()

VOID NTAPI PoNotifySystemTimeSet

(

VOID

)

Definition at line 39 of file events.c.

{
    KIRQL OldIrql;

    /* Check if Win32k registered a notification callback */
    if (PopEventCallout)
    {
        /* Raise to dispatch */
        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);

        /* Notify the callback */
        ExNotifyCallback(SetSystemTimeCallback, NULL, NULL);

        /* Lower IRQL back */
        KeLowerIrql(OldIrql);
    }
}

Referenced by Phase1InitializationDiscard().

PopAddRemoveSysCapsCallback()

NTSTATUS NTAPI PopAddRemoveSysCapsCallback	(	IN PVOID	NotificationStructure,
		IN PVOID	Context
	)

Definition at line 147 of file events.c.

{
    PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification;
    PSYS_BUTTON_CONTEXT SysButtonContext;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE FileHandle;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT FileObject;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatusBlock;
    KEVENT Event;
    BOOLEAN Arrival;
    ULONG Caps;
    NTSTATUS Status;

    DPRINT("PopAddRemoveSysCapsCallback(%p %p)\n",
        NotificationStructure, Context);

    Notification = (PDEVICE_INTERFACE_CHANGE_NOTIFICATION)NotificationStructure;
    if (Notification->Version != 1)
        return STATUS_REVISION_MISMATCH;
    if (Notification->Size != sizeof(DEVICE_INTERFACE_CHANGE_NOTIFICATION))
        return STATUS_INVALID_PARAMETER;
    if (RtlCompareMemory(&Notification->Event, &GUID_DEVICE_INTERFACE_ARRIVAL, sizeof(GUID)) == sizeof(GUID))
        Arrival = TRUE;
    else if (RtlCompareMemory(&Notification->Event, &GUID_DEVICE_INTERFACE_REMOVAL, sizeof(GUID)) == sizeof(GUID))
        Arrival = FALSE;
    else
        return STATUS_INVALID_PARAMETER;

    if (Arrival)
    {
        DPRINT("Arrival of %wZ\n", Notification->SymbolicLinkName);

        /* Open the device */
        InitializeObjectAttributes(&ObjectAttributes,
                                   Notification->SymbolicLinkName,
                                   OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL);
        Status = ZwOpenFile(&FileHandle,
                            FILE_READ_DATA,
                            &ObjectAttributes,
                            &IoStatusBlock,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            0);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("ZwOpenFile() failed with status 0x%08lx\n", Status);
            return Status;
        }
        Status = ObReferenceObjectByHandle(FileHandle,
                                           FILE_READ_DATA,
                                           IoFileObjectType,
                                           KernelMode,
                                           (PVOID*)&FileObject,
                                           NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("ObReferenceObjectByHandle() failed with status 0x%08lx\n", Status);
            ZwClose(FileHandle);
            return Status;
        }
        DeviceObject = IoGetRelatedDeviceObject(FileObject);
        ObDereferenceObject(FileObject);

        /* Get capabilities (IOCTL_GET_SYS_BUTTON_CAPS) */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
        Irp = IoBuildDeviceIoControlRequest(IOCTL_GET_SYS_BUTTON_CAPS,
                                            DeviceObject,
                                            NULL,
                                            0,
                                            &Caps,
                                            sizeof(Caps),
                                            FALSE,
                                            &Event,
                                            &IoStatusBlock);
        if (!Irp)
        {
            DPRINT1("IoBuildDeviceIoControlRequest() failed\n");
            ZwClose(FileHandle);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            DPRINT("IOCTL_GET_SYS_BUTTON_CAPS pending\n");
            KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Sending IOCTL_GET_SYS_BUTTON_CAPS failed with status 0x%08x\n", Status);
            ZwClose(FileHandle);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        DPRINT("Device capabilities: 0x%x\n", Caps);
        if (Caps & SYS_BUTTON_POWER)
        {
            DPRINT("POWER button present\n");
            PopCapabilities.PowerButtonPresent = TRUE;
        }

        if (Caps & SYS_BUTTON_SLEEP)
        {
            DPRINT("SLEEP button present\n");
            PopCapabilities.SleepButtonPresent = TRUE;
        }

        if (Caps & SYS_BUTTON_LID)
        {
            DPRINT("LID present\n");
            PopCapabilities.LidPresent = TRUE;
        }

        SysButtonContext = ExAllocatePoolWithTag(NonPagedPool,
                                                 sizeof(SYS_BUTTON_CONTEXT),
                                                 'IWOP');
        if (!SysButtonContext)
        {
            DPRINT1("ExAllocatePoolWithTag() failed\n");
            ZwClose(FileHandle);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        /* Queue a work item to get sys button event */
        SysButtonContext->WorkItem = IoAllocateWorkItem(DeviceObject);
        SysButtonContext->DeviceObject = DeviceObject;
        if (!SysButtonContext->WorkItem)
        {
            DPRINT1("IoAllocateWorkItem() failed\n");
            ZwClose(FileHandle);
            ExFreePoolWithTag(SysButtonContext, 'IWOP');
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        IoQueueWorkItem(SysButtonContext->WorkItem,
                        PopGetSysButton,
                        DelayedWorkQueue,
                        SysButtonContext);

        ZwClose(FileHandle);
        return STATUS_SUCCESS;
    }
    else
    {
        DPRINT1("Removal of a power capable device not implemented\n");
        return STATUS_NOT_IMPLEMENTED;
    }
}

Referenced by PoInitSystem().

PopCleanupPowerState()

VOID NTAPI PopCleanupPowerState

(

IN PPOWER_STATE

PowerState

)

Definition at line 164 of file power.c.

{
    //UNIMPLEMENTED;
}

Referenced by PspExitProcess(), and PspExitThread().

PopFlushVolumes()

VOID NTAPI PopFlushVolumes

(

IN BOOLEAN

ShuttingDown

)

Definition at line 229 of file povolume.c.

{
    POP_FLUSH_VOLUME FlushContext = {{0}};
    ULONG FlushPolicy;
    UNICODE_STRING RegistryName = RTL_CONSTANT_STRING(L"\\Registry");
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE RegistryHandle;
    PLIST_ENTRY NextEntry;
    PDEVICE_OBJECT_POWER_EXTENSION  Dope;
    ULONG VolumeCount = 0;
    NTSTATUS Status;
    HANDLE ThreadHandle;
    ULONG ThreadCount;

    /* Setup the flush context */
    InitializeListHead(&FlushContext.List);
    KeInitializeEvent(&FlushContext.Wait, NotificationEvent, FALSE);

    /* What to flush */
    FlushPolicy = ShuttingDown ? 1 | 2 : PopFlushPolicy;
    if ((FlushPolicy & 1))
    {
        /* Registry flush requested, so open it */
        DPRINT("Opening registry\n");
        InitializeObjectAttributes(&ObjectAttributes,
                                   &RegistryName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   NULL,
                                   NULL);
        Status = ZwOpenKey(&RegistryHandle, KEY_READ, &ObjectAttributes);
        if (NT_SUCCESS(Status))
        {
            /* Flush the registry */
            DPRINT("Flushing registry\n");
            ZwFlushKey(RegistryHandle);
            ZwClose(RegistryHandle);
        }
    }

    /* Serialize with other flushes */
    KeAcquireGuardedMutex(&PopVolumeLock);

    /* Scan the volume list */
    NextEntry = PopVolumeDevices.Flink;
    while (NextEntry != &PopVolumeDevices)
    {
        /* Get the dope from the link */
        Dope = CONTAINING_RECORD(NextEntry, DEVICE_OBJECT_POWER_EXTENSION, Volume);

        /* Grab the next entry now, since we'll be modifying the list */
        NextEntry = NextEntry->Flink;

        /* Make sure the object is mounted, writable, exists, and is not a floppy */
        if (!(Dope->DeviceObject->Vpb->Flags & VPB_MOUNTED) ||
            (Dope->DeviceObject->Characteristics & FILE_FLOPPY_DISKETTE) ||
            (Dope->DeviceObject->Characteristics & FILE_READ_ONLY_DEVICE) ||
            ((Dope->DeviceObject->Vpb->RealDevice) &&
             (Dope->DeviceObject->Vpb->RealDevice->Characteristics & FILE_FLOPPY_DISKETTE)))
        {
            /* Not flushable */
            continue;
        }

        /* Remove it from the dope and add it to the flush context list */
        RemoveEntryList(&Dope->Volume);
        InsertTailList(&FlushContext.List, &Dope->Volume);

        /* Next */
        VolumeCount++;
    }

    /* Check if we should skip non-removable devices */
    if (!(FlushPolicy & 2))
    {
        /* ReactOS only implements this routine for shutdown, which requires it */
        UNIMPLEMENTED;
    }

    /* Check if there were no volumes at all */
    if (!VolumeCount)
    {
        /* Nothing to do */
        KeReleaseGuardedMutex(&PopVolumeLock);
        return;
    }

    /* Allocate up to 8 flusher threads */
    ThreadCount = min(VolumeCount, 8);
    InitializeObjectAttributes(&ObjectAttributes,
                               NULL,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);

    /* We will ourselves become a flusher thread */
    FlushContext.Count = 1;
    ThreadCount--;

    /* Look for any extra ones we might need */
    while (ThreadCount > 0)
    {
        /* Create a new one */
        ThreadCount--;
        DPRINT("Creating flush thread\n");
        Status = PsCreateSystemThread(&ThreadHandle,
                                      THREAD_ALL_ACCESS,
                                      &ObjectAttributes,
                                      0L,
                                      NULL,
                                      PopFlushVolumeWorker,
                                      &FlushContext);
        if (NT_SUCCESS(Status))
        {
            /* One more created... */
            FlushContext.Count++;
            ZwClose(ThreadHandle);
        }
    }

    /* Allow flushes to go through */
    KeReleaseGuardedMutex(&PopVolumeLock);

    /* Enter the flush work */
    DPRINT("Local flush\n");
    PopFlushVolumeWorker(&FlushContext);

    /* Wait for all flushes to be over */
    DPRINT("Waiting for flushes\n");
    KeWaitForSingleObject(&FlushContext.Wait, Executive, KernelMode, FALSE, NULL);
    DPRINT("Flushes have completed\n");
}

Referenced by NtSetSystemPowerState().

PopGracefulShutdown()

VOID NTAPI PopGracefulShutdown

(

IN PVOID

Context

)

Definition at line 247 of file poshtdwn.c.

{
    PEPROCESS Process = NULL;

    /* Process the registered waits and work items */
    PopProcessShutDownLists();

    /* Loop every process */
    Process = PsGetNextProcess(Process);
    while (Process)
    {
        /* Make sure this isn't the idle or initial process */
        if ((Process != PsInitialSystemProcess) && (Process != PsIdleProcess))
        {
            /* Print it */
            DPRINT1("%15s is still RUNNING (%p)\n", Process->ImageFileName, Process->UniqueProcessId);
        }

        /* Get the next process */
        Process = PsGetNextProcess(Process);
    }

    /* First, the HAL handles any "end of boot" special functionality */
    DPRINT("HAL shutting down\n");
    HalEndOfBoot();

    /* Shut down the Shim cache if enabled */
    ApphelpCacheShutdown();

    /* In this step, the I/O manager does first-chance shutdown notification */
    DPRINT("I/O manager shutting down in phase 0\n");
    IoShutdownSystem(0);

    /* In this step, all workers are killed and hives are flushed */
    DPRINT("Configuration Manager shutting down\n");
    CmShutdownSystem();

    /* Shut down the Executive */
    DPRINT("Executive shutting down\n");
    ExShutdownSystem();

    /* Note that modified pages should be written here (MiShutdownSystem) */
    MmShutdownSystem(0);

    /* Flush all user files before we start shutting down IO */
    /* This is where modified pages are written back by the IO manager */
    CcShutdownSystem();

    /* In this step, the I/O manager does last-chance shutdown notification */
    DPRINT("I/O manager shutting down in phase 1\n");
    IoShutdownSystem(1);
    CcWaitForCurrentLazyWriterActivity();

    /* FIXME: Calling Mm shutdown phase 1 here to get page file dereference
     * but it shouldn't be called here. Only phase 2 should be called.
     */
    MmShutdownSystem(1);

    /* Note that here, we should broadcast the power IRP to devices */

    /* In this step, the HAL disables any wake timers */
    DPRINT("Disabling wake timers\n");
    HalSetWakeEnable(FALSE);

    /* And finally the power request is sent */
    DPRINT("Taking the system down\n");
    PopShutdownSystem(PopAction.Action);
}

Referenced by NtSetSystemPowerState().

PopInitShutdownList()

VOID NTAPI PopInitShutdownList

(

VOID

)

Definition at line 35 of file poshtdwn.c.

{
    PAGED_CODE();

    /* Initialize the global shutdown event */
    KeInitializeEvent(&PopShutdownEvent, NotificationEvent, FALSE);

    /* Initialize the shutdown lists */
    PopShutdownThreadList = NULL;
    InitializeListHead(&PopShutdownQueue);

    /* Initialize the shutdown list lock */
    KeInitializeGuardedMutex(&PopShutdownListMutex);

    /* The list is available now */
    PopShutdownListAvailable = TRUE;
}

Referenced by PoInitSystem().

PopReadShutdownPolicy()

VOID NTAPI PopReadShutdownPolicy

(

VOID

)

Definition at line 318 of file poshtdwn.c.

{
    UNICODE_STRING KeyString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    HANDLE KeyHandle;
    ULONG Length;
    UCHAR Buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
    PKEY_VALUE_PARTIAL_INFORMATION Info = (PVOID)Buffer;

    /* Setup object attributes */
    RtlInitUnicodeString(&KeyString,
                         L"\\Registry\\Machine\\Software\\Policies\\Microsoft\\Windows NT");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyString,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);

    /* Open the key */
    Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
    if (NT_SUCCESS(Status))
    {
        /* Open the policy value and query it */
        RtlInitUnicodeString(&KeyString, L"DontPowerOffAfterShutdown");
        Status = ZwQueryValueKey(KeyHandle,
                                 &KeyString,
                                 KeyValuePartialInformation,
                                 &Info,
                                 sizeof(Info),
                                 &Length);
        if ((NT_SUCCESS(Status)) && (Info->Type == REG_DWORD))
        {
            /* Read the policy */
            PopShutdownPowerOffPolicy = *Info->Data == 1;
        }

        /* Close the key */
        ZwClose(KeyHandle);
    }
}

Referenced by NtSetSystemPowerState().

PopSetSystemPowerState()

NTSTATUS NTAPI PopSetSystemPowerState	(	SYSTEM_POWER_STATE	PowerState,
		POWER_ACTION	PowerAction
	)

Definition at line 332 of file power.c.

{
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_OBJECT Fdo;
    NTSTATUS Status;
    DEVICETREE_TRAVERSE_CONTEXT Context;
    POWER_STATE_TRAVERSE_CONTEXT PowerContext;

    Status = IopGetSystemPowerDeviceObject(&DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("No system power driver available\n");
        Fdo = NULL;
    }
    else
    {
        Fdo = IoGetAttachedDeviceReference(DeviceObject);
        if (Fdo == DeviceObject)
        {
            DPRINT("An FDO was not attached\n");
            return STATUS_UNSUCCESSFUL;
        }
    }

    /* Set up context */
    PowerContext.PowerAction = PowerAction;
    PowerContext.SystemPowerState = PowerState;
    PowerContext.PowerDevice = Fdo;

    /* Query for system power change */
    IopInitDeviceTreeTraverseContext(&Context,
                                     IopRootDeviceNode,
                                     PopQuerySystemPowerStateTraverse,
                                     &PowerContext);

    Status = IopTraverseDeviceTree(&Context);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Query system power state failed; changing state anyway\n");
    }

    /* Set system power change */
    IopInitDeviceTreeTraverseContext(&Context,
                                     IopRootDeviceNode,
                                     PopSetSystemPowerStateTraverse,
                                     &PowerContext);

    IopTraverseDeviceTree(&Context);

    if (!PopAcpiPresent) return STATUS_NOT_IMPLEMENTED;

    if (Fdo != NULL)
    {
        if (PowerAction != PowerActionShutdownReset)
            PopSendSetSystemPowerState(Fdo, PowerState, PowerAction);

        ObDereferenceObject(Fdo);
    }

    return Status;
}

Referenced by PopShutdownSystem().

PoRemoveVolumeDevice()

VOID NTAPI PoRemoveVolumeDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 105 of file povolume.c.

{
    PDEVICE_OBJECT_POWER_EXTENSION Dope;
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
    KIRQL OldIrql;
    PAGED_CODE();

    /* If the device already has the dope, return it */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
    if (!DeviceExtension->Dope)
    {
        /* no dope */
        return;
    }

    /* Make sure we can flush safely */
    KeAcquireGuardedMutex(&PopVolumeLock);

    /* Get dope from device */
    Dope = (PDEVICE_OBJECT_POWER_EXTENSION)DeviceExtension->Dope;

    if (Dope->Volume.Flink)
    {
        /* Remove from volume from list */
        RemoveEntryList(&Dope->Volume);
    }

    /* Allow flushes to go through */
    KeReleaseGuardedMutex(&PopVolumeLock);

    /* Now remove dope from device object */
    KeAcquireSpinLock(&PopDopeGlobalLock, &OldIrql);

    /* remove from dev obj */
    DeviceExtension->Dope = NULL;

    /* Release lock */
    KeReleaseSpinLock(&PopDopeGlobalLock, OldIrql);

    /* Free dope */
    ExFreePoolWithTag(Dope, TAG_PO_DOPE);
}

Referenced by IoDeleteDevice().

PoVolumeDevice()

VOID NTAPI PoVolumeDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 83 of file povolume.c.

{
    PDEVICE_OBJECT_POWER_EXTENSION Dope;
    PAGED_CODE();

    /* Get dope from the device (if the device has no dope, it will receive some) */
    Dope = PopGetDope(DeviceObject);
    if (Dope)
    {
        /* Make sure we can flush safely */
        KeAcquireGuardedMutex(&PopVolumeLock);

        /* Add this volume into the list of power-manager volumes */
        if (!Dope->Volume.Flink) InsertTailList(&PopVolumeDevices, &Dope->Volume);

        /* Allow flushes to go through */
        KeReleaseGuardedMutex(&PopVolumeLock);
    }
}

Referenced by IoCreateDevice(), and IoVerifyVolume().

Variable Documentation

PopAction

POP_POWER_ACTION PopAction

Definition at line 27 of file power.c.

Referenced by NtSetSystemPowerState(), and PopGracefulShutdown().

PopCapabilities

SYSTEM_POWER_CAPABILITIES PopCapabilities

Definition at line 29 of file power.c.

Referenced by NtPowerInformation(), PoInitSystem(), and PopAddRemoveSysCapsCallback().

PopDopeGlobalLock

KSPIN_LOCK PopDopeGlobalLock

Definition at line 28 of file povolume.c.

Referenced by PoInitSystem(), PopGetDope(), and PoRemoveVolumeDevice().

PopSystemPowerDeviceNode

PDEVICE_NODE PopSystemPowerDeviceNode

Definition at line 25 of file power.c.

Referenced by IopGetSystemPowerDeviceObject(), and PiCallDriverAddDevice().

PopVolumeDevices

LIST_ENTRY PopVolumeDevices

Definition at line 27 of file povolume.c.

Referenced by PoInitSystem(), PopFlushVolumes(), PopFlushVolumeWorker(), and PoVolumeDevice().

PopVolumeLock

KGUARDED_MUTEX PopVolumeLock

Definition at line 26 of file povolume.c.

Referenced by PoInitSystem(), PopFlushVolumes(), PopFlushVolumeWorker(), PoRemoveVolumeDevice(), and PoVolumeDevice().