Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

362 lines
16 KiB

/*******************************************************************************
*
* (C) COPYRIGHT MICROSOFT CORP., 1997
*
* TITLE: DEBUG.C
*
* VERSION: 2.0
*
* AUTHOR: ReedB
*
* DATE: 21 Jan, 1997
*
* DESCRIPTION:
*
* Private debug routines implemented here.
*
*******************************************************************************/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <ntpoapi.h>
#include <stdio.h>
#include <powrprofp.h>
#ifdef DEBUG
LPTSTR lpszDebugPwrState[] = {
TEXT("PwrSysUnspecified"),
TEXT("S0, PwrSysWorking"),
TEXT("S1, PwrSysSleeping1"),
TEXT("S2, PwrSysSleeping2"),
TEXT("S3, PwrSysSleeping3"),
TEXT("S4, PwrSysHibernate"),
TEXT("S5, PwrSysShutdown"),
TEXT("PwrSysMaximum")
};
LPTSTR lpszDebugPwrAction[] = {
TEXT("PwrActionNone"),
TEXT("PwrActionDoze"),
TEXT("PwrActionSleep"),
TEXT("PwrActionHibernate"),
TEXT("PwrActionShutdown"),
TEXT("PwrActionShutdownReset"),
TEXT("PwrActionShutdownOff")
};
extern int g_iShowValidationChanges;
/*******************************************************************************
*
* GetIndent
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
#define MAX_INDENT 32
void GetIndent(LPSTR lpsz, LPSTR lpszIndent)
{
UINT i;
for (i = 0; i < MAX_INDENT; i++) {
if (*lpsz != ' ') {
break;
}
lpsz++;
*lpszIndent++ = ' ';
}
*lpszIndent = '\0';
}
/*******************************************************************************
*
* DumpPowerActionPolicy
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
void DumpPowerActionPolicy(
LPSTR lpszLabel,
PPOWER_ACTION_POLICY ppap
)
{
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
GetIndent(lpszLabel, szIndent);
MYDBGPRINT(("%s, POWER_ACTION_POLICY: %08X", lpszLabel, ppap));
if (ppap->Action <= PowerActionShutdownOff) {
MYDBGPRINT(("%s Action: %08X, %s", szIndent, ppap->Action, lpszDebugPwrAction[ppap->Action]));
}
else {
MYDBGPRINT(("%s Action: %08X, Invalid!", szIndent, ppap->Action));
}
MYDBGPRINT(("%s Flags: %08X", szIndent, ppap->Flags));
MYDBGPRINT(("%s EventCode: %08X", szIndent, ppap->EventCode));
}
/*******************************************************************************
*
* DumpSystemPowerLevel
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
void DumpSystemPowerLevel(
LPSTR lpszLabel,
PSYSTEM_POWER_LEVEL pspl
)
{
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
GetIndent(lpszLabel, szIndent);
MYDBGPRINT(("%s, SYSTEM_POWER_LEVEL: %08X", lpszLabel, pspl));
MYDBGPRINT(("%s Enable: %08X", szIndent, pspl->Enable));
MYDBGPRINT(("%s BatteryLevel: %08X", szIndent, pspl->BatteryLevel));
wsprintfA(szLabel, "%s PowerPolicy", szIndent);
DumpPowerActionPolicy(szLabel, &pspl->PowerPolicy);
if (pspl->MinSystemState <= PowerSystemMaximum) {
MYDBGPRINT(("%s MinSystemState: %08X, %s", szIndent, pspl->MinSystemState, lpszDebugPwrState[pspl->MinSystemState]));
}
else {
MYDBGPRINT(("%s MinSystemState: %08X, Invalid!!", szIndent, pspl->MinSystemState));
}
}
/*******************************************************************************
*
* DumpSystemPowerPolicy
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
void DumpSystemPowerPolicy(
LPSTR lpszLabel,
PSYSTEM_POWER_POLICY pspp
)
{
UINT i;
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
GetIndent(lpszLabel, szIndent);
MYDBGPRINT(("%s, SYSTEM_POWER_POLICY: %08X", lpszLabel, pspp));
MYDBGPRINT(("%s Revision: %08X", szIndent, pspp->Revision));
wsprintfA(szLabel, "%s PowerButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp->PowerButton);
wsprintfA(szLabel, "%s SleepButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp->SleepButton);
wsprintfA(szLabel, "%s LidClose", szIndent);
DumpPowerActionPolicy( szLabel, &pspp->LidClose);
MYDBGPRINT(("%s LidOpenWake: %08X, %s", szIndent, pspp->LidOpenWake, lpszDebugPwrState[pspp->LidOpenWake]));
wsprintfA(szLabel, "%s Idle", szIndent);
DumpPowerActionPolicy( szLabel, &pspp->Idle);
MYDBGPRINT(("%s IdleTimeout: %08X", szIndent, pspp->IdleTimeout));
MYDBGPRINT(("%s IdleSensitivity: %08X", szIndent, pspp->IdleSensitivity));
MYDBGPRINT(("%s MinSleep: %08X, %s", szIndent, pspp->MinSleep, lpszDebugPwrState[pspp->MinSleep]));
MYDBGPRINT(("%s MaxSleep: %08X, %s", szIndent, pspp->MaxSleep, lpszDebugPwrState[pspp->MaxSleep]));
MYDBGPRINT(("%s ReducedLatencySleep: %08X, %s", szIndent, pspp->ReducedLatencySleep, lpszDebugPwrState[pspp->ReducedLatencySleep]));
MYDBGPRINT(("%s WinLogonFlags: %08X", szIndent, pspp->WinLogonFlags));
MYDBGPRINT(("%s DozeS4Timeout: %08X", szIndent, pspp->DozeS4Timeout));
MYDBGPRINT(("%s BroadcastCapacityResolution: %08X", szIndent, pspp->BroadcastCapacityResolution));
for (i = 0; i < NUM_DISCHARGE_POLICIES; i++) {
wsprintfA(szLabel, "%s DischargePolicy[%d]", szIndent, i);
DumpSystemPowerLevel( szLabel, &pspp->DischargePolicy[i]);
}
MYDBGPRINT(("%s VideoTimeout: %08X", szIndent, pspp->VideoTimeout));
MYDBGPRINT(("%s VideoDimDisplay: %08X", szIndent, pspp->VideoDimDisplay));
MYDBGPRINT(("%s SpindownTimeout: %08X", szIndent, pspp->SpindownTimeout));
MYDBGPRINT(("%s OptimizeForPower: %08X", szIndent, pspp->OptimizeForPower));
MYDBGPRINT(("%s FanThrottleTolerance: %08X", szIndent, pspp->FanThrottleTolerance));
MYDBGPRINT(("%s ForcedThrottle: %08X", szIndent, pspp->ForcedThrottle));
MYDBGPRINT(("%s MinThrottle: %08X", szIndent, pspp->MinThrottle));
wsprintfA(szLabel, "%s OverThrottled", szIndent);
DumpPowerActionPolicy( szLabel, &pspp->OverThrottled);
MYDBGPRINT(("\n\n"));
}
/*******************************************************************************
*
* DumpSystemPowerCapabilities
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
void DumpSystemPowerCapabilities(
LPSTR lpszLabel,
PSYSTEM_POWER_CAPABILITIES pspc
)
{
UINT i;
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
GetIndent(lpszLabel, szIndent);
MYDBGPRINT(("%s, SYSTEM_POWER_CAPABILITIES: %08X", lpszLabel, pspc));
MYDBGPRINT(("%s PowerButtonPresent: %08X", szIndent, pspc->PowerButtonPresent));
MYDBGPRINT(("%s SleepButtonPresent: %08X", szIndent, pspc->SleepButtonPresent));
MYDBGPRINT(("%s LidPresent: %08X", szIndent, pspc->LidPresent));
MYDBGPRINT(("%s SystemS1: %08X", szIndent, pspc->SystemS1));
MYDBGPRINT(("%s SystemS2: %08X", szIndent, pspc->SystemS2));
MYDBGPRINT(("%s SystemS3: %08X", szIndent, pspc->SystemS3));
MYDBGPRINT(("%s SystemS4: %08X", szIndent, pspc->SystemS4));
MYDBGPRINT(("%s SystemS5: %08X", szIndent, pspc->SystemS5));
MYDBGPRINT(("%s HiberFilePresent: %08X", szIndent, pspc->HiberFilePresent));
MYDBGPRINT(("%s ThermalControl: %08X", szIndent, pspc->ThermalControl));
MYDBGPRINT(("%s ProcessorThrottle: %08X", szIndent, pspc->ProcessorThrottle));
MYDBGPRINT(("%s ProcessorMinThrottle: %02X", szIndent, pspc->ProcessorMinThrottle));
MYDBGPRINT(("%s ProcessorMaxThrottle: %02X", szIndent, pspc->ProcessorMaxThrottle));
MYDBGPRINT(("%s VideoDimPresent: %08X", szIndent, pspc->VideoDimPresent));
MYDBGPRINT(("%s DiskSpinDown: %08X", szIndent, pspc->DiskSpinDown));
MYDBGPRINT(("%s SystemBatteriesPresent: %08X", szIndent, pspc->SystemBatteriesPresent));
MYDBGPRINT(("%s BatteriesAreShortTerm: %08X", szIndent, pspc->BatteriesAreShortTerm));
// Not implemented: BATTERY_REPORTING_SCALE BatteryScale[3];
MYDBGPRINT(("%s AcOnLineWake: %08X, %s", szIndent, pspc->AcOnLineWake, lpszDebugPwrState[pspc->AcOnLineWake]));
MYDBGPRINT(("%s SoftLidWake: %08X, %s", szIndent, pspc->SoftLidWake, lpszDebugPwrState[pspc->SoftLidWake]));
MYDBGPRINT(("%s RtcWake: %08X, %s", szIndent, pspc->RtcWake, lpszDebugPwrState[pspc->RtcWake]));
MYDBGPRINT(("%s MinDeviceWakeState: %08X, %s", szIndent, pspc->MinDeviceWakeState, lpszDebugPwrState[pspc->MinDeviceWakeState]));
MYDBGPRINT(("%s DefaultLowLatencyWake: %08X, %s", szIndent, pspc->DefaultLowLatencyWake, lpszDebugPwrState[pspc->DefaultLowLatencyWake]));
MYDBGPRINT(("\n\n"));
}
/*******************************************************************************
*
* DifSystemPowerPolicies
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
void DifSystemPowerPolicies(
LPSTR lpszLabel,
PSYSTEM_POWER_POLICY pspp1,
PSYSTEM_POWER_POLICY pspp2
)
{
UINT i;
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
if (!g_iShowValidationChanges) {
return;
}
if (memcmp(pspp1, pspp2, sizeof(SYSTEM_POWER_POLICY))) {
GetIndent(lpszLabel, szIndent);
MYDBGPRINT(("%s, spp1: %08X, spp2: %08X", lpszLabel, pspp1, pspp2));
if (pspp1->Revision != pspp2->Revision) {
MYDBGPRINT(("%s Revision, spp1: %08X, spp2: %08X", szIndent, pspp1->Revision, pspp2->Revision));
}
if (memcmp(&pspp1->PowerButton, &pspp2->PowerButton, sizeof(POWER_ACTION_POLICY))) {
wsprintfA(szLabel, "%s spp1, PowerButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp1->PowerButton);
wsprintfA(szLabel, "%s spp2, PowerButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp2->PowerButton);
}
if (memcmp(&pspp1->SleepButton, &pspp2->SleepButton, sizeof(POWER_ACTION_POLICY))) {
wsprintfA(szLabel, "%s spp1, SleepButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp1->SleepButton);
wsprintfA(szLabel, "%s spp2, SleepButton", szIndent);
DumpPowerActionPolicy( szLabel, &pspp2->SleepButton);
}
if (memcmp(&pspp1->LidClose, &pspp2->LidClose, sizeof(POWER_ACTION_POLICY))) {
wsprintfA(szLabel, "%s spp1, LidClose", szIndent);
DumpPowerActionPolicy( szLabel, &pspp1->LidClose);
wsprintfA(szLabel, "%s spp2, LidClose:", szIndent);
DumpPowerActionPolicy( szLabel, &pspp2->LidClose);
}
if (pspp1->LidOpenWake != pspp2->LidOpenWake) {
MYDBGPRINT(("%s spp1, LidOpenWake: %08X, %s", szIndent, pspp1->LidOpenWake, lpszDebugPwrState[pspp1->LidOpenWake]));
MYDBGPRINT(("%s spp2, LidOpenWake: %08X, %s", szIndent, pspp2->LidOpenWake, lpszDebugPwrState[pspp2->LidOpenWake]));
}
if (memcmp(&pspp1->Idle, &pspp2->Idle, sizeof(POWER_ACTION_POLICY))) {
wsprintfA(szLabel, "%s spp1, Idle", szIndent);
DumpPowerActionPolicy( szLabel, &pspp1->Idle);
wsprintfA(szLabel, "%s spp2, Idle", szIndent);
DumpPowerActionPolicy( szLabel, &pspp2->Idle);
}
if (pspp1->IdleTimeout != pspp2->IdleTimeout) {
MYDBGPRINT(("%s IdleTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->IdleTimeout, pspp2->IdleTimeout));
}
if (pspp1->IdleSensitivity != pspp2->IdleSensitivity) {
MYDBGPRINT(("%s IdleSensitivity, spp1: %08X, spp2: %08X", szIndent, pspp1->IdleSensitivity, pspp2->IdleSensitivity));
}
if (pspp1->MinSleep != pspp2->MinSleep) {
MYDBGPRINT(("%s MinSleep, spp1: %08X, %s", szIndent, pspp1->MinSleep, lpszDebugPwrState[pspp1->MinSleep]));
MYDBGPRINT(("%s MinSleep, spp2: %08X, %s", szIndent, pspp2->MinSleep, lpszDebugPwrState[pspp2->MinSleep]));
}
if (pspp1->MaxSleep != pspp2->MaxSleep) {
MYDBGPRINT(("%s MaxSleep, spp1: %08X, %s", szIndent, pspp1->MaxSleep, lpszDebugPwrState[pspp1->MaxSleep]));
MYDBGPRINT(("%s MaxSleep, spp2: %08X, %s", szIndent, pspp2->MaxSleep, lpszDebugPwrState[pspp2->MaxSleep]));
}
if (pspp1->ReducedLatencySleep != pspp2->ReducedLatencySleep) {
MYDBGPRINT(("%s ReducedLatencySleep, spp1: %08X, %s", szIndent, pspp1->ReducedLatencySleep, lpszDebugPwrState[pspp1->ReducedLatencySleep]));
MYDBGPRINT(("%s ReducedLatencySleep, spp2: %08X, %s", szIndent, pspp2->ReducedLatencySleep, lpszDebugPwrState[pspp2->ReducedLatencySleep]));
}
if (pspp1->WinLogonFlags != pspp2->WinLogonFlags) {
MYDBGPRINT(("%s WinLogonFlags, spp1: %08X, spp2: %08X", szIndent, pspp1->WinLogonFlags, pspp2->WinLogonFlags));
}
if (pspp1->DozeS4Timeout != pspp2->DozeS4Timeout) {
MYDBGPRINT(("%s DozeS4Timeout, spp1: %08X, spp2: %08X", szIndent, pspp1->DozeS4Timeout, pspp2->DozeS4Timeout));
}
if (pspp1->BroadcastCapacityResolution != pspp2->BroadcastCapacityResolution) {
MYDBGPRINT(("%s BroadcastCapacityResolution, spp1: %08X, spp2: %08X", szIndent, pspp1->BroadcastCapacityResolution, pspp2->BroadcastCapacityResolution));
}
for (i = 0; i < NUM_DISCHARGE_POLICIES; i++) {
if (memcmp(&(pspp1->DischargePolicy[i]), &(pspp2->DischargePolicy[i]), sizeof(SYSTEM_POWER_LEVEL))) {
wsprintfA(szLabel, "%s DischargePolicy[%d], spp1:", szIndent, i);
DumpSystemPowerLevel( szLabel, &pspp1->DischargePolicy[i]);
wsprintfA(szLabel, "%s DischargePolicy[%d], spp2:", szIndent, i);
DumpSystemPowerLevel( szLabel, &pspp2->DischargePolicy[i]);
}
}
if (pspp1->VideoTimeout != pspp2->VideoTimeout) {
MYDBGPRINT(("%s VideoTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->VideoTimeout, pspp2->VideoTimeout));
}
if (pspp1->VideoDimDisplay != pspp2->VideoDimDisplay) {
MYDBGPRINT(("%s VideoDimDisplay, spp1: %08X, spp2: %08X", szIndent, pspp1->VideoDimDisplay, pspp2->VideoDimDisplay));
}
if (pspp1->SpindownTimeout != pspp2->SpindownTimeout) {
MYDBGPRINT(("%s SpindownTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->SpindownTimeout, pspp2->SpindownTimeout));
}
if (pspp1->OptimizeForPower != pspp2->OptimizeForPower) {
MYDBGPRINT(("%s OptimizeForPower, spp1: %08X, spp2: %08X", szIndent, pspp1->OptimizeForPower, pspp2->OptimizeForPower));
}
if (pspp1->FanThrottleTolerance != pspp2->FanThrottleTolerance) {
MYDBGPRINT(("%s FanThrottleTolerance, spp1: %08X, spp2: %08X", szIndent, pspp1->FanThrottleTolerance, pspp2->FanThrottleTolerance));
}
if (pspp1->ForcedThrottle != pspp2->ForcedThrottle) {
MYDBGPRINT(("%s ForcedThrottle, spp1: %08X, spp2: %08X", szIndent, pspp1->ForcedThrottle, pspp2->ForcedThrottle));
}
if (pspp1->MinThrottle != pspp2->MinThrottle) {
MYDBGPRINT(("%s MinThrottle, spp1: %08X, spp2: %08X", szIndent, pspp1->MinThrottle, pspp2->MinThrottle));
}
if (memcmp(&pspp1->OverThrottled, &pspp2->OverThrottled, sizeof(POWER_ACTION_POLICY))) {
wsprintfA(szLabel, "%s spp1, OverThrottled", szIndent);
DumpPowerActionPolicy( szLabel, &pspp1->OverThrottled);
wsprintfA(szLabel, "%s spp2, OverThrottled", szIndent);
DumpPowerActionPolicy( szLabel, &pspp2->OverThrottled);
}
MYDBGPRINT(("\n\n"));
}
}
#endif