OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/base/ntos/po/sys.c

1033 lines
26 KiB
C
Raw Blame History

/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
sys.c
Abstract:
This module interfaces to the system power state handler functions
Author:
Ken Reneris (kenr) 17-Jan-1997
Revision History:
--*/
#include "pop.h"
#include <inbv.h>
#include <stdio.h>
#if defined(i386) || defined(_AMD64_)
VOID
KeRestoreProcessorSpecificFeatures(
VOID
);
#endif
#if defined(i386)
VOID
KePrepareToLoseProcessorSpecificState(
VOID
);
__inline
LONGLONG
POP_GET_TICK_COUNT(
VOID
)
{
_asm _emit 0x0f
_asm _emit 0x31
}
#endif
//
// Internal shared context structure used to coordinate
// invoking a power state handler
//
typedef struct {
PPOWER_STATE_HANDLER Handler;
PENTER_STATE_SYSTEM_HANDLER SystemHandler;
PVOID SystemContext;
PPOP_HIBER_CONTEXT HiberContext;
PPOWER_STATE_NOTIFY_HANDLER NotifyHandler;
POWER_STATE_HANDLER_TYPE NotifyState;
BOOLEAN NotifyType;
LONG NumberProcessors;
volatile LONG TargetCount;
volatile ULONG State;
LONG HandlerBarrier;
} POP_SYS_CONTEXT, *PPOP_SYS_CONTEXT;
typedef struct {
ULONG LastState;
BOOLEAN InterruptEnable;
KIRQL Irql;
BOOLEAN FloatSaved;
KFLOATING_SAVE FloatSave;
NTSTATUS Status;
} POP_LOCAL_CONTEXT, *PPOP_LOCAL_CONTEXT;
#define POP_SH_UNINITIALIZED 0
#define POP_SH_COLLECTING_PROCESSORS 1
#define POP_SH_SAVE_CONTEXT 2
#define POP_SH_GET_STACKS 3
#define POP_SH_DISABLE_INTERRUPTS 4
#define POP_SH_INVOKE_HANDLER 5
#define POP_SH_INVOKE_NOTIFY_HANDLER 6
#define POP_SH_RESTORE_INTERRUPTS 7
#define POP_SH_RESTORE_CONTEXT 8
#define POP_SH_COMPLETE 9
extern ULONG MmAvailablePages;
BOOLEAN PopFailedHibernationAttempt = FALSE; // we tried to hibernate and failed.
WCHAR PopHibernationErrorSubtstitionString[128];
//
// Internal prototypes
//
NTSTATUS
PopInvokeSystemStateHandler (
IN POWER_STATE_HANDLER_TYPE Type,
IN PVOID Memory
);
VOID
PopIssueNextState (
IN PPOP_SYS_CONTEXT Context,
IN PPOP_LOCAL_CONTEXT LocalContext,
IN ULONG NextState
);
VOID
PopHandleNextState (
IN PPOP_SYS_CONTEXT Context,
IN PPOP_LOCAL_CONTEXT LocalContext
);
VOID
PopInvokeStateHandlerTargetProcessor (
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2
);
NTSTATUS
PopShutdownHandler (
IN PVOID Context,
IN PENTER_STATE_SYSTEM_HANDLER SystemHandler OPTIONAL,
IN PVOID SystemContext,
IN LONG NumberProcessors,
IN volatile PLONG Number
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGELK, PopShutdownSystem)
#pragma alloc_text(PAGELK, PopSleepSystem)
#pragma alloc_text(PAGELK, PopInvokeSystemStateHandler)
#pragma alloc_text(PAGELK, PopInvokeStateHandlerTargetProcessor)
#pragma alloc_text(PAGELK, PopIssueNextState)
#pragma alloc_text(PAGELK, PopHandleNextState)
#pragma alloc_text(PAGELK, PopShutdownHandler)
#endif
VOID
PopShutdownSystem (
IN POWER_ACTION SystemAction
)
/*++
Routine Description:
Routine to implement a Shutdown style power actions
Arguments:
SystemAction - Action to implement (must be a valid shutdown type)
Return Value:
Status
--*/
{
//
// Tell the debugger we are shutting down
//
KD_SYMBOLS_INFO SymbolInfo = {0};
SymbolInfo.BaseOfDll = (PVOID)KD_REBOOT;
DebugService2(NULL, &SymbolInfo, BREAKPOINT_UNLOAD_SYMBOLS);
//
// Perform the final shutdown operation
//
switch (SystemAction) {
case PowerActionShutdownReset:
//
// Reset the system
//
PopInvokeSystemStateHandler (PowerStateShutdownReset, NULL);
//
// Didn't do it, go for legacy function
//
HalReturnToFirmware (HalRebootRoutine);
break;
case PowerActionShutdownOff:
case PowerActionShutdown:
//
// Power down the system
//
PopInvokeSystemStateHandler (PowerStateShutdownOff, NULL);
//
// Didn't do it, go for legacy function
//
HalReturnToFirmware (HalPowerDownRoutine);
//
// Due to simulations we can try to power down on systems
// which don't support it
//
PoPrint (PO_ERROR, ("PopShutdownSystem: HalPowerDownRoutine returned\n"));
HalReturnToFirmware (HalRebootRoutine);
break;
default:
//
// Got some unexpected input...
ASSERT(0);
HalReturnToFirmware (HalRebootRoutine);
}
KeBugCheckEx (INTERNAL_POWER_ERROR, 5, 0, 0, 0);
}
#if _MSC_FULL_VER >= 13008827
#pragma warning(push)
#pragma warning(disable:4715) // Not all control paths return (due to infinite loop at end)
#endif
NTSTATUS
PopShutdownHandler (
IN PVOID Context,
IN PENTER_STATE_SYSTEM_HANDLER SystemHandler OPTIONAL,
IN PVOID SystemContext,
IN LONG NumberProcessors,
IN volatile PLONG Number
)
{
PKPRCB Prcb;
UNREFERENCED_PARAMETER (Context);
UNREFERENCED_PARAMETER (SystemHandler);
UNREFERENCED_PARAMETER (SystemContext);
UNREFERENCED_PARAMETER (NumberProcessors);
UNREFERENCED_PARAMETER (Number);
KeDisableInterrupts();
Prcb = KeGetCurrentPrcb();
//
// On processor 0 put up the shutdown screen
//
if (Prcb->Number == 0) {
if (InbvIsBootDriverInstalled()) {
PUCHAR Bitmap1, Bitmap2;
if (!InbvCheckDisplayOwnership()) {
InbvAcquireDisplayOwnership();
}
InbvResetDisplay();
InbvSolidColorFill(0,0,639,479,0);
InbvEnableDisplayString(TRUE); // enable display string
InbvSetScrollRegion(0,0,639,475); // set to use entire screen
Bitmap1 = InbvGetResourceAddress(3);
Bitmap2 = InbvGetResourceAddress(5);
if (Bitmap1 && Bitmap2) {
InbvBitBlt(Bitmap1, 215, 282);
InbvBitBlt(Bitmap2, 217, 111);
}
} else {
ULONG i;
//
// Skip to middle of the display
//
for (i=0; i<25; i++) {
InbvDisplayString ((PUCHAR)"\n");
}
InbvDisplayString ((PUCHAR)" "); // 23 spaces
InbvDisplayString ((PUCHAR)"The system may be powered off now.\n");
}
}
//
// Halt
//
for (; ;) {
HalHaltSystem ();
}
}
#if _MSC_FULL_VER >= 13008827
#pragma warning(pop)
#endif
NTSTATUS
PopSleepSystem (
IN SYSTEM_POWER_STATE SystemState,
IN PVOID Memory
)
/*++
Routine Description:
Routine to implement a Sleep style system power actions.
N.B. All devices must already be in a compatible sleeping state.
Arguments:
SystemState - System state to implement (must be a valid sleep type)
Return Value:
Status
--*/
{
POWER_STATE_HANDLER_TYPE Type;
NTSTATUS Status = STATUS_SUCCESS;
switch (SystemState) {
case PowerSystemSleeping1: Type = PowerStateSleeping1; break;
case PowerSystemSleeping2: Type = PowerStateSleeping2; break;
case PowerSystemSleeping3: Type = PowerStateSleeping3; break;
case PowerSystemHibernate: Type = PowerStateSleeping4; break;
default:
PoAssert(PO_ERROR,FALSE && ("PopSleepSystem: Bad SYSTEM_POWER_STATE requested."));
return STATUS_INVALID_PARAMETER;
}
Status = PopInvokeSystemStateHandler (Type, Memory);
if( !NT_SUCCESS(Status) && (SystemState == PowerSystemHibernate) ) {
UNICODE_STRING UnicodeString;
_snwprintf( PopHibernationErrorSubtstitionString, sizeof(PopHibernationErrorSubtstitionString)/sizeof(WCHAR), L"0x%x", Status );
RtlInitUnicodeString( &UnicodeString, PopHibernationErrorSubtstitionString );
//
// Tell someone.
// We'll send in a friendly error code instead of the
// cryptic one we got back from PopInvokeSystemStateHandler()
//
IoRaiseInformationalHardError( STATUS_HIBERNATION_FAILURE, &UnicodeString, NULL );
// Remember that we failed so we don't try again.
PopFailedHibernationAttempt = TRUE;
}
return Status;
}
NTSTATUS
PopInvokeSystemStateHandler (
IN POWER_STATE_HANDLER_TYPE Type,
IN PPOP_HIBER_CONTEXT HiberContext
)
/*++
Routine Description:
Invokes a power state handler on every processor concurrently.
Arguments:
Type - Index to the handle to invoke
Return Value:
Status
--*/
{
KDPC Dpc;
KIRQL OldIrql;
KAFFINITY Targets;
ULONG Processor;
LONG TargetCount;
POP_SYS_CONTEXT Context;
POP_LOCAL_CONTEXT LocalContext;
POWER_STATE_HANDLER ShutdownHandler;
KAFFINITY ActiveProcessors;
ULONG result;
//
// No spinlocks can be held when this call is made
//
ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
//
// Get system state handler
//
RtlZeroMemory (&Context, sizeof(Context));
RtlZeroMemory (&ShutdownHandler, sizeof(ShutdownHandler));
Context.Handler = &ShutdownHandler;
Context.NotifyHandler = &PopPowerStateNotifyHandler;
Context.NotifyState = Type;
if (Type != PowerStateMaximum) {
Context.Handler = &PopPowerStateHandlers[Type];
if (!Context.Handler->Handler) {
return STATUS_DEVICE_DOES_NOT_EXIST;
}
}
Context.NumberProcessors = (ULONG) KeNumberProcessors;
Context.HandlerBarrier = KeNumberProcessors;
Context.State = POP_SH_COLLECTING_PROCESSORS;
Context.HiberContext = HiberContext;
if (HiberContext) {
Context.SystemContext = HiberContext;
Context.SystemHandler = PopSaveHiberContext;
}
RtlZeroMemory (&LocalContext, sizeof(LocalContext));
//
// Before we freeze the machine, attempt to collect up as much memory
// as we can from MM to avoid saving it into the hibernation file.
//
if (HiberContext && HiberContext->ReserveFreeMemory) {
for (; ;) {
if (MmAvailablePages < POP_FREE_THRESHOLD) {
break;
}
//
// Collect the pages
//
result = PopGatherMemoryForHibernate (HiberContext,
POP_FREE_ALLOCATE_SIZE,
&HiberContext->Spares,
FALSE);
if (!result) {
break;
}
}
}
//
// Switch to boot processor and raise to DISPATCH_LEVEL level to
// avoid getting any DPCs
//
KeSetSystemAffinityThread (1);
KeRaiseIrql (DISPATCH_LEVEL, &OldIrql);
KeInitializeDpc (&Dpc, PopInvokeStateHandlerTargetProcessor, &Context);
KeSetImportanceDpc (&Dpc, HighImportance);
//
// Collect and halt the other processors
//
Targets = KeActiveProcessors & (~1);
while (Targets) {
KeFindFirstSetLeftAffinity(Targets, &Processor);
ClearMember (Processor, Targets);
//
// Prepare to wait
//
TargetCount = Context.TargetCount;
//
// Issue DPC to target processor
//
KeSetTargetProcessorDpc (&Dpc, (CCHAR) Processor);
KeInsertQueueDpc (&Dpc, NULL, NULL);
//
// Wait for DPC to be processed
//
while (TargetCount == Context.TargetCount) ;
}
//
// All processors halted and spinning at dispatch level
//
PopIssueNextState (&Context, &LocalContext, POP_SH_SAVE_CONTEXT);
#if defined(i386)
//
// Fast system call must be disabled until the context required
// to support it is restored.
//
KePrepareToLoseProcessorSpecificState();
#endif
//
// Enter system state
//
if (HiberContext) {
//
// Get each processors stacks in the memory map for
// special handling during hibernate
//
PopIssueNextState (&Context, &LocalContext, POP_SH_GET_STACKS);
//
// Build the rest of the map, and structures needed
// to write the file
//
LocalContext.Status = PopBuildMemoryImageHeader (HiberContext, Type);
#ifdef HIBERNATE_PRESERVE_BPS
//
// Disable the kernel debugger breakpoints. We will reenable them after
// resume. We do this here because this could in theory require an IPI.
//
KdDisableDebugger();
#endif //HIBERNATE_PRESERVE_BPS
//
// Disable interrupts on all processors
//
PopIssueNextState (&Context, &LocalContext, POP_SH_DISABLE_INTERRUPTS);
//
// With interrupts disabled on all the processors, the debugger
// really can't work the way its supposed to. It can't IPI the
// other processors to get them to stop. So we temporarily
// change the kernel's notion of active processors, making it
// think that the this processor is the only one it has to worry
// about.
//
ActiveProcessors = KeActiveProcessors;
KeActiveProcessors = 1;
if (NT_SUCCESS(LocalContext.Status)) {
//
// Notify the Notify Handler of pending sleep
//
Context.NotifyType = TRUE; // notify before
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_NOTIFY_HANDLER);
//
// Invoke the Power State handler
//
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_HANDLER);
//
// If the sleep was successful, clear the fully awake flag
//
if (NT_SUCCESS(LocalContext.Status)) {
InterlockedExchange(&PopFullWake, PO_GDI_ON_PENDING);
PoPowerSequence = PoPowerSequence + 1;
PopSIdle.Time = 1;
}
//
// Notify the Notify Handler of resume
//
Context.NotifyType = FALSE; // notify after
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_NOTIFY_HANDLER);
}
//
// Hiber is over, call while the machine still stopped to allow
// memory verification, etc..
//
PopHiberComplete (LocalContext.Status, HiberContext);
//
// If there's a request for a reset here, do it
//
if (HiberContext->Reset) {
Context.Handler = &PopPowerStateHandlers[PowerStateShutdownReset];
Context.HiberContext = NULL;
if (Context.Handler->Handler) {
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_HANDLER);
}
HalReturnToFirmware (HalRebootRoutine);
}
//
// If we are past this point, then we are guaranteed to have awakened
// from Hibernation (or something went severely wrong).
//
// Our Hibercontext is no longer needed (in fact, we will free it soon).
//
// Thus we set its status value to indicate that this is a wake up.
// This status value is used later on when the context is being freed
// in order to clear things no longer needed after the system awakens properly.
//
PERFINFO_HIBER_REINIT_TRACE();
HiberContext->Status = STATUS_WAKE_SYSTEM;
//
// Now restore the kernel's previous notion of active processors
// before we enable interrupts on the others.
//
KeActiveProcessors = ActiveProcessors;
//
// Restore interrupts on all processors
//
PopIssueNextState (&Context, &LocalContext, POP_SH_RESTORE_INTERRUPTS);
#ifdef HIBERNATE_PRESERVE_BPS
//
// Reenable the kernel debugger breakpoints. This will reset the
// debugger if neccessary.
//
KdEnableDebugger();
#endif //HIBERNATE_PRESERVE_BPS
//
// We are returning from hibernate, and we need to tell the system
// that win32k now owns the display again.
//
InbvSetDisplayOwnership(FALSE);
} else {
//
// Notify the Notify Handler of pending sleep
//
Context.NotifyType = TRUE; // notify before
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_NOTIFY_HANDLER);
//
// Invoke the sleep handle
//
if (PERFINFO_IS_GROUP_ON(PERF_POWER)) {
PERFINFO_PO_PRESLEEP LogEntry;
#if defined(i386)
if (PopAction.SystemState == PowerSystemSleeping3) {
LogEntry.PerformanceFrequency.QuadPart = (ULONGLONG)KeGetCurrentPrcb()->MHz * 1000000;
LogEntry.PerformanceCounter.QuadPart = 0;
} else {
LogEntry.PerformanceCounter = KeQueryPerformanceCounter(&LogEntry.PerformanceFrequency);
}
#else
LogEntry.PerformanceCounter = KeQueryPerformanceCounter(&LogEntry.PerformanceFrequency);
#endif
PerfInfoLogBytes(PERFINFO_LOG_TYPE_PO_PRESLEEP,
&LogEntry,
sizeof(LogEntry));
}
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_HANDLER);
if (PERFINFO_IS_GROUP_ON(PERF_POWER)) {
PERFINFO_PO_POSTSLEEP LogEntry;
#if defined(i386)
if (PopAction.SystemState == PowerSystemSleeping3) {
LogEntry.PerformanceCounter.QuadPart = POP_GET_TICK_COUNT();
} else {
LogEntry.PerformanceCounter = KeQueryPerformanceCounter(NULL);
}
#else
LogEntry.PerformanceCounter = KeQueryPerformanceCounter(NULL);
#endif
PerfInfoLogBytes(PERFINFO_LOG_TYPE_PO_POSTSLEEP,
&LogEntry,
sizeof(LogEntry));
}
//
// If the sleep was successful, clear the fully awake flag
//
if (NT_SUCCESS(LocalContext.Status)) {
//
// If somebody has set display required, then turn the
// display back on. Otherwise leave it off until there
// is some user activity signalled.
//
if (PopAttributes[POP_DISPLAY_ATTRIBUTE].Count > 0) {
InterlockedExchange(&PopFullWake, PO_GDI_ON_PENDING);
} else {
InterlockedExchange(&PopFullWake, 0);
}
PoPowerSequence = PoPowerSequence + 1;
PopSIdle.Time = 1;
}
//
// Notify the Notify Handler of resume
//
Context.NotifyType = FALSE; // notify after
PopIssueNextState (&Context, &LocalContext, POP_SH_INVOKE_NOTIFY_HANDLER);
}
//
// Restore other saved state on each processor
//
PopIssueNextState (&Context, &LocalContext, POP_SH_RESTORE_CONTEXT);
#if defined(i386)
//
// On x86, reload any processor specific data structures (MSRs).
//
if (NT_SUCCESS(LocalContext.Status)) {
KeRestoreProcessorSpecificFeatures();
}
#endif
//
// Let the other processor return
//
PopIssueNextState (&Context, &LocalContext, POP_SH_COMPLETE);
//
// Now that all processors have returned,
// put all the available memory back into the system. We don't do
// this earlier because on systems with large amounts of memory it
// can take significant time to free it all and this triggers the
// DPC timeouts.
//
if (HiberContext) {
PopFreeHiberContext (FALSE);
}
//
// If success, return status_success and count the number of
// times the sleep state has worked
//
if (NT_SUCCESS(LocalContext.Status)) {
LocalContext.Status = STATUS_SUCCESS;
if (Context.Handler->Spare[0] != 0xff) {
Context.Handler->Spare[0] += 1;
}
}
//
// Done
//
KeLowerIrql (OldIrql);
return LocalContext.Status;
}
VOID
PopIssueNextState (
IN PPOP_SYS_CONTEXT Context,
IN PPOP_LOCAL_CONTEXT LocalContext,
IN ULONG NextState
)
/*++
Routine Description:
Called by the invoking processor to instruct all processors
to the next state in the sequence needed to invoke/enter the
target power handler.
Arguments:
Context - Shared context structure used to communicate the
state transitions
NextState - New target state to enter
Return Value:
None
--*/
{
//
// Reset count for this operation
//
InterlockedExchange ((PVOID) &Context->TargetCount, 0);
//
// Issue new state
//
InterlockedExchange ((PVOID) &Context->State, NextState);
//
// Handle it ourselves
//
LocalContext->LastState = POP_SH_UNINITIALIZED;
PopHandleNextState (Context, LocalContext);
//
// Wait for all processor to complete
//
while (Context->TargetCount != Context->NumberProcessors) {
KeYieldProcessor ();
}
}
VOID
PopHandleNextState (
IN PPOP_SYS_CONTEXT Context,
IN PPOP_LOCAL_CONTEXT LocalContext
)
/*++
Routine Description:
Wait for next state notification, and then handle it
Arguments:
Context - Shared context structure used to communicate the
state transitions
LocalContext- Context local to this processor
Return Value:
None
--*/
{
NTSTATUS Status;
PPROCESSOR_POWER_STATE PState;
PKPRCB Prcb;
Prcb = KeGetCurrentPrcb();
PState = &Prcb->PowerState;
//
// Wait for new state
//
while (Context->State == LocalContext->LastState) {
KeYieldProcessor ();
}
//
// Pickup new state and handle it
//
LocalContext->LastState = Context->State;
switch (LocalContext->LastState) {
case POP_SH_SAVE_CONTEXT:
Status = KeSaveFloatingPointState(&LocalContext->FloatSave);
LocalContext->FloatSaved = NT_SUCCESS(Status) ? TRUE : FALSE;
break;
case POP_SH_GET_STACKS:
PopCloneStack (Context->HiberContext);
break;
case POP_SH_DISABLE_INTERRUPTS:
LocalContext->Irql = KeGetCurrentIrql();
LocalContext->InterruptEnable = KeDisableInterrupts();
break;
case POP_SH_INVOKE_HANDLER:
Status = Context->Handler->Handler (
Context->Handler->Context,
Context->SystemHandler,
Context->SystemContext,
Context->NumberProcessors,
&Context->HandlerBarrier
);
LocalContext->Status = Status;
break;
case POP_SH_INVOKE_NOTIFY_HANDLER:
if (Context->NotifyHandler->Handler) {
Status = Context->NotifyHandler->Handler(
Context->NotifyState,
Context->NotifyHandler->Context,
Context->NotifyType
);
//
// Don't overwrite LocalContext->Status here. It's been set
// by the POP_SH_INVOKE_HANDLER code above and we don't want
// to step on that.
//
ASSERT(NT_SUCCESS(Status));
}
break;
case POP_SH_RESTORE_INTERRUPTS:
KeEnableInterrupts(LocalContext->InterruptEnable);
KeLowerIrql(LocalContext->Irql);
break;
case POP_SH_RESTORE_CONTEXT:
#if defined(_AMD64_)
KeRestoreProcessorSpecificFeatures();
#endif
if (LocalContext->FloatSaved) {
KeRestoreFloatingPointState(&LocalContext->FloatSave);
}
if (PState->Flags & PSTATE_SUPPORTS_THROTTLE) {
PState->PerfSetThrottle(PState->CurrentThrottle);
}
break;
}
//
// Signal that we are in the new state
//
InterlockedIncrement (&Context->TargetCount);
}
VOID
PopInvokeStateHandlerTargetProcessor (
IN PKDPC Dpc,
IN PVOID DeferredContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2
)
/*++
Routine Description:
Called by target processors when invoking a power state
handler. Target processors wait for invoking processor
to coordinate the states required to enter the particular
power state handler.
Arguments:
Dpc - Not used
DeferredContext - Shared context structure
Return Value:
None
--*/
{
POP_LOCAL_CONTEXT LocalContext;
PPOP_SYS_CONTEXT Context;
UNREFERENCED_PARAMETER (Dpc);
UNREFERENCED_PARAMETER (SystemArgument1);
UNREFERENCED_PARAMETER (SystemArgument2);
Context = (PPOP_SYS_CONTEXT) DeferredContext;
RtlZeroMemory (&LocalContext, sizeof(LocalContext));
LocalContext.LastState = POP_SH_UNINITIALIZED;
//
// Handle new states
//
do {
PopHandleNextState (Context, &LocalContext);
} while (LocalContext.LastState != POP_SH_COMPLETE);
}
View Git Blame Copy Permalink