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