07e92b7f9b836cf0726213139d576d574647e6d0
[reactos.git] / reactos / ntoskrnl / po / power.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/po/power.c
5 * PURPOSE: Power Manager
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Hervé Poussineau (hpoussin@reactos.com)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* GLOBALS *******************************************************************/
17
18 typedef struct _POWER_STATE_TRAVERSE_CONTEXT
19 {
20 SYSTEM_POWER_STATE SystemPowerState;
21 POWER_ACTION PowerAction;
22 PDEVICE_OBJECT PowerDevice;
23 } POWER_STATE_TRAVERSE_CONTEXT, *PPOWER_STATE_TRAVERSE_CONTEXT;
24
25 PDEVICE_NODE PopSystemPowerDeviceNode = NULL;
26 BOOLEAN PopAcpiPresent = FALSE;
27 POP_POWER_ACTION PopAction;
28 WORK_QUEUE_ITEM PopShutdownWorkItem;
29
30 /* PRIVATE FUNCTIONS *********************************************************/
31
32 static
33 NTSTATUS
34 NTAPI
35 PopRequestPowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject,
36 IN PIRP Irp,
37 IN PVOID Context)
38 {
39 PIO_STACK_LOCATION Stack;
40 PREQUEST_POWER_COMPLETE CompletionRoutine;
41 POWER_STATE PowerState;
42
43 Stack = IoGetCurrentIrpStackLocation(Irp);
44 CompletionRoutine = Context;
45
46 PowerState.DeviceState = (ULONG_PTR)Stack->Parameters.Others.Argument3;
47 CompletionRoutine(Stack->Parameters.Others.Argument1,
48 (UCHAR)(ULONG_PTR)Stack->Parameters.Others.Argument2,
49 PowerState,
50 Stack->Parameters.Others.Argument4,
51 &Irp->IoStatus);
52
53 IoSkipCurrentIrpStackLocation(Irp);
54 IoFreeIrp(Irp);
55 ObDereferenceObject(DeviceObject);
56
57 return STATUS_MORE_PROCESSING_REQUIRED;
58 }
59
60 VOID
61 NTAPI
62 PopCleanupPowerState(IN PPOWER_STATE PowerState)
63 {
64 //UNIMPLEMENTED;
65 }
66
67 NTSTATUS
68 PopSendQuerySystemPowerState(PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
69 {
70 KEVENT Event;
71 IO_STATUS_BLOCK IoStatusBlock;
72 PIO_STACK_LOCATION IrpSp;
73 PIRP Irp;
74 NTSTATUS Status;
75
76 KeInitializeEvent(&Event,
77 NotificationEvent,
78 FALSE);
79
80 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
81 DeviceObject,
82 NULL,
83 0,
84 NULL,
85 &Event,
86 &IoStatusBlock);
87 if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
88
89 IrpSp = IoGetNextIrpStackLocation(Irp);
90 IrpSp->MinorFunction = IRP_MN_QUERY_POWER;
91 IrpSp->Parameters.Power.Type = SystemPowerState;
92 IrpSp->Parameters.Power.State.SystemState = SystemState;
93 IrpSp->Parameters.Power.ShutdownType = PowerAction;
94
95 Status = PoCallDriver(DeviceObject, Irp);
96 if (Status == STATUS_PENDING)
97 {
98 KeWaitForSingleObject(&Event,
99 Executive,
100 KernelMode,
101 FALSE,
102 NULL);
103 Status = IoStatusBlock.Status;
104 }
105
106 return Status;
107 }
108
109 NTSTATUS
110 PopSendSetSystemPowerState(PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
111 {
112 KEVENT Event;
113 IO_STATUS_BLOCK IoStatusBlock;
114 PIO_STACK_LOCATION IrpSp;
115 PIRP Irp;
116 NTSTATUS Status;
117
118 KeInitializeEvent(&Event,
119 NotificationEvent,
120 FALSE);
121
122 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
123 DeviceObject,
124 NULL,
125 0,
126 NULL,
127 &Event,
128 &IoStatusBlock);
129 if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
130
131 IrpSp = IoGetNextIrpStackLocation(Irp);
132 IrpSp->MinorFunction = IRP_MN_SET_POWER;
133 IrpSp->Parameters.Power.Type = SystemPowerState;
134 IrpSp->Parameters.Power.State.SystemState = SystemState;
135 IrpSp->Parameters.Power.ShutdownType = PowerAction;
136
137 Status = PoCallDriver(DeviceObject, Irp);
138 if (Status == STATUS_PENDING)
139 {
140 KeWaitForSingleObject(&Event,
141 Executive,
142 KernelMode,
143 FALSE,
144 NULL);
145 Status = IoStatusBlock.Status;
146 }
147
148 return Status;
149 }
150
151 NTSTATUS
152 PopQuerySystemPowerStateTraverse(PDEVICE_NODE DeviceNode,
153 PVOID Context)
154 {
155 PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
156 NTSTATUS Status;
157
158 DPRINT("PopQuerySystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
159
160 if (DeviceNode == IopRootDeviceNode)
161 return STATUS_SUCCESS;
162
163 if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
164 return STATUS_SUCCESS;
165
166 Status = PopSendQuerySystemPowerState(DeviceNode->PhysicalDeviceObject,
167 PowerStateContext->SystemPowerState,
168 PowerStateContext->PowerAction);
169 if (!NT_SUCCESS(Status))
170 {
171 DPRINT1("Device '%wZ' failed IRP_MN_QUERY_POWER\n", &DeviceNode->InstancePath);
172 }
173
174 #if 0
175 return Status;
176 #else
177 return STATUS_SUCCESS;
178 #endif
179 }
180
181 NTSTATUS
182 PopSetSystemPowerStateTraverse(PDEVICE_NODE DeviceNode,
183 PVOID Context)
184 {
185 PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
186 NTSTATUS Status;
187
188 DPRINT("PopSetSystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
189
190 if (DeviceNode == IopRootDeviceNode)
191 return STATUS_SUCCESS;
192
193 if (DeviceNode->PhysicalDeviceObject == PowerStateContext->PowerDevice)
194 return STATUS_SUCCESS;
195
196 if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
197 return STATUS_SUCCESS;
198
199 Status = PopSendSetSystemPowerState(DeviceNode->PhysicalDeviceObject,
200 PowerStateContext->SystemPowerState,
201 PowerStateContext->PowerAction);
202 if (!NT_SUCCESS(Status))
203 {
204 DPRINT1("Device '%wZ' failed IRP_MN_SET_POWER\n", &DeviceNode->InstancePath);
205 }
206
207 #if 0
208 return Status;
209 #else
210 return STATUS_SUCCESS;
211 #endif
212 }
213
214 NTSTATUS
215 NTAPI
216 PopSetSystemPowerState(SYSTEM_POWER_STATE PowerState, POWER_ACTION PowerAction)
217 {
218 PDEVICE_OBJECT DeviceObject;
219 PDEVICE_OBJECT Fdo;
220 NTSTATUS Status;
221 DEVICETREE_TRAVERSE_CONTEXT Context;
222 POWER_STATE_TRAVERSE_CONTEXT PowerContext;
223
224 Status = IopGetSystemPowerDeviceObject(&DeviceObject);
225 if (!NT_SUCCESS(Status))
226 {
227 DPRINT1("No system power driver available\n");
228 Fdo = NULL;
229 }
230 else
231 {
232 Fdo = IoGetAttachedDeviceReference(DeviceObject);
233 if (Fdo == DeviceObject)
234 {
235 DPRINT("An FDO was not attached\n");
236 return STATUS_UNSUCCESSFUL;
237 }
238 }
239
240 /* Set up context */
241 PowerContext.PowerAction = PowerAction;
242 PowerContext.SystemPowerState = PowerState;
243 PowerContext.PowerDevice = Fdo;
244
245 /* Query for system power change */
246 IopInitDeviceTreeTraverseContext(&Context,
247 IopRootDeviceNode,
248 PopQuerySystemPowerStateTraverse,
249 &PowerContext);
250
251 Status = IopTraverseDeviceTree(&Context);
252 if (!NT_SUCCESS(Status))
253 {
254 DPRINT1("Query system power state failed; changing state anyway\n");
255 }
256
257 /* Set system power change */
258 IopInitDeviceTreeTraverseContext(&Context,
259 IopRootDeviceNode,
260 PopSetSystemPowerStateTraverse,
261 &PowerContext);
262
263 IopTraverseDeviceTree(&Context);
264
265 if (!PopAcpiPresent) return STATUS_NOT_IMPLEMENTED;
266
267 if (Fdo != NULL)
268 {
269 if (PowerAction != PowerActionShutdownReset)
270 PopSendSetSystemPowerState(Fdo, PowerState, PowerAction);
271
272 ObDereferenceObject(Fdo);
273 }
274
275 return Status;
276 }
277
278 BOOLEAN
279 NTAPI
280 INIT_FUNCTION
281 PoInitSystem(IN ULONG BootPhase)
282 {
283 PVOID NotificationEntry;
284 PCHAR CommandLine;
285 BOOLEAN ForceAcpiDisable = FALSE;
286
287 /* Check if this is phase 1 init */
288 if (BootPhase == 1)
289 {
290 /* Register power button notification */
291 IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
292 PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
293 (PVOID)&GUID_DEVICE_SYS_BUTTON,
294 IopRootDeviceNode->
295 PhysicalDeviceObject->DriverObject,
296 PopAddRemoveSysCapsCallback,
297 NULL,
298 &NotificationEntry);
299
300 /* Register lid notification */
301 IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
302 PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
303 (PVOID)&GUID_DEVICE_LID,
304 IopRootDeviceNode->
305 PhysicalDeviceObject->DriverObject,
306 PopAddRemoveSysCapsCallback,
307 NULL,
308 &NotificationEntry);
309 return TRUE;
310 }
311
312 /* Get the Command Line */
313 CommandLine = KeLoaderBlock->LoadOptions;
314
315 /* Upcase it */
316 _strupr(CommandLine);
317
318 /* Check for ACPI disable */
319 if (strstr(CommandLine, "NOACPI")) ForceAcpiDisable = TRUE;
320
321 if (ForceAcpiDisable)
322 {
323 /* Set the ACPI State to False if it's been forced that way */
324 PopAcpiPresent = FALSE;
325 }
326 else
327 {
328 /* Otherwise check if the LoaderBlock has a ACPI Table */
329 PopAcpiPresent = KeLoaderBlock->Extension->AcpiTable != NULL ? TRUE : FALSE;
330 }
331
332
333 /* Initialize volume support */
334 InitializeListHead(&PopVolumeDevices);
335 KeInitializeGuardedMutex(&PopVolumeLock);
336
337 /* Initialize support for dope */
338 KeInitializeSpinLock(&PopDopeGlobalLock);
339
340 /* Initialize support for shutdown waits and work-items */
341 PopInitShutdownList();
342
343 return TRUE;
344 }
345
346 VOID
347 NTAPI
348 PopPerfIdle(PPROCESSOR_POWER_STATE PowerState)
349 {
350 DPRINT1("PerfIdle function: %p\n", PowerState);
351 }
352
353 VOID
354 NTAPI
355 PopPerfIdleDpc(IN PKDPC Dpc,
356 IN PVOID DeferredContext,
357 IN PVOID SystemArgument1,
358 IN PVOID SystemArgument2)
359 {
360 /* Call the Perf Idle function */
361 PopPerfIdle(&((PKPRCB)DeferredContext)->PowerState);
362 }
363
364 VOID
365 FASTCALL
366 PopIdle0(IN PPROCESSOR_POWER_STATE PowerState)
367 {
368 /* FIXME: Extremly naive implementation */
369 HalProcessorIdle();
370 }
371
372 VOID
373 NTAPI
374 INIT_FUNCTION
375 PoInitializePrcb(IN PKPRCB Prcb)
376 {
377 /* Initialize the Power State */
378 RtlZeroMemory(&Prcb->PowerState, sizeof(Prcb->PowerState));
379 Prcb->PowerState.Idle0KernelTimeLimit = 0xFFFFFFFF;
380 Prcb->PowerState.CurrentThrottle = 100;
381 Prcb->PowerState.CurrentThrottleIndex = 0;
382 Prcb->PowerState.IdleFunction = PopIdle0;
383
384 /* Initialize the Perf DPC and Timer */
385 KeInitializeDpc(&Prcb->PowerState.PerfDpc, PopPerfIdleDpc, Prcb);
386 KeSetTargetProcessorDpc(&Prcb->PowerState.PerfDpc, Prcb->Number);
387 KeInitializeTimerEx(&Prcb->PowerState.PerfTimer, SynchronizationTimer);
388 }
389
390 /* PUBLIC FUNCTIONS **********************************************************/
391
392 /*
393 * @unimplemented
394 */
395 NTSTATUS
396 NTAPI
397 PoCancelDeviceNotify(IN PVOID NotifyBlock)
398 {
399 UNIMPLEMENTED;
400 return STATUS_NOT_IMPLEMENTED;
401 }
402
403 /*
404 * @unimplemented
405 */
406 NTSTATUS
407 NTAPI
408 PoRegisterDeviceNotify(OUT PVOID Unknown0,
409 IN ULONG Unknown1,
410 IN ULONG Unknown2,
411 IN ULONG Unknown3,
412 IN PVOID Unknown4,
413 IN PVOID Unknown5)
414 {
415 UNIMPLEMENTED;
416 return STATUS_NOT_IMPLEMENTED;
417 }
418
419 /*
420 * @unimplemented
421 */
422 VOID
423 NTAPI
424 PoShutdownBugCheck(IN BOOLEAN LogError,
425 IN ULONG BugCheckCode,
426 IN ULONG_PTR BugCheckParameter1,
427 IN ULONG_PTR BugCheckParameter2,
428 IN ULONG_PTR BugCheckParameter3,
429 IN ULONG_PTR BugCheckParameter4)
430 {
431 DPRINT1("PoShutdownBugCheck called\n");
432
433 /* FIXME: Log error if requested */
434 /* FIXME: Initiate a shutdown */
435
436 /* Bugcheck the system */
437 KeBugCheckEx(BugCheckCode,
438 BugCheckParameter1,
439 BugCheckParameter2,
440 BugCheckParameter3,
441 BugCheckParameter4);
442 }
443
444 /*
445 * @unimplemented
446 */
447 VOID
448 NTAPI
449 PoSetHiberRange(IN PVOID HiberContext,
450 IN ULONG Flags,
451 IN OUT PVOID StartPage,
452 IN ULONG Length,
453 IN ULONG PageTag)
454 {
455 UNIMPLEMENTED;
456 return;
457 }
458
459 /*
460 * @implemented
461 */
462 NTSTATUS
463 NTAPI
464 PoCallDriver(IN PDEVICE_OBJECT DeviceObject,
465 IN OUT PIRP Irp)
466 {
467 NTSTATUS Status;
468
469 /* Forward to Io -- FIXME! */
470 Status = IoCallDriver(DeviceObject, Irp);
471
472 /* Return status */
473 return Status;
474 }
475
476 /*
477 * @unimplemented
478 */
479 PULONG
480 NTAPI
481 PoRegisterDeviceForIdleDetection(IN PDEVICE_OBJECT DeviceObject,
482 IN ULONG ConservationIdleTime,
483 IN ULONG PerformanceIdleTime,
484 IN DEVICE_POWER_STATE State)
485 {
486 UNIMPLEMENTED;
487 return NULL;
488 }
489
490 /*
491 * @unimplemented
492 */
493 PVOID
494 NTAPI
495 PoRegisterSystemState(IN PVOID StateHandle,
496 IN EXECUTION_STATE Flags)
497 {
498 UNIMPLEMENTED;
499 return NULL;
500 }
501
502 /*
503 * @implemented
504 */
505 NTSTATUS
506 NTAPI
507 PoRequestPowerIrp(IN PDEVICE_OBJECT DeviceObject,
508 IN UCHAR MinorFunction,
509 IN POWER_STATE PowerState,
510 IN PREQUEST_POWER_COMPLETE CompletionFunction,
511 IN PVOID Context,
512 OUT PIRP *pIrp OPTIONAL)
513 {
514 PDEVICE_OBJECT TopDeviceObject;
515 PIO_STACK_LOCATION Stack;
516 PIRP Irp;
517
518 if (MinorFunction != IRP_MN_QUERY_POWER
519 && MinorFunction != IRP_MN_SET_POWER
520 && MinorFunction != IRP_MN_WAIT_WAKE)
521 return STATUS_INVALID_PARAMETER_2;
522
523 /* Always call the top of the device stack */
524 TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
525
526 Irp = IoAllocateIrp(TopDeviceObject->StackSize + 2, FALSE);
527 if (!Irp)
528 {
529 ObDereferenceObject(TopDeviceObject);
530 return STATUS_INSUFFICIENT_RESOURCES;
531 }
532
533 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
534 Irp->IoStatus.Information = 0;
535
536 IoSetNextIrpStackLocation(Irp);
537
538 Stack = IoGetNextIrpStackLocation(Irp);
539 Stack->Parameters.Others.Argument1 = DeviceObject;
540 Stack->Parameters.Others.Argument2 = (PVOID)(ULONG_PTR)MinorFunction;
541 Stack->Parameters.Others.Argument3 = (PVOID)(ULONG_PTR)PowerState.DeviceState;
542 Stack->Parameters.Others.Argument4 = Context;
543 Stack->DeviceObject = TopDeviceObject;
544 IoSetNextIrpStackLocation(Irp);
545
546 Stack = IoGetNextIrpStackLocation(Irp);
547 Stack->MajorFunction = IRP_MJ_POWER;
548 Stack->MinorFunction = MinorFunction;
549 if (MinorFunction == IRP_MN_WAIT_WAKE)
550 {
551 Stack->Parameters.WaitWake.PowerState = PowerState.SystemState;
552 }
553 else
554 {
555 Stack->Parameters.Power.Type = DevicePowerState;
556 Stack->Parameters.Power.State = PowerState;
557 }
558
559 if (pIrp != NULL)
560 *pIrp = Irp;
561
562 IoSetCompletionRoutine(Irp, PopRequestPowerIrpCompletion, CompletionFunction, TRUE, TRUE, TRUE);
563 PoCallDriver(TopDeviceObject, Irp);
564
565 /* Always return STATUS_PENDING. The completion routine
566 * will call CompletionFunction and complete the Irp.
567 */
568 return STATUS_PENDING;
569 }
570
571 /*
572 * @unimplemented
573 */
574 POWER_STATE
575 NTAPI
576 PoSetPowerState(IN PDEVICE_OBJECT DeviceObject,
577 IN POWER_STATE_TYPE Type,
578 IN POWER_STATE State)
579 {
580 POWER_STATE ps;
581
582 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
583
584 ps.SystemState = PowerSystemWorking; // Fully on
585 ps.DeviceState = PowerDeviceD0; // Fully on
586
587 return ps;
588 }
589
590 /*
591 * @unimplemented
592 */
593 VOID
594 NTAPI
595 PoSetSystemState(IN EXECUTION_STATE Flags)
596 {
597 UNIMPLEMENTED;
598 }
599
600 /*
601 * @unimplemented
602 */
603 VOID
604 NTAPI
605 PoStartNextPowerIrp(IN PIRP Irp)
606 {
607 UNIMPLEMENTED;
608 }
609
610 /*
611 * @unimplemented
612 */
613 VOID
614 NTAPI
615 PoUnregisterSystemState(IN PVOID StateHandle)
616 {
617 UNIMPLEMENTED;
618 }
619
620 /*
621 * @unimplemented
622 */
623 NTSTATUS
624 NTAPI
625 NtInitiatePowerAction(IN POWER_ACTION SystemAction,
626 IN SYSTEM_POWER_STATE MinSystemState,
627 IN ULONG Flags,
628 IN BOOLEAN Asynchronous)
629 {
630 UNIMPLEMENTED;
631 return STATUS_NOT_IMPLEMENTED;
632 }
633
634 /*
635 * @unimplemented
636 */
637 NTSTATUS
638 NTAPI
639 NtPowerInformation(IN POWER_INFORMATION_LEVEL PowerInformationLevel,
640 IN PVOID InputBuffer OPTIONAL,
641 IN ULONG InputBufferLength,
642 OUT PVOID OutputBuffer OPTIONAL,
643 IN ULONG OutputBufferLength)
644 {
645 NTSTATUS Status;
646
647 PAGED_CODE();
648
649 DPRINT("NtPowerInformation(PowerInformationLevel 0x%x, InputBuffer 0x%p, "
650 "InputBufferLength 0x%x, OutputBuffer 0x%p, OutputBufferLength 0x%x)\n",
651 PowerInformationLevel,
652 InputBuffer, InputBufferLength,
653 OutputBuffer, OutputBufferLength);
654
655 switch (PowerInformationLevel)
656 {
657 case SystemBatteryState:
658 {
659 PSYSTEM_BATTERY_STATE BatteryState = (PSYSTEM_BATTERY_STATE)OutputBuffer;
660
661 if (InputBuffer != NULL)
662 return STATUS_INVALID_PARAMETER;
663 if (OutputBufferLength < sizeof(SYSTEM_BATTERY_STATE))
664 return STATUS_BUFFER_TOO_SMALL;
665
666 /* Just zero the struct (and thus set BatteryState->BatteryPresent = FALSE) */
667 RtlZeroMemory(BatteryState, sizeof(SYSTEM_BATTERY_STATE));
668 BatteryState->EstimatedTime = MAXULONG;
669
670 Status = STATUS_SUCCESS;
671 break;
672 }
673
674 case SystemPowerCapabilities:
675 {
676 PSYSTEM_POWER_CAPABILITIES PowerCapabilities = (PSYSTEM_POWER_CAPABILITIES)OutputBuffer;
677
678 if (InputBuffer != NULL)
679 return STATUS_INVALID_PARAMETER;
680 if (OutputBufferLength < sizeof(SYSTEM_POWER_CAPABILITIES))
681 return STATUS_BUFFER_TOO_SMALL;
682
683 /* Just zero the struct (and thus set BatteryState->BatteryPresent = FALSE) */
684 RtlZeroMemory(PowerCapabilities, sizeof(SYSTEM_POWER_CAPABILITIES));
685 //PowerCapabilities->SystemBatteriesPresent = 0;
686
687 Status = STATUS_SUCCESS;
688 break;
689 }
690
691 default:
692 Status = STATUS_NOT_IMPLEMENTED;
693 DPRINT1("PowerInformationLevel 0x%x is UNIMPLEMENTED! Have a nice day.\n",
694 PowerInformationLevel);
695 break;
696 }
697
698 return Status;
699 }
700
701 NTSTATUS
702 NTAPI
703 NtGetDevicePowerState(IN HANDLE Device,
704 IN PDEVICE_POWER_STATE PowerState)
705 {
706 UNIMPLEMENTED;
707 return STATUS_NOT_IMPLEMENTED;
708 }
709
710 BOOLEAN
711 NTAPI
712 NtIsSystemResumeAutomatic(VOID)
713 {
714 UNIMPLEMENTED;
715 return FALSE;
716 }
717
718 NTSTATUS
719 NTAPI
720 NtRequestWakeupLatency(IN LATENCY_TIME Latency)
721 {
722 UNIMPLEMENTED;
723 return STATUS_NOT_IMPLEMENTED;
724 }
725
726 NTSTATUS
727 NTAPI
728 NtSetThreadExecutionState(IN EXECUTION_STATE esFlags,
729 OUT EXECUTION_STATE *PreviousFlags)
730 {
731 PKTHREAD Thread = KeGetCurrentThread();
732 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
733 EXECUTION_STATE PreviousState;
734 PAGED_CODE();
735
736 /* Validate flags */
737 if (esFlags & ~(ES_CONTINUOUS | ES_USER_PRESENT))
738 {
739 /* Fail the request */
740 return STATUS_INVALID_PARAMETER;
741 }
742
743 /* Check for user parameters */
744 if (PreviousMode != KernelMode)
745 {
746 /* Protect the probes */
747 _SEH2_TRY
748 {
749 /* Check if the pointer is valid */
750 ProbeForWriteUlong(PreviousFlags);
751 }
752 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
753 {
754 /* It isn't -- fail */
755 _SEH2_YIELD(return _SEH2_GetExceptionCode());
756 }
757 _SEH2_END;
758 }
759
760 /* Save the previous state, always masking in the continous flag */
761 PreviousState = Thread->PowerState | ES_CONTINUOUS;
762
763 /* Check if we need to update the power state */
764 if (esFlags & ES_CONTINUOUS) Thread->PowerState = (UCHAR)esFlags;
765
766 /* Protect the write back to user mode */
767 _SEH2_TRY
768 {
769 /* Return the previous flags */
770 *PreviousFlags = PreviousState;
771 }
772 _SEH2_EXCEPT(ExSystemExceptionFilter())
773 {
774 /* Something's wrong, fail */
775 _SEH2_YIELD(return _SEH2_GetExceptionCode());
776 }
777 _SEH2_END;
778
779 /* All is good */
780 return STATUS_SUCCESS;
781 }
782
783 NTSTATUS
784 NTAPI
785 NtSetSystemPowerState(IN POWER_ACTION SystemAction,
786 IN SYSTEM_POWER_STATE MinSystemState,
787 IN ULONG Flags)
788 {
789 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
790 POP_POWER_ACTION Action = {0};
791 NTSTATUS Status;
792 ULONG Dummy;
793
794 /* Check for invalid parameter combinations */
795 if ((MinSystemState >= PowerSystemMaximum) ||
796 (MinSystemState <= PowerSystemUnspecified) ||
797 (SystemAction > PowerActionWarmEject) ||
798 (SystemAction < PowerActionReserved) ||
799 (Flags & ~(POWER_ACTION_QUERY_ALLOWED |
800 POWER_ACTION_UI_ALLOWED |
801 POWER_ACTION_OVERRIDE_APPS |
802 POWER_ACTION_LIGHTEST_FIRST |
803 POWER_ACTION_LOCK_CONSOLE |
804 POWER_ACTION_DISABLE_WAKES |
805 POWER_ACTION_CRITICAL)))
806 {
807 DPRINT1("NtSetSystemPowerState: Bad parameters!\n");
808 DPRINT1(" SystemAction: 0x%x\n", SystemAction);
809 DPRINT1(" MinSystemState: 0x%x\n", MinSystemState);
810 DPRINT1(" Flags: 0x%x\n", Flags);
811 return STATUS_INVALID_PARAMETER;
812 }
813
814 /* Check for user caller */
815 if (PreviousMode != KernelMode)
816 {
817 /* Check for shutdown permission */
818 if (!SeSinglePrivilegeCheck(SeShutdownPrivilege, PreviousMode))
819 {
820 /* Not granted */
821 DPRINT1("ERROR: Privilege not held for shutdown\n");
822 return STATUS_PRIVILEGE_NOT_HELD;
823 }
824
825 /* Do it as a kernel-mode caller for consistency with system state */
826 return ZwSetSystemPowerState(SystemAction, MinSystemState, Flags);
827 }
828
829 /* Read policy settings (partial shutdown vs. full shutdown) */
830 if (SystemAction == PowerActionShutdown) PopReadShutdownPolicy();
831
832 /* Disable lazy flushing of registry */
833 DPRINT("Stopping lazy flush\n");
834 CmSetLazyFlushState(FALSE);
835
836 /* Setup the power action */
837 Action.Action = SystemAction;
838 Action.Flags = Flags;
839
840 /* Notify callbacks */
841 DPRINT("Notifying callbacks\n");
842 ExNotifyCallback(PowerStateCallback, (PVOID)3, NULL);
843
844 /* Swap in any worker thread stacks */
845 DPRINT("Swapping worker threads\n");
846 ExSwapinWorkerThreads(FALSE);
847
848 /* Make our action global */
849 PopAction = Action;
850
851 /* Start power loop */
852 Status = STATUS_CANCELLED;
853 while (TRUE)
854 {
855 /* Break out if there's nothing to do */
856 if (Action.Action == PowerActionNone) break;
857
858 /* Check for first-pass or restart */
859 if (Status == STATUS_CANCELLED)
860 {
861 /* Check for shutdown action */
862 if ((PopAction.Action == PowerActionShutdown) ||
863 (PopAction.Action == PowerActionShutdownReset) ||
864 (PopAction.Action == PowerActionShutdownOff))
865 {
866 /* Set the action */
867 PopAction.Shutdown = TRUE;
868 }
869
870 /* Now we are good to go */
871 Status = STATUS_SUCCESS;
872 }
873
874 /* Check if we're still in an invalid status */
875 if (!NT_SUCCESS(Status)) break;
876
877 #ifndef NEWCC
878 /* Flush dirty cache pages */
879 CcRosFlushDirtyPages(-1, &Dummy, FALSE); //HACK: We really should wait here!
880 #else
881 Dummy = 0;
882 #endif
883
884 /* Flush all volumes and the registry */
885 DPRINT("Flushing volumes, cache flushed %lu pages\n", Dummy);
886 PopFlushVolumes(PopAction.Shutdown);
887
888 /* Set IRP for drivers */
889 PopAction.IrpMinor = IRP_MN_SET_POWER;
890 if (PopAction.Shutdown)
891 {
892 DPRINT("Queueing shutdown thread\n");
893 /* Check if we are running in the system context */
894 if (PsGetCurrentProcess() != PsInitialSystemProcess)
895 {
896 /* We're not, so use a worker thread for shutdown */
897 ExInitializeWorkItem(&PopShutdownWorkItem,
898 &PopGracefulShutdown,
899 NULL);
900
901 ExQueueWorkItem(&PopShutdownWorkItem, CriticalWorkQueue);
902
903 /* Spend us -- when we wake up, the system is good to go down */
904 KeSuspendThread(KeGetCurrentThread());
905 Status = STATUS_SYSTEM_SHUTDOWN;
906 goto Exit;
907
908 }
909 else
910 {
911 /* Do the shutdown inline */
912 PopGracefulShutdown(NULL);
913 }
914 }
915
916 /* You should not have made it this far */
917 // ASSERTMSG("System is still up and running?!", FALSE);
918 DPRINT1("System is still up and running, you may not have chosen a yet supported power option: %u\n", PopAction.Action);
919 break;
920 }
921
922 Exit:
923 /* We're done, return */
924 return Status;
925 }