archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
2 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/sdktools/dumppo/dumppo.c

1399 lines
40 KiB
Raw Blame History

/*****************************************************************/
/** Microsoft LAN Manager **/
/** Copyright(c) Microsoft Corp., 1988-1991 **/
/*****************************************************************/
#include <stdio.h>
#include <process.h>
#include <setjmp.h>
#include <stdlib.h>
#include <time.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
PROCESSOR_POWER_POLICY PAc, PDc, PCurrent;
SYSTEM_POWER_POLICY Ac, Dc, Current;
SYSTEM_POWER_CAPABILITIES Cap;
SYSTEM_POWER_STATUS PS;
ADMINISTRATOR_POWER_POLICY Admin;
SYSTEM_BATTERY_STATE Batt;
typedef
VOID
(*PCUR_PRINT)(
IN PVOID Context
);
typedef
VOID
(*PCUR_ASSIGN)(
PUCHAR Variable,
PUCHAR Value
);
ULONG CurType;
POWER_INFORMATION_LEVEL CurInfo;
PVOID CurContext;
ULONG CurContextSize;
PCUR_PRINT CurPrint;
PCUR_ASSIGN CurAssign;
PUCHAR CurDesc;
PUCHAR CurValue;
BOOLEAN ItemUpdated;
BOOLEAN CurValueIsNumeric;
BOOLEAN Verbose1;
BOOLEAN Verbose2;
PUCHAR szBool[] = { "FALSE", "TRUE" };
typedef struct {
ULONG Flags;
PUCHAR String;
} DEFBITS, *PDEFBITS;
DEFBITS ActFlags[] = {
POWER_ACTION_QUERY_ALLOWED, "QueryApps",
POWER_ACTION_UI_ALLOWED, "UIAllowed",
POWER_ACTION_OVERRIDE_APPS, "OverrideApps",
POWER_ACTION_DISABLE_WAKES, "DisableWakes",
POWER_ACTION_CRITICAL, "Critical",
0, NULL
};
DEFBITS PsBatteryFlagBits[] = {
BATTERY_FLAG_HIGH, "high",
BATTERY_FLAG_LOW, "low",
BATTERY_FLAG_CRITICAL, "critical",
BATTERY_FLAG_CHARGING, "charing",
0, NULL
};
PUCHAR
ActionS(
IN POWER_ACTION Act
)
{
static char line[50];
PCHAR p;
switch (Act) {
case PowerActionNone: p = "None"; break;
case PowerActionSleep: p = "Sleep"; break;
case PowerActionHibernate: p = "Hibernate"; break;
case PowerActionShutdown: p = "Shutdown"; break;
case PowerActionShutdownReset: p = "ShutdownReset"; break;
case PowerActionShutdownOff: p = "ShutdownOff"; break;
default:
sprintf(line, "Unknown action %x", Act);
p = line;
break;
}
return p;
}
PUCHAR
SysPower(
IN SYSTEM_POWER_STATE State
)
{
static char line[50];
PCHAR p;
switch (State) {
case PowerSystemUnspecified: p = "Unspecified"; break;
case PowerSystemWorking: p = "Working"; break;
case PowerSystemSleeping1: p = "S1"; break;
case PowerSystemSleeping2: p = "S2"; break;
case PowerSystemSleeping3: p = "S3"; break;
case PowerSystemHibernate: p = "S4 - hibernate"; break;
case PowerSystemShutdown: p = "Shutdown"; break;
default:
sprintf(line, "Unknown power state %x", State);
p = line;
break;
}
return p;
}
PUCHAR
DynamicThrottle(
IN UCHAR Throttle
)
{
static char line[50];
PCHAR p;
switch (Throttle) {
case PO_THROTTLE_NONE: p = "None"; break;
case PO_THROTTLE_CONSTANT: p = "Constant"; break;
case PO_THROTTLE_DEGRADE: p = "Degrade"; break;
case PO_THROTTLE_ADAPTIVE: p = "Adaptive"; break;
default:
sprintf(line,"Unknown Dynamic Throttle state %x", Throttle);
p = line;
break;
}
return p;
}
PUCHAR
MicroSeconds(
IN ULONG Time
)
{
static char line[256];
PCHAR p;
ULONG MicroSeconds;
ULONG MilliSeconds;
ULONG Seconds;
ULONG Minutes;
ULONG Hours;
ULONG Days;
MicroSeconds = Time % 1000;
MilliSeconds = Time / 1000;
Seconds = MilliSeconds / 1000;
MilliSeconds = MilliSeconds % 1000;
Minutes = Seconds / 60;
Seconds = Seconds % 60;
Hours = Minutes / 60;
Minutes = Minutes % 60;
Days = Hours / 24;
Hours = Hours % 24;
if (Hours) {
sprintf(
line,
"%d [%2d:%2d %ds %dms %dus]",
Time,
Hours,
Minutes,
Seconds,
MilliSeconds,
MicroSeconds
);
} else if (Minutes) {
sprintf(
line,
"%d [0:%2d %ds %dms %dus]",
Time,
Minutes,
Seconds,
MilliSeconds,
MicroSeconds
);
} else if (Seconds) {
sprintf(
line,
"%d [%ds %dms %dus]",
Time,
Seconds,
MilliSeconds,
MicroSeconds
);
} else if (MilliSeconds) {
sprintf(
line,
"%d [%dms %dus]",
Time,
MilliSeconds,
MicroSeconds
);
} else {
sprintf(
line,
"%d [%dus]",
Time,
MicroSeconds
);
}
p = line;
return p;
}
VOID
GetBits (
IN PUCHAR Dest,
IN ULONG Flags,
IN PDEFBITS DefBits
)
{
UCHAR c;
ULONG i;
c = 0;
*Dest = 0;
for (i=0; DefBits[i].Flags; i++) {
if (Flags & DefBits[i].Flags) {
if (c) {
*Dest = c;
Dest += 1;
}
strcpy(Dest, DefBits[i].String);
Dest += strlen(DefBits[i].String);
c = '|';
}
}
}
VOID
PrintPowerStatus (
VOID
)
{
ULONG i;
PUCHAR Ls;
UCHAR Bf[200];
switch (PS.ACLineStatus) {
case AC_LINE_OFFLINE: Ls = "off line"; break;
case AC_LINE_ONLINE: Ls = "on line"; break;
case AC_LINE_BACKUP_POWER: Ls = "backup power"; break;
case AC_LINE_UNKNOWN: Ls = "unknown"; break;
default: Ls = "**invalid**"; break;
}
strcpy (Bf, "unkown");
if (PS.BatteryFlag != BATTERY_FLAG_UNKNOWN) {
GetBits(Bf, PS.BatteryFlag, PsBatteryFlagBits);
}
printf ("Win32 System power status\n"
"AC line status..........: %s\n", Ls);
printf ("Battery flag............: %s\n", Bf);
printf ("Battery life percent....: %d\n", PS.BatteryLifePercent);
printf ("Battery full life time..: %d\n\n", PS.BatteryFullLifeTime);
}
VOID
PrintBattStatus (
VOID
)
{
ULONG i;
PUCHAR Ls;
UCHAR Bf[200];
printf ("AC on line..............: %s\n", szBool[Batt.AcOnLine]);
printf ("Battery present ........: %s\n", szBool[Batt.BatteryPresent]);
printf ("Charging................: %s\n", szBool[Batt.Charging]);
printf ("Discharging.............: %s\n", szBool[Batt.Discharging]);
printf ("Max Capacity............: %d\n", Batt.MaxCapacity);
printf ("Remaining Capacity......: %d", Batt.RemainingCapacity);
if (Batt.MaxCapacity) {
printf (" %d%%\n", Batt.RemainingCapacity * 100 / Batt.MaxCapacity);
} else {
printf (" (divide by zero)%%\n");
}
printf ("Rate....................: %d\n", Batt.Rate);
printf ("Estimated time..........: %d\n", Batt.EstimatedTime);
printf ("Default alert 1 & 2.....: %d %d\n\n",Batt.DefaultAlert1, Batt.DefaultAlert2);
}
BOOLEAN
streql (
PUCHAR p1,
PUCHAR p2
)
{
return strcmp(p1, p2) == 0;
}
PUCHAR
_strtok (
PUCHAR Start
)
{
static PUCHAR Location;
PUCHAR p;
if (Start) {
Location = Start;
}
for (p = Location; *p && *p <'a' && *p >'z'; p++) ;
if (!*p) {
return NULL;
}
Start = p;
for (; *p && *p >= 'a' && *p <= 'z'; p++) ;
if (*p) {
*p++ = 0;
}
Location = p;
return Start;
}
VOID
PrintCap (
PVOID Context
)
{
ULONG i;
puts ("System power capabilties");
printf ("Power Button Present....: %s\n", szBool[Cap.PowerButtonPresent]);
printf ("Sleep Button Present....: %s\n", szBool[Cap.SleepButtonPresent]);
printf ("Lid Present.............: %s\n", szBool[Cap.LidPresent]);
printf ("System states supported.: %s%s%s%s%s\n",
Cap.SystemS1 ? "S1 " : "",
Cap.SystemS2 ? "S2 " : "",
Cap.SystemS3 ? "S3 " : "",
Cap.SystemS4 ? "S4 " : "",
Cap.SystemS5 ? "S5 " : ""
);
printf ("Hiber file reserved.....: %s\n", szBool[Cap.HiberFilePresent]);
printf ("Thermal control.........: %s\n", szBool[Cap.ThermalControl]);
printf ("CPU Throttle control....: %s\n", szBool[Cap.ProcessorThrottle]);
printf ("Processor min throttle..: %d\n", Cap.ProcessorMinThrottle);
printf ("Processor max throttle..: %d\n", Cap.ProcessorMaxThrottle);
printf ("Some disk will spindown.: %s\n", szBool[Cap.DiskSpinDown]);
printf ("System batteries present: %s %s\n",
szBool[Cap.SystemBatteriesPresent],
Cap.BatteriesAreShortTerm ? "- short term" : ""
);
printf ("System batteries scale..: ");
for (i=0; i<3; i++) {
printf ("(G:%d C:%d) ",
Cap.BatteryScale[i].Granularity,
Cap.BatteryScale[i].Capacity
);
}
printf ("\n"
"Ac on line wake ability.: %s\n", SysPower(Cap.AcOnLineWake));
printf ("Lid wake ability........: %s\n", SysPower(Cap.SoftLidWake));
printf ("RTC wake ability........: %s\n", SysPower(Cap.RtcWake));
printf ("Min device wake.........: %s\n", SysPower(Cap.MinDeviceWakeState));
printf ("Default low latency wake: %s\n\n", SysPower(Cap.DefaultLowLatencyWake));
}
PUCHAR
Action (
IN PBOOLEAN CapFlag,
IN PPOWER_ACTION_POLICY Act
)
{
static UCHAR text[200];
PUCHAR p;
UCHAR c;
ULONG i;
p = text;
if (CapFlag && !*CapFlag) {
strcpy(p, "Disabled ");
p += strlen("Disabled ");
}
strcpy(p, ActionS(Act->Action));
p+=strlen(ActionS(Act->Action));
if (Act->Action != PowerActionNone && Act->Flags) {
c = '(';
for (i=0; ActFlags[i].Flags; i++) {
if (Act->Flags & ActFlags[i].Flags) {
p += sprintf (p, "%c%s", c, ActFlags[i].String);
c = '|';
}
}
p += sprintf (p, ")");
}
if (Act->EventCode) {
p += sprintf (p, "-Code=%x", Act->EventCode);
}
return text;
}
VOID
SetAction (
IN PPOWER_ACTION_POLICY Action
)
{
PUCHAR p;
POWER_ACTION Act;
ULONG Flags;
Flags = 0;
p = _strtok (CurValue);
if (streql(p, "none")) { Act = PowerActionNone;
} else if (streql(p, "sleep")) { Act = PowerActionSleep;
} else if (streql(p, "hiber")) { Act = PowerActionHibernate;
} else if (streql(p, "shutdown")) { Act = PowerActionShutdown;
} else if (streql(p, "shutdownreset")) { Act = PowerActionShutdownReset;
} else if (streql(p, "shutdownoff")) { Act = PowerActionShutdownOff;
} else {
printf ("Unknown power action '%s'.\n", p);
puts ("use: doze, sleep, shutdown, shutdownreset, shutdownoff");
exit (1);
}
while (p = _strtok(NULL)) {
if (streql(p, "qapp")) { Flags |= POWER_ACTION_QUERY_ALLOWED;
} else if (streql(p, "ui")) { Flags |= POWER_ACTION_UI_ALLOWED;
} else if (streql(p, "override")) { Flags |= POWER_ACTION_OVERRIDE_APPS;
} else if (streql(p, "disablewake")) { Flags |= POWER_ACTION_DISABLE_WAKES;
} else if (streql(p, "critical")) { Flags |= POWER_ACTION_CRITICAL;
} else {
printf ("Unknown power action '%s'.\n", p);
puts ("use: qapp, io, override, disablewake, critical");
exit (1);
}
}
Action->Action = Act;
Action->Flags = Flags;
}
VOID
SetSysPower (
IN PSYSTEM_POWER_STATE SysPower
)
{
PUCHAR p;
p = CurValue;
if (streql(p, "s0")) { *SysPower = PowerSystemWorking;
} else if (streql(p, "s1")) { *SysPower = PowerSystemSleeping1;
} else if (streql(p, "s2")) { *SysPower = PowerSystemSleeping2;
} else if (streql(p, "s3")) { *SysPower = PowerSystemSleeping3;
} else if (streql(p, "s4")) { *SysPower = PowerSystemHibernate;
} else {
printf ("Unknown system power state '%s'. Use S0,S1,S2,S3 or S4\n", p);
exit (1);
}
}
VOID
SetPolicyCount(
IN PULONG Variable
)
{
ULONG local;
if (!CurValueIsNumeric) {
printf("'%s' is not numeric\n", CurValue);
exit(1);
}
local = atol(CurValue);
if (local > 3) {
puts("PolicyCount can only be in the range 0 to 3\n");
exit(1);
}
*Variable = local;
}
VOID
SetDynamicThrottle(
IN PUCHAR Variable
)
{
ULONG local;
PUCHAR p;
p = CurValue;
if (streql(p,"none")) { *Variable = PO_THROTTLE_NONE;
} else if (streql(p,"constant")) { *Variable = PO_THROTTLE_CONSTANT;
} else if (streql(p,"degrade")) { *Variable = PO_THROTTLE_DEGRADE;
} else if (streql(p,"degraded")) { *Variable = PO_THROTTLE_DEGRADE;
} else if (streql(p,"adaptive")) { *Variable = PO_THROTTLE_ADAPTIVE;
} else {
printf("Unknown Dynamic Throttle state %s\n", CurValue);
exit(1);
}
}
VOID
SetCStates(
IN PPROCESSOR_POWER_POLICY Pol
)
{
PUCHAR p;
p = CurValue;
if (streql(p,"true")) {
Pol->DisableCStates = 1;
} else {
Pol->DisableCStates = 0;
}
}
VOID
SetPercentage (
IN PUCHAR Variable
)
{
PUCHAR p;
if (!CurValueIsNumeric) {
for (p = CurValue; *p; p++) {
if (*p == '%') {
*p = '\0';
}
}
CurValueIsNumeric = TRUE;
for (p = CurValue; *p; p++) {
if (*p < '0' || *p > '9') {
CurValueIsNumeric = FALSE;
}
}
if (!CurValueIsNumeric) {
printf ("'%s' is not numeric\n", CurValue);
exit (1);
}
}
*Variable = (UCHAR) atol(CurValue);
}
VOID
SetValue (
IN PULONG Variable
)
{
if (!CurValueIsNumeric) {
printf ("'%s' is not numeric\n", CurValue);
exit (1);
}
*Variable = atol(CurValue);
}
VOID
SetBool (
IN PBOOLEAN Variable
)
{
BOOLEAN State;
State = 99;
if (CurValueIsNumeric) {
State = (BOOLEAN)atol(CurValue);
} else {
if (streql(CurValue, "true")) { State = TRUE;
} else if (streql(CurValue, "false")) { State = FALSE;
}
}
if (State != FALSE && State != TRUE) {
printf ("'%s' is not boolean\n", CurValue);
exit (1);
}
*Variable = State;
}
VOID
SetField(
IN PPROCESSOR_POWER_POLICY Pol,
IN ULONG Index,
IN PUCHAR What
)
{
BOOLEAN State;
State = 99;
if (CurValueIsNumeric) {
State = (BOOLEAN)atol(CurValue);
} else {
if (streql(CurValue, "true")) { State = TRUE;
} else if (streql(CurValue, "false")) { State = FALSE;
}
}
if (State != FALSE && State != TRUE) {
printf ("'%s' is not boolean\n", CurValue);
exit (1);
}
if (streql(What,"allowpromotion")) { Pol->Policy[Index].AllowPromotion = State;
} else if (streql(What,"allowdemotion")) { Pol->Policy[Index].AllowDemotion = State;
}
}
VOID
PrintPol (
IN PSYSTEM_POWER_POLICY Pol
)
{
BOOLEAN AnySleep;
ULONG i;
UCHAR text[200];
PUCHAR p;
if (Pol->Revision != 1) {
puts ("** revision not 1**");
}
AnySleep = Cap.SystemS1 || Cap.SystemS2 || Cap.SystemS3 || Cap.SystemS4;
printf ("Power button.........: %s\n", Action(&Cap.PowerButtonPresent, &Pol->PowerButton));
printf ("Sleep button.........: %s\n", Action(&Cap.SleepButtonPresent, &Pol->SleepButton));
printf ("Lid close............: %s\n", Action(&Cap.LidPresent, &Pol->LidClose));
printf ("Lid open wake........: %s\n", SysPower(Pol->LidOpenWake));
printf ("Idle.................: %s\n", Action(&AnySleep, &Pol->Idle));
printf ("Settings.............: Timeout=%d, Sensitivity=%d\n",
Pol->IdleTimeout,
Pol->IdleSensitivity
);
printf ("Min sleep state......: %s\n", SysPower(Pol->MinSleep));
printf ("Max sleep state......: %s\n", SysPower(Pol->MaxSleep));
printf ("Reduced latency.sleep: %s\n", SysPower(Pol->ReducedLatencySleep));
printf ("WinLogonFlags........: %x\n", Pol->WinLogonFlags);
printf ("DynamicThrottle......: %s\n", DynamicThrottle(Pol->DynamicThrottle));
printf ("Doze S4 timeout......: %d\n", Pol->DozeS4Timeout);
printf ("Battery broadcast res: %d\n", Pol->BroadcastCapacityResolution);
for (i=0; i < NUM_DISCHARGE_POLICIES; i++) {
printf ("Battery discharge %d..: ", i);
p = "Disabled";
if (!Cap.SystemBatteriesPresent && Pol->DischargePolicy[i].Enable) {
p = "No battery, but enable is set";
}
if (Cap.SystemBatteriesPresent && Pol->DischargePolicy[i].Enable) {
sprintf (text, "%d, %s, Min=%s",
Pol->DischargePolicy[i].BatteryLevel,
Action (NULL, &Pol->DischargePolicy[i].PowerPolicy),
SysPower(Pol->DischargePolicy[i].MinSystemState)
);
p = text;
}
printf ("%s\n", p);
}
printf ("Video timeout.......: %d\n", Pol->VideoTimeout);
printf ("Hard disk timeout....: %d\n", Pol->SpindownTimeout);
printf ("Optimize for power...: %s\n", szBool[Pol->OptimizeForPower]);
printf ("Fan throttle toler...: %d\n", Pol->FanThrottleTolerance);
printf ("Forced throttle......: %d%% %s\n",
Pol->ForcedThrottle,
Pol->ForcedThrottle == 100 ? "(off)" : "(on)"
);
printf ("Min throttle.........: %d%%\n", Pol->MinThrottle);
printf ("Over throttle act....: %s\n", Action (NULL, &Pol->OverThrottled));
printf ("\n");
}
VOID
PrintPPol (
IN PPROCESSOR_POWER_POLICY Pol
)
{
ULONG i;
UCHAR text[200];
PUCHAR p;
if (Pol->Revision != 1) {
puts ("** revision not 1**");
}
printf ("Dynamic Throttle.....: %s\n", DynamicThrottle(Pol->DynamicThrottle) );
printf ("Disable CStates......: %s\n", szBool[Pol->DisableCStates] );
printf ("\n");
for (i = 0; i < Pol->PolicyCount; i++) {
printf ("C%x Processor Power Policy\n", (i+1) );
printf (" Allow Demotion....: %s\n", szBool[Pol->Policy[i].AllowDemotion]);
printf (" Allow Promotion...: %s\n", szBool[Pol->Policy[i].AllowPromotion]);
printf (" Demote Percent....: %d%%\n", Pol->Policy[i].DemotePercent);
printf (" Promote Percent...: %d%%\n", Pol->Policy[i].PromotePercent);
printf (" Demote Limit......: %s\n", MicroSeconds(Pol->Policy[i].DemoteLimit) );
printf (" Promote Limit.....: %s\n", MicroSeconds(Pol->Policy[i].PromoteLimit) );
printf (" Time Check........: %s\n", MicroSeconds(Pol->Policy[i].TimeCheck) );
printf ("\n");
}
printf ("\n");
}
VOID
PrintAdmin (
PVOID Context
)
{
printf ("Min sleep state......: %s\n", SysPower(Admin.MinSleep));
printf ("Max sleep state......: %s\n", SysPower(Admin.MaxSleep));
printf ("Min video timeout....: %d\n", Admin.MinVideoTimeout);
printf ("Max video timeout....: %d\n", Admin.MaxVideoTimeout);
printf ("Min spindown timeout.: %d\n", Admin.MinSpindownTimeout);
printf ("Max spindown timeout.: %d\n", Admin.MaxSpindownTimeout);
}
VOID
AssignSetting (
PUCHAR Variable,
PUCHAR Value
)
{
PSYSTEM_POWER_POLICY Pol;
PUCHAR p;
if (!CurContext) {
puts(
"must select one of:\n"
" ac - the system power policy while on AC\n"
" dc - the system power policy while on DC\n"
" pac - the processor power policy while on AC\n"
" pdc - the processor power policy while on DC\n"
" cap - the system capabilities\n"
" admin - the admin policy\n"
"before assigning settings"
);
exit (1);
}
CurValue = Value;
if (!*CurValue) {
printf ("null settings not allowed\n");
exit (1);
}
CurValueIsNumeric = TRUE;
for (p = Value; *p; p++) {
if (*p < '0' || *p > '9') {
CurValueIsNumeric = FALSE;
}
}
ItemUpdated = TRUE;
CurAssign (Variable, Value);
}
VOID
AssignPolicySetting (
PUCHAR Variable,
PUCHAR Value
)
{
PSYSTEM_POWER_POLICY Pol;
Pol = (PSYSTEM_POWER_POLICY) CurContext;
// set policy
if (streql(Variable, "pbutt")) { SetAction(&Pol->PowerButton);
} else if (streql(Variable, "sbutt")) { SetAction(&Pol->SleepButton);
} else if (streql(Variable, "lidclose")) { SetAction(&Pol->LidClose);
} else if (streql(Variable, "idle")) { SetAction(&Pol->Idle);
} else if (streql(Variable, "idlesense")) { SetValue((PULONG)&Pol->IdleSensitivity);
} else if (streql(Variable, "idletimeout")) { SetValue(&Pol->IdleTimeout);
} else if (streql(Variable, "minsleep")) { SetSysPower(&Pol->MinSleep);
} else if (streql(Variable, "maxsleep")) { SetSysPower(&Pol->MaxSleep);
} else if (streql(Variable, "reducedsleep")) { SetSysPower(&Pol->ReducedLatencySleep);
} else if (streql(Variable, "s4timeout")) { SetValue(&Pol->DozeS4Timeout);
} else if (streql(Variable, "videotimeout")) { SetValue(&Pol->VideoTimeout);
} else if (streql(Variable, "disktimeout")) { SetValue(&Pol->SpindownTimeout);
} else if (streql(Variable, "optpower")) { SetBool(&Pol->OptimizeForPower);
} else if (streql(Variable, "fantol")) { SetValue((PULONG)&Pol->FanThrottleTolerance);
} else if (streql(Variable, "minthrot")) { SetValue((PULONG)&Pol->MinThrottle);
} else if (streql(Variable, "forcethrot")) { SetValue((PULONG)&Pol->ForcedThrottle);
} else if (streql(Variable, "overthrot")) { SetAction(&Pol->OverThrottled);
} else {
puts (
"Variable not:\n"
" pbutt, sbutt, lidclose\n"
" idle, idlesense, idletime\n"
" minsleep, maxsleep, reducedsleep, s4timeout\n"
" videotimeout, disktimeout, optpower\n"
" optpower, fantol, minthrot, forcethrot, overthrot"
);
exit (1);
}
}
VOID
AssignPPolicySetting (
PUCHAR Variable,
PUCHAR Value
)
{
PPROCESSOR_POWER_POLICY Pol;
Pol = (PPROCESSOR_POWER_POLICY) CurContext;
if (streql(Variable,"policycount")) { SetPolicyCount(&(Pol->PolicyCount));
} else if (streql(Variable,"dynamicthrottle")) { SetDynamicThrottle(&(Pol->DynamicThrottle));
} else if (streql(Variable,"disablecstates")) { SetCStates(Pol);
} else if (streql(Variable,"c1allowpromotion")) { SetField(Pol,0,"allowpromotion");
} else if (streql(Variable,"c1allowdemotion")) { SetField(Pol,0,"allowdemotion");
} else if (streql(Variable,"c1demotepercent")) { SetPercentage(&(Pol->Policy[0].DemotePercent));
} else if (streql(Variable,"c1promotepercent")) { SetPercentage(&(Pol->Policy[0].PromotePercent));
} else if (streql(Variable,"c1demotelimit")) { SetValue(&(Pol->Policy[0].DemoteLimit));
} else if (streql(Variable,"c1promotelimit")) { SetValue(&(Pol->Policy[0].PromoteLimit));
} else if (streql(Variable,"c1timecheck")) { SetValue(&(Pol->Policy[0].TimeCheck));
} else if (streql(Variable,"c2allowpromotion")) { SetField(Pol,1,"allowpromotion");
} else if (streql(Variable,"c2allowdemotion")) { SetField(Pol,1,"allowdemotion");
} else if (streql(Variable,"c2demotepercent")) { SetPercentage(&(Pol->Policy[1].DemotePercent));
} else if (streql(Variable,"c2promotepercent")) { SetPercentage(&(Pol->Policy[1].PromotePercent));
} else if (streql(Variable,"c2demotelimit")) { SetValue(&(Pol->Policy[1].DemoteLimit));
} else if (streql(Variable,"c2promotelimit")) { SetValue(&(Pol->Policy[1].PromoteLimit));
} else if (streql(Variable,"c2timecheck")) { SetValue(&(Pol->Policy[1].TimeCheck));
} else if (streql(Variable,"c3allowpromotion")) { SetField(Pol,2,"allowpromotion");
} else if (streql(Variable,"c3allowdemotion")) { SetField(Pol,2,"allowdemotion");
} else if (streql(Variable,"c3demotepercent")) { SetPercentage(&(Pol->Policy[2].DemotePercent));
} else if (streql(Variable,"c3promotepercent")) { SetPercentage(&(Pol->Policy[2].PromotePercent));
} else if (streql(Variable,"c3demotelimit")) { SetValue(&(Pol->Policy[2].DemoteLimit));
} else if (streql(Variable,"c3promotelimit")) { SetValue(&(Pol->Policy[2].PromoteLimit));
} else if (streql(Variable,"c3timecheck")) { SetValue(&(Pol->Policy[2].TimeCheck));
} else {
puts(
"Variable not:\n"
" policycount - number of elements in policy\n"
" dynamicthrottle - which throttle policy to use\n"
" disablecstates - disable cstates if true\n"
" cXallowpromotion - allow promotion from state X\n"
" cXallowdemotion - allow demotion from state X\n"
" cXdemotepercent - set demote percent for state X\n"
" cXpromotepercent - set promote percent for state X\n"
" cXdemotelimit - set demote limit for state X\n"
" cXpromotelimit - set promote limit for state X\n"
" cXtimecheck - set time check interval for state X"
" where X = <1,2,3>\n"
);
exit(1);
}
}
VOID
AssignCurrentSetting(
PUCHAR Variable,
PUCHAR Value
)
{
if (CurInfo == ProcessorPowerPolicyCurrent) {
puts(
"PCurrent is only intended for use in displaying the current processor\n"
"power policy. You must use 'pac' or 'pdc' to actually set policy."
);
} else if (CurInfo == SystemPowerPolicyCurrent) {
puts(
"Current is only intended for use in displaying the current system\n"
"power policy. You muse use 'ac' or 'dc' to actually set policy."
);
} else {
puts(
"Unknown setting."
);
}
exit(1);
}
VOID
AssignAdminSetting (
PUCHAR Variable,
PUCHAR Value
)
{
if (streql(Variable, "minsleep")) { SetSysPower(&Admin.MinSleep);
} else if (streql(Variable, "maxsleep")) { SetSysPower(&Admin.MaxSleep);
} else if (streql(Variable, "minvideo")) { SetValue(&Admin.MinVideoTimeout);
} else if (streql(Variable, "maxvideo")) { SetValue(&Admin.MaxVideoTimeout);
} else if (streql(Variable, "mindisk")) { SetValue(&Admin.MinSpindownTimeout);
} else if (streql(Variable, "maxdisk")) { SetValue(&Admin.MaxSpindownTimeout);
} else {
puts(
"Variable not:\n"
" minsleep, maxsleep\n"
" minvideo, maxvideo, mindisk, maxdisk"
);
exit (1);
}
}
VOID
AssignCapSetting (
PUCHAR Variable,
PUCHAR Value
)
{
// set capability
if (streql(Variable, "pbutt")) { SetBool(&Cap.PowerButtonPresent);
} else if (streql(Variable, "sbutt")) { SetBool(&Cap.SleepButtonPresent);
} else if (streql(Variable, "lid")) { SetBool(&Cap.LidPresent);
} else if (streql(Variable, "s1")) { SetBool(&Cap.SystemS1);
} else if (streql(Variable, "s2")) { SetBool(&Cap.SystemS2);
} else if (streql(Variable, "s3")) { SetBool(&Cap.SystemS3);
} else if (streql(Variable, "s4")) { SetBool(&Cap.SystemS4);
} else if (streql(Variable, "s5")) { SetBool(&Cap.SystemS5);
} else if (streql(Variable, "batt")) { SetBool(&Cap.SystemBatteriesPresent);
} else if (streql(Variable, "shortterm")) { SetBool(&Cap.BatteriesAreShortTerm);
} else if (streql(Variable, "acwake")) { SetSysPower(&Cap.AcOnLineWake);
} else if (streql(Variable, "lidwake")) { SetSysPower(&Cap.SoftLidWake);
} else if (streql(Variable, "rtcwake")) { SetSysPower(&Cap.RtcWake);
} else if (streql(Variable, "lowlat")) { SetSysPower(&Cap.DefaultLowLatencyWake);
} else {
puts (
"Variable not:\n"
" pbutt, sbutt, lid, s1, s2, s3, s4, s5\n"
" batt, shortterm, acwake, lidwake, rtcwak, lowlat"
);
exit (1);
}
}
#define SEL_NONE 0
#define SEL_AC 1
#define SEL_DC 2
#define SEL_CAP 3
#define SEL_ADMIN 4
#define SEL_PAC 5
#define SEL_PDC 6
#define SEL_CURRENT 7
#define SEL_PCURRENT 8
VOID
SelectItem(
IN ULONG Type
)
{
NTSTATUS Status;
if (CurType) {
if (ItemUpdated) {
if (Verbose2) {
printf ("%s being set as:\n", CurDesc);
CurPrint (CurContext);
}
Status = NtPowerInformation (
CurInfo,
CurContext,
CurContextSize,
CurContext,
CurContextSize
);
if (!NT_SUCCESS(Status)) {
printf ("NtPowerInformation failed with %x\n", Status);
}
}
puts (CurDesc);
CurPrint (CurContext);
}
switch (Type) {
case SEL_NONE:
CurPrint = NULL;
CurAssign = NULL;
CurContext = NULL;
break;
case SEL_AC:
CurPrint = PrintPol;
CurInfo = SystemPowerPolicyAc;
CurContext = &Ac;
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
CurAssign = AssignPolicySetting;
CurDesc = "AC power policy";
break;
case SEL_DC:
CurPrint = PrintPol;
CurInfo = SystemPowerPolicyDc;
CurContext = &Dc;
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
CurAssign = AssignPolicySetting;
CurDesc = "DC power policy";
break;
case SEL_CURRENT:
CurPrint = PrintPol;
CurInfo = SystemPowerPolicyCurrent;
CurContext = &Current;
CurContextSize = sizeof(SYSTEM_POWER_POLICY);
CurAssign = AssignCurrentSetting;
CurDesc = "Current power policy";
break;
case SEL_PAC:
CurPrint = PrintPPol;
CurInfo = ProcessorPowerPolicyAc;
CurContext = &PAc;
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
CurAssign = AssignPPolicySetting;
CurDesc = "AC processor power policy";
break;
case SEL_PDC:
CurPrint = PrintPPol;
CurInfo = ProcessorPowerPolicyDc;
CurContext = &PDc;
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
CurAssign = AssignPPolicySetting;
CurDesc = "DC processor power policy";
break;
case SEL_PCURRENT:
CurPrint = PrintPPol;
CurInfo = ProcessorPowerPolicyCurrent;
CurContext = &PCurrent;
CurContextSize = sizeof(PROCESSOR_POWER_POLICY);
CurAssign = AssignCurrentSetting;
CurDesc = "Current processor power policy";
break;
case SEL_CAP:
CurPrint = PrintCap;
CurInfo = SystemPowerCapabilities,
CurContext = &Cap;
CurContextSize = sizeof(SYSTEM_POWER_CAPABILITIES);
CurAssign = AssignCapSetting;
CurDesc = "power capabilties";
break;
case SEL_ADMIN:
CurPrint = PrintAdmin;
CurInfo = AdministratorPowerPolicy;
CurContext = &Admin;
CurContextSize = sizeof(ADMINISTRATOR_POWER_POLICY);
CurAssign = AssignAdminSetting;
CurDesc = "Admin policy overrides";
break;
}
CurType = Type;
ItemUpdated = FALSE;
}
VOID
UpdateAdmin (
VOID
)
{
ADMINISTRATOR_POWER_POLICY AdminPolicy;
NTSTATUS Status;
Status = NtPowerInformation (
AdministratorPowerPolicy,
NULL,
0,
&AdminPolicy,
sizeof (AdminPolicy)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading admin policy %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
AdministratorPowerPolicy,
&AdminPolicy,
sizeof (AdminPolicy),
NULL,
0
);
if (!NT_SUCCESS(Status)) {
printf ("Error writing admin policy %x\n", Status);
exit (1);
}
}
VOID __cdecl
main (argc, argv)
int argc;
char *argv[];
{
NTSTATUS Status;
PUCHAR p, p1;
BOOLEAN Result;
HANDLE hToken;
TOKEN_PRIVILEGES tkp;
if (argc < 2) {
puts ("dumppo: cap ps bs admin ac dc current pac pdc pcurrent");
exit (1);
}
Status = NtPowerInformation (
SystemPowerCapabilities,
NULL,
0,
&Cap,
sizeof (Cap)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading power capabilities %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
AdministratorPowerPolicy,
NULL,
0,
&Admin,
sizeof (Admin)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading admin power overrides %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
SystemPowerPolicyAc,
NULL,
0,
&Ac,
sizeof (Ac)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading AC policies %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
SystemPowerPolicyDc,
NULL,
0,
&Dc,
sizeof (Dc)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading DC policies %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
SystemPowerPolicyCurrent,
NULL,
0,
&Current,
sizeof (Current)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading Current policies %x\n", Status);
exit (1);
}
Result = (BOOLEAN)GetSystemPowerStatus (&PS);
if (!Result) {
printf ("False returned from GetSystemPowerStatus %x\n", GetLastError());
exit (1);
}
Status = NtPowerInformation (
SystemBatteryState,
NULL,
0,
&Batt,
sizeof (Batt)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading system battery status %x\n", Status);
exit (1);
}
Status = NtPowerInformation (
ProcessorPowerPolicyAc,
NULL,
0,
&PAc,
sizeof (PAc)
);
if (!NT_SUCCESS(Status)) {
printf ("Error reading processor AC policy %x\n", Status);
exit (1);
}
Status = NtPowerInformation(
ProcessorPowerPolicyDc,
NULL,
0,
&PDc,
sizeof (PDc)
);
if (!NT_SUCCESS(Status)) {
printf("Error reading processor DC policy %x\n", Status);
exit (1);
}
Status = NtPowerInformation(
ProcessorPowerPolicyCurrent,
NULL,
0,
&PCurrent,
sizeof (PCurrent)
);
if (!NT_SUCCESS(Status)) {
printf("Error reading processor Current policy %x\n", Status);
exit (1);
}
//
// Upgrade premissions
//
OpenProcessToken (
GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken
);
LookupPrivilegeValue (
NULL,
SE_SHUTDOWN_NAME,
&tkp.Privileges[0].Luid
);
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges (
hToken,
FALSE,
&tkp,
0,
NULL,
0
);
//
// Process args
//
while (argc) {
argc--;
if (streql(*argv, "-v")) {
Verbose1 = TRUE;
}
if (streql(*argv, "-V")) {
Verbose1 = TRUE;
Verbose2 = TRUE;
}
for (p = *argv; *p; p++) {
if (*p >= 'A' && *p <= 'Z') {
*p += 'a' - 'A';
}
}
p = *argv;
argv += 1;
if (streql(p, "ac")) {
SelectItem(SEL_AC);
}
if (streql(p, "dc")) {
SelectItem(SEL_DC);
}
if (streql(p, "current")) {
SelectItem(SEL_CURRENT);
}
if (streql(p, "cap")) {
SelectItem(SEL_CAP);
}
if (streql(p, "ps")) {
SelectItem(SEL_NONE);
PrintPowerStatus ();
}
if (streql(p, "bs")) {
SelectItem(SEL_NONE);
PrintBattStatus();
}
if (streql(p, "admin")) {
SelectItem(SEL_ADMIN);
}
if (streql(p, "pdc")) {
SelectItem(SEL_PDC);
}
if (streql(p, "pac")) {
SelectItem(SEL_PAC);
}
if (streql(p, "pcurrent")) {
SelectItem(SEL_PCURRENT);
}
//
// Check if this is a assignment
//
for (p1=p; *p1; p1++) {
if (*p1 == '=') {
*p1 = 0;
AssignSetting (p, p1+1);
}
}
}
// flush
SelectItem(SEL_NONE);
}