1 /* 2 * Copyright (c) 1998-2020 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 #ifndef _IOKIT_ROOTDOMAIN_H 29 #define _IOKIT_ROOTDOMAIN_H 30 31 #include <libkern/c++/OSPtr.h> 32 #include <IOKit/IOService.h> 33 #include <IOKit/pwr_mgt/IOPM.h> 34 #include <IOKit/IOBufferMemoryDescriptor.h> 35 #include <sys/vnode.h> 36 37 #ifdef XNU_KERNEL_PRIVATE 38 39 #include <IOKit/pwr_mgt/IOPMPrivate.h> 40 41 struct AggressivesRecord; 42 struct IOPMMessageFilterContext; 43 struct IOPMActions; 44 struct IOPMSystemSleepParameters; 45 class PMSettingObject; 46 class PMTraceWorker; 47 class IOPMPowerStateQueue; 48 class RootDomainUserClient; 49 class PMAssertionsTracker; 50 class IOTimerEventSource; 51 52 #define OBFUSCATE(x) (void *)VM_KERNEL_UNSLIDE_OR_PERM(x) 53 54 #endif 55 56 /*! 57 * Types for PM Assertions 58 * For creating, releasing, and getting PM assertion levels. 59 */ 60 61 /*! IOPMDriverAssertionType 62 * A bitfield describing a set of assertions. May be used to specify which assertions 63 * to set with <link>IOPMrootDomain::createPMAssertion</link>; or to query which 64 * assertions are set with <link>IOPMrootDomain::releasePMAssertion</link>. 65 */ 66 typedef uint64_t IOPMDriverAssertionType; 67 68 /* IOPMDriverAssertionID 69 * Drivers may create PM assertions to request system behavior (keep the system awake, 70 * or keep the display awake). When a driver creates an assertion via 71 * <link>IOPMrootDomain::createPMAssertion</link>, PM returns a handle to 72 * the assertion of type IOPMDriverAssertionID. 73 */ 74 typedef uint64_t IOPMDriverAssertionID; 75 #define kIOPMUndefinedDriverAssertionID 0 76 77 /* IOPMDriverAssertionLevel 78 * Possible values for IOPMDriverAssertionLevel are <link>kIOPMDriverAssertionLevelOff</link> 79 * and <link>kIOPMDriverAssertionLevelOn</link> 80 */ 81 typedef uint32_t IOPMDriverAssertionLevel; 82 #define kIOPMDriverAssertionLevelOff 0 83 #define kIOPMDriverAssertionLevelOn 255 84 85 /* 86 * Flags for get/setSleepSupported() 87 */ 88 enum { 89 kRootDomainSleepNotSupported = 0x00000000, 90 kRootDomainSleepSupported = 0x00000001, 91 kFrameBufferDeepSleepSupported = 0x00000002, 92 kPCICantSleep = 0x00000004 93 }; 94 95 /* 96 * IOPMrootDomain registry property keys 97 */ 98 #define kRootDomainSupportedFeatures "Supported Features" 99 #define kRootDomainSleepReasonKey "Last Sleep Reason" 100 #define kRootDomainSleepOptionsKey "Last Sleep Options" 101 #define kIOPMRootDomainWakeReasonKey "Wake Reason" 102 #define kIOPMRootDomainWakeTypeKey "Wake Type" 103 #define kIOPMRootDomainPowerStatusKey "Power Status" 104 105 /* 106 * Possible sleep reasons found under kRootDomainSleepReasonsKey 107 */ 108 #define kIOPMClamshellSleepKey "Clamshell Sleep" 109 #define kIOPMPowerButtonSleepKey "Power Button Sleep" 110 #define kIOPMSoftwareSleepKey "Software Sleep" 111 #define kIOPMOSSwitchHibernationKey "OS Switch Sleep" 112 #define kIOPMIdleSleepKey "Idle Sleep" 113 #define kIOPMLowPowerSleepKey "Low Power Sleep" 114 #define kIOPMThermalEmergencySleepKey "Thermal Emergency Sleep" 115 #define kIOPMMaintenanceSleepKey "Maintenance Sleep" 116 117 /* 118 * String constants for communication with PM CPU 119 */ 120 #define kIOPMRootDomainLidCloseCString "LidClose" 121 #define kIOPMRootDomainBatPowerCString "BatPower" 122 123 /* 124 * Supported Feature bitfields for IOPMrootDomain::publishFeature() 125 */ 126 enum { 127 kIOPMSupportedOnAC = (1 << 0), 128 kIOPMSupportedOnBatt = (1 << 1), 129 kIOPMSupportedOnUPS = (1 << 2) 130 }; 131 132 typedef IOReturn (*IOPMSettingControllerCallback) 133 (OSObject *target, const OSSymbol *type, 134 OSObject *val, uintptr_t refcon); 135 136 __BEGIN_DECLS 137 IONotifier * registerSleepWakeInterest( 138 IOServiceInterestHandler, void *, void * = NULL); 139 140 IONotifier * registerPrioritySleepWakeInterest( 141 IOServiceInterestHandler handler, 142 void * self, void * ref = NULL); 143 144 IOReturn acknowledgeSleepWakeNotification(void * ); 145 146 IOReturn vetoSleepWakeNotification(void * PMrefcon); 147 __END_DECLS 148 149 #define IOPM_ROOTDOMAIN_REV 2 150 151 class IOPMrootDomain : public IOService 152 { 153 OSDeclareFinalStructors(IOPMrootDomain); 154 155 public: 156 static IOPMrootDomain * construct( void ); 157 158 virtual bool start( IOService * provider ) APPLE_KEXT_OVERRIDE; 159 virtual IOReturn setAggressiveness( unsigned long, unsigned long ) APPLE_KEXT_OVERRIDE; 160 virtual IOReturn getAggressiveness( unsigned long, unsigned long * ) APPLE_KEXT_OVERRIDE; 161 162 virtual IOReturn sleepSystem( void ); 163 IOReturn sleepSystemOptions( OSDictionary *options ); 164 165 virtual IOReturn setProperties( OSObject * ) APPLE_KEXT_OVERRIDE; 166 virtual bool serializeProperties( OSSerialize * s ) const APPLE_KEXT_OVERRIDE; 167 virtual OSPtr<OSObject> copyProperty( const char * aKey ) const APPLE_KEXT_OVERRIDE; 168 169 /*! @function systemPowerEventOccurred 170 * @abstract Other drivers may inform IOPMrootDomain of system PM events 171 * @discussion systemPowerEventOccurred is a richer alternative to receivePowerNotification() 172 * Only Apple-owned kexts should have reason to call systemPowerEventOccurred. 173 * @param event An OSSymbol describing the type of power event. 174 * @param intValue A 32-bit integer value associated with the event. 175 * @result kIOReturnSuccess on success */ 176 177 IOReturn systemPowerEventOccurred( 178 const OSSymbol *event, 179 uint32_t intValue ); 180 181 IOReturn systemPowerEventOccurred( 182 const OSSymbol *event, 183 OSObject *value ); 184 185 #ifdef XNU_KERNEL_PRIVATE // Hide doc from public headers 186 /*! @function claimSystemWakeEvent 187 * @abstract Apple-internal SPI to describe system wake events. 188 * @discussion IOKit drivers may call claimSystemWakeEvent() during system wakeup to 189 * provide human readable debug information describing the event(s) that 190 * caused the system to wake. 191 * 192 * - Drivers should call claimSystemWakeEvent before completing 193 * their setPowerState() acknowledgement. IOPMrootDomain stops 194 * collecting wake events when driver wake is complete. 195 * 196 * - It is only appropriate to claim a wake event when the driver 197 * can positively identify its hardware has generated an event 198 * that can wake the system. 199 * 200 * - This call tracks wake events from a non-S0 state (S0i, S3, S4) into S0. 201 * - This call does not track wake events from DarkWake(S0) to FullWake(S0). 202 * 203 * Examples: 204 * (reason = "WiFi.TCPData", 205 * details = "TCPKeepAlive packet arrived from IP 16.2.1.1") 206 * (reason = "WiFi.ScanOffload", 207 * details = "WiFi station 'AppleWiFi' signal dropped below threshold") 208 * (reason = "Enet.LinkToggle", 209 * details = "Ethernet attached") 210 * 211 * @param device The device/nub that is associated with the wake event. 212 * 213 * @param flags Pass kIOPMWakeEventSource if the device is the source 214 * of the wake event. Pass zero if the device is forwarding or 215 * aggregating wake events from multiple sources, e.g. an USB or 216 * Thunderbolt host controller. 217 * 218 * @param reason Caller should pass a human readable C string describing the 219 * wake reason. Please use a string from the list below, or create 220 * your own string matching this format: 221 * [Hardware].[Event] 222 * WiFi.MagicPacket 223 * WiFi.ScanOffload 224 * WiFi.mDNSConflict 225 * WiFi.mDNSService 226 * WiFi.TCPData 227 * WiFi.TCPTimeout 228 * WiFi.FirmwareCrash 229 * Enet.MagicPacket 230 * Enet.mDNSConflict 231 * Enet.mDNSService 232 * Enet.TCPData 233 * Enet.TCPTimeout 234 * Enet.Service 235 * Enet.LinkToggle 236 * Enet.ConflictResolution 237 * Enet.PatternMatch 238 * Enet.Timer 239 * Enet.LinkUpTimeout 240 * Enet.LinkDown 241 * USB.DeviceAttach 242 * USB.DeviceDetach 243 * 244 * @param details Optional details further describing the wake event. 245 * Please pass an OSString defining the event. 246 */ 247 #endif 248 void claimSystemWakeEvent( 249 IOService *device, 250 IOOptionBits flags, 251 const char *reason, 252 OSObject *details = NULL ); 253 254 void claimSystemBootEvent( 255 IOService *device, 256 IOOptionBits flags, 257 const char *reason, 258 OSObject *details = NULL ); 259 260 void claimSystemShutdownEvent( 261 IOService *device, 262 IOOptionBits flags, 263 const char *reason, 264 OSObject *details = NULL ); 265 266 virtual IOReturn receivePowerNotification( UInt32 msg ); 267 268 virtual void setSleepSupported( IOOptionBits flags ); 269 270 virtual IOOptionBits getSleepSupported( void ); 271 272 void wakeFromDoze( void ); 273 274 void requestUserActive(IOService *driver, const char *reason); 275 276 // KEXT driver announces support of power management feature 277 278 void publishFeature( const char *feature ); 279 280 // KEXT driver announces support of power management feature 281 // And specifies power sources with kIOPMSupportedOn{AC/Batt/UPS} bitfield. 282 // Returns a unique uint32_t identifier for later removing support for this 283 // feature. 284 // NULL is acceptable for uniqueFeatureID for kexts without plans to unload. 285 286 void publishFeature( const char *feature, 287 uint32_t supportedWhere, 288 uint32_t *uniqueFeatureID); 289 290 // KEXT driver announces removal of a previously published power management 291 // feature. Pass 'uniqueFeatureID' returned from publishFeature() 292 293 IOReturn removePublishedFeature( uint32_t removeFeatureID ); 294 295 /*! @function copyPMSetting 296 * @abstract Copy the current value for a PM setting. Returns an OSNumber or 297 * OSData depending on the setting. 298 * @param whichSetting Name of the desired setting. 299 * @result OSObject value if valid, NULL otherwise. */ 300 301 OSPtr<OSObject> copyPMSetting( OSSymbol *whichSetting ); 302 303 /*! @function registerPMSettingController 304 * @abstract Register for callbacks on changes to certain PM settings. 305 * @param settings NULL terminated array of C strings, each string for a PM 306 * setting that the caller is interested in and wants to get callbacks for. 307 * @param callout C function ptr or member function cast as such. 308 * @param target The target of the callback, usually 'this' 309 * @param refcon Will be passed to caller in callback; for caller's use. 310 * @param handle Caller should keep the OSObject * returned here. If non-NULL, 311 * handle will have a retain count of 1 on return. To deregister, pass to 312 * unregisterPMSettingController() 313 * @result kIOReturnSuccess on success. */ 314 315 IOReturn registerPMSettingController( 316 const OSSymbol *settings[], 317 IOPMSettingControllerCallback callout, 318 OSObject *target, 319 uintptr_t refcon, 320 OSObject **handle); // out param 321 322 /*! @function registerPMSettingController 323 * @abstract Register for callbacks on changes to certain PM settings. 324 * @param settings NULL terminated array of C strings, each string for a PM 325 * setting that the caller is interested in and wants to get callbacks for. 326 * @param supportedPowerSources bitfield indicating which power sources these 327 * settings are supported for (kIOPMSupportedOnAC, etc.) 328 * @param callout C function ptr or member function cast as such. 329 * @param target The target of the callback, usually 'this' 330 * @param refcon Will be passed to caller in callback; for caller's use. 331 * @param handle Caller should keep the OSObject * returned here. If non-NULL, 332 * handle will have a retain count of 1 on return. To deregister, pass to 333 * unregisterPMSettingController() 334 * @result kIOReturnSuccess on success. */ 335 336 IOReturn registerPMSettingController( 337 const OSSymbol *settings[], 338 uint32_t supportedPowerSources, 339 IOPMSettingControllerCallback callout, 340 OSObject *target, 341 uintptr_t refcon, 342 OSObject **handle); // out param 343 344 virtual OSPtr<IONotifier> registerInterest( 345 const OSSymbol * typeOfInterest, 346 IOServiceInterestHandler handler, 347 void * target, void * ref = NULL ) APPLE_KEXT_OVERRIDE; 348 349 virtual IOReturn callPlatformFunction( 350 const OSSymbol *functionName, 351 bool waitForFunction, 352 void *param1, void *param2, 353 void *param3, void *param4 ) APPLE_KEXT_OVERRIDE; 354 355 /*! @function createPMAssertion 356 * @abstract Creates an assertion to influence system power behavior. 357 * @param whichAssertionsBits A bitfield specify the assertion that the caller requests. 358 * @param assertionLevel An integer detailing the initial assertion level, kIOPMDriverAssertionLevelOn 359 * or kIOPMDriverAssertionLevelOff. 360 * @param ownerService A pointer to the caller's IOService class, for tracking. 361 * @param ownerDescription A reverse-DNS string describing the caller's identity and reason. 362 * @result On success, returns a new assertion of type IOPMDriverAssertionID 363 */ 364 IOPMDriverAssertionID createPMAssertion( 365 IOPMDriverAssertionType whichAssertionsBits, 366 IOPMDriverAssertionLevel assertionLevel, 367 IOService *ownerService, 368 const char *ownerDescription); 369 370 /* @function setPMAssertionLevel 371 * @abstract Modify the level of a pre-existing assertion. 372 * @discussion Change the value of a PM assertion to influence system behavior, 373 * without undergoing the work required to create or destroy an assertion. Suggested 374 * for clients who will assert and de-assert needs for PM behavior several times over 375 * their lifespan. 376 * @param assertionID An assertion ID previously returned by <link>createPMAssertion</link> 377 * @param assertionLevel The new assertion level. 378 * @result kIOReturnSuccess if it worked; kIOReturnNotFound or other IOReturn error on failure. 379 */ 380 IOReturn setPMAssertionLevel(IOPMDriverAssertionID assertionID, IOPMDriverAssertionLevel assertionLevel); 381 382 /*! @function getPMAssertionLevel 383 * @absract Returns the active level of the specified assertion(s). 384 * @discussion Returns <link>kIOPMDriverAssertionLevelOff</link> or 385 * <link>kIOPMDriverAssertionLevelOn</link>. If multiple assertions are specified 386 * in the bitfield, only returns <link>kIOPMDriverAssertionLevelOn</link> 387 * if all assertions are active. 388 * @param whichAssertionBits Bits defining the assertion or assertions the caller is interested in 389 * the level of. If in doubt, pass <link>kIOPMDriverAssertionCPUBit</link> as the argument. 390 * @result Returns <link>kIOPMDriverAssertionLevelOff</link> or 391 * <link>kIOPMDriverAssertionLevelOn</link> indicating the specified assertion's levels, if available. 392 * If the assertions aren't supported on this machine, or aren't recognized by the OS, the 393 * result is undefined. 394 */ 395 IOPMDriverAssertionLevel getPMAssertionLevel(IOPMDriverAssertionType whichAssertionBits); 396 397 /*! @function releasePMAssertion 398 * @abstract Removes an assertion to influence system power behavior. 399 * @result On success, returns a new assertion of type IOPMDriverAssertionID * 400 */ 401 IOReturn releasePMAssertion(IOPMDriverAssertionID releaseAssertion); 402 403 /*! @function restartWithStackshot 404 * @abstract Take a stackshot of the system and restart the system. 405 * @result Return kIOReturnSuccess if it work, kIOReturnError if the service is not available. 406 */ 407 IOReturn restartWithStackshot(); 408 409 IOReturn setWakeTime(uint64_t wakeContinuousTime); 410 411 #if XNU_KERNEL_PRIVATE 412 IOReturn acquireDriverKitMatchingAssertion(); 413 void releaseDriverKitMatchingAssertion(); 414 #endif 415 416 void copyWakeReasonString( char * outBuf, size_t bufSize ); 417 418 private: 419 unsigned long getRUN_STATE(void); 420 421 virtual IOReturn changePowerStateTo( unsigned long ordinal ) APPLE_KEXT_COMPATIBILITY_OVERRIDE; 422 virtual IOReturn changePowerStateToPriv( unsigned long ordinal ); 423 virtual IOReturn requestPowerDomainState( IOPMPowerFlags, IOPowerConnection *, unsigned long ) APPLE_KEXT_OVERRIDE; 424 virtual void powerChangeDone( unsigned long ) APPLE_KEXT_OVERRIDE; 425 virtual bool tellChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE; 426 virtual bool askChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE; 427 virtual void tellChangeUp( unsigned long ) APPLE_KEXT_OVERRIDE; 428 virtual void tellNoChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE; 429 virtual IOReturn configureReport(IOReportChannelList *channels, 430 IOReportConfigureAction action, 431 void *result, 432 void *destination) APPLE_KEXT_OVERRIDE; 433 virtual IOReturn updateReport(IOReportChannelList *channels, 434 IOReportUpdateAction action, 435 void *result, 436 void *destination) APPLE_KEXT_OVERRIDE; 437 438 void configureReportGated(uint64_t channel_id, 439 uint64_t action, 440 void *result); 441 IOReturn updateReportGated(uint64_t ch_id, 442 void *result, 443 IOBufferMemoryDescriptor *dest); 444 445 #ifdef XNU_KERNEL_PRIVATE 446 /* Root Domain internals */ 447 public: 448 void tagPowerPlaneService( 449 IOService * service, 450 IOPMActions * actions, 451 IOPMPowerStateIndex maxPowerState ); 452 453 void overrideOurPowerChange( 454 IOService * service, 455 IOPMActions * actions, 456 const IOPMRequest * request, 457 IOPMPowerStateIndex * inOutPowerState, 458 IOPMPowerChangeFlags * inOutChangeFlags ); 459 460 void handleOurPowerChangeStart( 461 IOService * service, 462 IOPMActions * actions, 463 const IOPMRequest * request, 464 IOPMPowerStateIndex powerState, 465 IOPMPowerChangeFlags * inOutChangeFlags ); 466 467 void handleOurPowerChangeDone( 468 IOService * service, 469 IOPMActions * actions, 470 const IOPMRequest * request, 471 IOPMPowerStateIndex powerState, 472 IOPMPowerChangeFlags changeFlags ); 473 474 void overridePowerChangeForService( 475 IOService * service, 476 IOPMActions * actions, 477 const IOPMRequest * request, 478 IOPMPowerStateIndex * inOutPowerState, 479 IOPMPowerChangeFlags * inOutChangeFlags ); 480 481 void handleActivityTickleForDisplayWrangler( 482 IOService * service, 483 IOPMActions * actions ); 484 485 void handleUpdatePowerClientForDisplayWrangler( 486 IOService * service, 487 IOPMActions * actions, 488 const OSSymbol * powerClient, 489 IOPMPowerStateIndex oldPowerState, 490 IOPMPowerStateIndex newPowerState ); 491 492 bool shouldDelayChildNotification( 493 IOService * service ); 494 495 void handlePowerChangeStartForPCIDevice( 496 IOService * service, 497 IOPMActions * actions, 498 const IOPMRequest * request, 499 IOPMPowerStateIndex powerState, 500 IOPMPowerChangeFlags * inOutChangeFlags ); 501 502 void handlePowerChangeDoneForPCIDevice( 503 IOService * service, 504 IOPMActions * actions, 505 const IOPMRequest * request, 506 IOPMPowerStateIndex powerState, 507 IOPMPowerChangeFlags changeFlags ); 508 509 void askChangeDownDone( 510 IOPMPowerChangeFlags * inOutChangeFlags, 511 bool * cancel ); 512 513 void handlePublishSleepWakeUUID( 514 bool shouldPublish); 515 516 void handleQueueSleepWakeUUID( 517 OSObject *obj); 518 519 void willTellSystemCapabilityDidChange(void); 520 521 void handleSetDisplayPowerOn(bool powerOn); 522 523 void willNotifyPowerChildren( IOPMPowerStateIndex newPowerState ); 524 525 IOReturn setMaintenanceWakeCalendar( 526 const IOPMCalendarStruct * calendar ); 527 528 IOReturn getSystemSleepType(uint32_t * sleepType, uint32_t * standbyTimer); 529 530 // Handle callbacks from IOService::systemWillShutdown() 531 void acknowledgeSystemWillShutdown( IOService * from ); 532 533 // Handle platform halt and restart notifications 534 void handlePlatformHaltRestart( UInt32 pe_type ); 535 536 IOReturn shutdownSystem( void ); 537 IOReturn restartSystem( void ); 538 void handleSleepTimerExpiration( void ); 539 void setIdleSleepRevertible( bool revertible ); 540 541 bool activitySinceSleep(void); 542 bool abortHibernation(void); 543 void updateConsoleUsers(void); 544 545 IOReturn joinAggressiveness( IOService * service ); 546 void handleAggressivesRequests( void ); 547 548 void kdebugTrace(uint32_t event, uint64_t regId, 549 uintptr_t param1, uintptr_t param2, uintptr_t param3 = 0); 550 void tracePoint(uint8_t point); 551 void traceDetail(uint32_t msgType, uint32_t msgIndex, uint32_t delay); 552 void traceNotification(OSObject *notifier, bool start, uint64_t ts = 0, uint32_t msgIndex = UINT_MAX); 553 void traceNotificationAck(OSObject *notifier, uint32_t delay_ms); 554 void traceNotificationResponse(OSObject *object, uint32_t delay_ms, uint32_t ack_time_us); 555 void traceFilteredNotification(OSObject *notifier); 556 const char * getNotificationClientName(OSObject *notifier); 557 558 void startSpinDump(uint32_t spindumpKind); 559 560 bool systemMessageFilter( 561 void * object, void * arg1, void * arg2, void * arg3 ); 562 563 bool updatePreventIdleSleepList( 564 IOService * service, bool addNotRemove ); 565 void updatePreventSystemSleepList( 566 IOService * service, bool addNotRemove ); 567 568 bool updatePreventIdleSleepListInternal( 569 IOService * service, bool addNotRemove, unsigned int oldCount); 570 unsigned int idleSleepPreventersCount(); 571 572 void publishPMSetting( 573 const OSSymbol * feature, uint32_t where, uint32_t * featureID ); 574 575 void pmStatsRecordEvent( 576 int eventIndex, 577 AbsoluteTime timestamp); 578 579 void pmStatsRecordApplicationResponse( 580 const OSSymbol *response, 581 const char *name, 582 int messageType, 583 uint32_t delay_ms, 584 uint64_t id, 585 OSObject *object, 586 IOPMPowerStateIndex ps = 0, 587 bool async = false); 588 589 void copyShutdownReasonString( char * outBuf, size_t bufSize ); 590 void lowLatencyAudioNotify(uint64_t time, boolean_t state); 591 592 #if HIBERNATION 593 bool getHibernateSettings( 594 uint32_t * hibernateMode, 595 uint32_t * hibernateFreeRatio, 596 uint32_t * hibernateFreeTime ); 597 bool mustHibernate( void ); 598 #endif 599 void takeStackshot(bool restart); 600 void sleepWakeDebugTrig(bool restart); 601 void sleepWakeDebugEnableWdog(); 602 bool sleepWakeDebugIsWdogEnabled(); 603 void sleepWakeDebugSaveSpinDumpFile(); 604 bool checkShutdownTimeout(); 605 void panicWithShutdownLog(uint32_t timeoutInMs) __abortlike; 606 uint32_t getWatchdogTimeout(); 607 void deleteStackshot(); 608 609 private: 610 friend class PMSettingObject; 611 friend class RootDomainUserClient; 612 friend class PMAssertionsTracker; 613 614 static IOReturn sysPowerDownHandler( void * target, void * refCon, 615 UInt32 messageType, IOService * service, 616 void * messageArgument, vm_size_t argSize ); 617 618 static IOReturn displayWranglerNotification( void * target, void * refCon, 619 UInt32 messageType, IOService * service, 620 void * messageArgument, vm_size_t argSize ); 621 622 static IOReturn rootBusyStateChangeHandler( void * target, void * refCon, 623 UInt32 messageType, IOService * service, 624 void * messageArgument, vm_size_t argSize ); 625 626 void initializeBootSessionUUID( void ); 627 628 void fullWakeDelayedWork( void ); 629 630 OSPtr<IOService> wrangler; 631 OSPtr<OSDictionary> wranglerIdleSettings; 632 633 IOLock *featuresDictLock;// guards supportedFeatures 634 IOLock *wakeEventLock; 635 IOPMPowerStateQueue *pmPowerStateQueue; 636 637 OSPtr<OSArray> allowedPMSettings; 638 OSPtr<OSArray> noPublishPMSettings; 639 OSPtr<PMTraceWorker> pmTracer; 640 PMAssertionsTracker *pmAssertions; 641 642 // Settings controller info 643 IOLock *settingsCtrlLock; 644 OSPtr<OSDictionary> settingsCallbacks; 645 OSPtr<OSDictionary> fPMSettingsDict; 646 647 // Statistics 648 OSPtr<const OSSymbol> _statsNameKey; 649 OSPtr<const OSSymbol> _statsPIDKey; 650 OSPtr<const OSSymbol> _statsTimeMSKey; 651 OSPtr<const OSSymbol> _statsResponseTypeKey; 652 OSPtr<const OSSymbol> _statsMessageTypeKey; 653 OSPtr<const OSSymbol> _statsPowerCapsKey; 654 uint32_t sleepCnt; 655 uint32_t darkWakeCnt; 656 uint32_t displayWakeCnt; 657 658 OSPtr<OSString> queuedSleepWakeUUIDString; 659 OSPtr<OSArray> pmStatsAppResponses; 660 IOLock *pmStatsLock;// guards pmStatsAppResponses 661 662 void *sleepDelaysReport; // report to track time taken to go to sleep 663 uint32_t sleepDelaysClientCnt;// Number of interested clients in sleepDelaysReport 664 uint64_t ts_sleepStart; 665 uint64_t wake2DarkwakeDelay; // Time taken to change from full wake -> Dark wake 666 667 void *assertOnWakeReport;// report to track time spent without any assertions held after wake 668 uint32_t assertOnWakeClientCnt;// Number of clients interested in assertOnWakeReport 669 clock_sec_t assertOnWakeSecs; // Num of secs after wake for first assertion 670 671 bool uuidPublished; 672 673 // Pref: idle time before idle sleep 674 bool idleSleepEnabled; 675 uint32_t sleepSlider; 676 uint32_t idleMilliSeconds; 677 bool idleSleepRevertible; 678 679 // Difference between sleepSlider and longestNonSleepSlider 680 uint32_t extraSleepDelay; 681 682 // Used to wait between say display idle and system idle 683 thread_call_t extraSleepTimer; 684 thread_call_t powerButtonDown; 685 thread_call_t powerButtonUp; 686 thread_call_t diskSyncCalloutEntry; 687 thread_call_t fullWakeThreadCall; 688 thread_call_t updateConsoleUsersEntry; 689 690 // Core Analytics 691 IOPMAOTAnalytics * _aotAnalytics; 692 thread_call_t analyticsThreadCall; 693 694 // Track system capabilities. 695 uint32_t _desiredCapability; 696 uint32_t _currentCapability; 697 uint32_t _pendingCapability; 698 uint32_t _highestCapability; 699 OSPtr<OSSet> _joinedCapabilityClients; 700 uint32_t _systemStateGeneration; 701 702 // Type of clients that can receive system messages. 703 enum { 704 kSystemMessageClientPowerd = 0x01, 705 kSystemMessageClientLegacyApp = 0x02, 706 kSystemMessageClientKernel = 0x04, 707 kSystemMessageClientAll = 0x07 708 }; 709 uint32_t _systemMessageClientMask; 710 711 // Power state and capability change transitions. 712 enum { 713 kSystemTransitionNone = 0, 714 kSystemTransitionSleep = 1, 715 kSystemTransitionWake = 2, 716 kSystemTransitionCapability = 3, 717 kSystemTransitionNewCapClient = 4 718 } _systemTransitionType; 719 720 unsigned int systemBooting :1; 721 unsigned int systemShutdown :1; 722 unsigned int systemDarkWake :1; 723 unsigned int clamshellExists :1; 724 unsigned int clamshellClosed :1; 725 unsigned int clamshellDisabled :1; 726 unsigned int desktopMode :1; 727 unsigned int acAdaptorConnected :1; 728 729 unsigned int clamshellIgnoreClose :1; 730 unsigned int idleSleepTimerPending :1; 731 unsigned int userDisabledAllSleep :1; 732 unsigned int ignoreTellChangeDown :1; 733 unsigned int wranglerAsleep :1; 734 unsigned int darkWakeExit :1; 735 unsigned int _preventUserActive :1; 736 unsigned int darkWakePowerClamped :1; 737 738 unsigned int capabilityLoss :1; 739 unsigned int pciCantSleepFlag :1; 740 unsigned int pciCantSleepValid :1; 741 unsigned int darkWakeLogClamp :1; 742 unsigned int darkWakeToSleepASAP :1; 743 unsigned int darkWakeMaintenance :1; 744 unsigned int darkWakeSleepService :1; 745 unsigned int darkWakePostTickle :1; 746 747 unsigned int sleepTimerMaintenance :1; 748 unsigned int sleepToStandby :1; 749 unsigned int lowBatteryCondition :1; 750 unsigned int hibernateDisabled :1; 751 unsigned int hibernateRetry :1; 752 unsigned int wranglerTickled :1; 753 unsigned int userIsActive :1; 754 unsigned int userWasActive :1; 755 756 unsigned int displayIdleForDemandSleep :1; 757 unsigned int darkWakeHibernateError :1; 758 unsigned int thermalWarningState :1; 759 unsigned int toldPowerdCapWillChange :1; 760 unsigned int displayPowerOnRequested :1; 761 unsigned int isRTCAlarmWake :1; 762 unsigned int wranglerPowerOff :1; 763 unsigned int thermalEmergencyState :1; 764 765 uint8_t tasksSuspended; 766 uint8_t tasksSuspendState; 767 uint32_t hibernateMode; 768 AbsoluteTime userActivityTime; 769 AbsoluteTime userActivityTime_prev; 770 uint32_t userActivityCount; 771 uint32_t userActivityAtSleep; 772 uint32_t lastSleepReason; 773 uint32_t fullToDarkReason; 774 uint32_t hibernateAborted; 775 uint8_t standbyNixed; 776 uint8_t resetTimers; 777 778 enum FullWakeReason { 779 kFullWakeReasonNone = 0, 780 kFullWakeReasonLocalUser = 1, 781 kFullWakeReasonDisplayOn = 2, 782 fFullWakeReasonDisplayOnAndLocalUser = 3 783 }; 784 uint32_t fullWakeReason; 785 786 enum { 787 kClamshellSleepDisableInternal = 0x01, 788 kClamshellSleepDisablePowerd = 0x02 789 }; 790 uint32_t clamshellSleepDisableMask; 791 792 // Info for communicating system state changes to PMCPU 793 int32_t idxPMCPUClamshell; 794 int32_t idxPMCPULimitedPower; 795 796 IOOptionBits platformSleepSupport; 797 uint32_t _debugWakeSeconds; 798 799 queue_head_t aggressivesQueue; 800 thread_call_t aggressivesThreadCall; 801 OSPtr<OSData> aggressivesData; 802 803 AbsoluteTime userBecameInactiveTime; 804 805 // PCI top-level PM trace 806 OSPtr<IOService> pciHostBridgeDevice; 807 OSPtr<IOService> pciHostBridgeDriver; 808 809 OSPtr<IONotifier> systemCapabilityNotifier; 810 811 typedef struct { 812 uint32_t pid; 813 uint32_t refcount; 814 } PMNotifySuspendedStruct; 815 816 uint32_t pmSuspendedCapacity; 817 uint32_t pmSuspendedSize; 818 PMNotifySuspendedStruct *pmSuspendedPIDS; 819 820 OSPtr<OSSet> preventIdleSleepList; 821 OSPtr<OSSet> preventSystemSleepList; 822 823 OSPtr<const OSSymbol> _nextScheduledAlarmType; 824 clock_sec_t _nextScheduledAlarmUTC; 825 clock_sec_t _calendarWakeAlarmUTC; 826 UInt32 _scheduledAlarmMask; 827 UInt32 _userScheduledAlarmMask; 828 829 #if HIBERNATION 830 clock_sec_t _standbyTimerResetSeconds; 831 #endif 832 volatile uint32_t swd_lock;/* Lock to access swd_buffer & and its header */ 833 void * swd_buffer;/* Memory allocated for dumping sleep/wake logs */ 834 uint32_t swd_flags;/* Flags defined in IOPMPrivate.h */ 835 void * swd_compressed_buffer; 836 void * swd_spindump_buffer; 837 thread_t notifierThread; 838 OSPtr<OSObject> notifierObject; 839 840 OSPtr<IOBufferMemoryDescriptor> swd_spindump_memDesc; 841 OSPtr<IOBufferMemoryDescriptor> swd_memDesc; 842 843 // Wake Event Reporting 844 OSPtr<OSArray> _systemWakeEventsArray; 845 bool _acceptSystemWakeEvents; 846 847 // AOT -- 848 IOPMCalendarStruct _aotWakeTimeCalendar; 849 OSPtr<IOTimerEventSource> _aotTimerES; 850 clock_sec_t _aotWakeTimeUTC; 851 uint64_t _aotTestTime; 852 uint64_t _aotTestInterval; 853 uint32_t _aotPendingFlags; 854 public: 855 IOPMAOTMetrics * _aotMetrics; 856 uint8_t _aotMode; 857 private: 858 uint8_t _aotNow; 859 uint8_t _aotTasksSuspended; 860 uint8_t _aotTimerScheduled; 861 uint8_t _aotReadyToFullWake; 862 uint64_t _aotLastWakeTime; 863 uint64_t _aotWakeTimeContinuous; 864 uint64_t _aotWakePreWindow; 865 uint64_t _aotWakePostWindow; 866 uint64_t _aotLingerTime; 867 868 size_t _driverKitMatchingAssertionCount; 869 IOPMDriverAssertionID _driverKitMatchingAssertion; 870 871 bool aotShouldExit(bool software); 872 void aotExit(bool cps); 873 void aotEvaluate(IOTimerEventSource * timer); 874 public: 875 bool isAOTMode(void); 876 877 // Core Analytics 878 void initAOTMetrics(); 879 void scheduleAnalyticsThreadCall(); 880 void reportAnalytics(); 881 882 private: 883 // -- AOT 884 enum { 885 kTasksSuspendUnsuspended = 0, 886 kTasksSuspendSuspended = 1, 887 kTasksSuspendNoChange = -1, 888 }; 889 bool updateTasksSuspend(int newTasksSuspended, int newAOTTasksSuspended); 890 int findSuspendedPID(uint32_t pid, uint32_t *outRefCount); 891 892 // IOPMrootDomain internal sleep call 893 IOReturn privateSleepSystem( uint32_t sleepReason ); 894 void reportUserInput( void ); 895 void updateUserActivity( void ); 896 void setDisableClamShellSleep( bool ); 897 void setClamShellSleepDisable(bool disable, uint32_t bitmask); 898 bool checkSystemSleepAllowed( IOOptionBits options, 899 uint32_t sleepReason ); 900 bool checkSystemSleepEnabled( void ); 901 bool checkSystemCanSleep( uint32_t sleepReason ); 902 bool checkSystemCanSustainFullWake( void ); 903 bool checkSystemCanAbortIdleSleep( void ); 904 void adjustPowerState( bool sleepASAP = false ); 905 bool attemptIdleSleepAbort( void ); 906 void setQuickSpinDownTimeout( void ); 907 void restoreUserSpinDownTimeout( void ); 908 909 bool shouldSleepOnClamshellClosed(void ); 910 bool shouldSleepOnRTCAlarmWake(void ); 911 void sendClientClamshellNotification( void ); 912 913 // Inform PMCPU of changes to state like lid, AC vs. battery 914 void informCPUStateChange( uint32_t type, uint32_t value ); 915 916 void dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 ); 917 void handlePowerNotification( UInt32 msg ); 918 919 IOReturn setPMSetting(const OSSymbol *, OSObject *); 920 921 void startIdleSleepTimer( uint32_t inMilliSeconds ); 922 void cancelIdleSleepTimer( void ); 923 uint32_t getTimeToIdleSleep( void ); 924 925 IOReturn setAggressiveness( 926 unsigned long type, 927 unsigned long value, 928 IOOptionBits options ); 929 930 void synchronizeAggressives( 931 queue_head_t * services, 932 const AggressivesRecord * array, 933 int count ); 934 935 void broadcastAggressives( 936 const AggressivesRecord * array, 937 int count ); 938 939 IOReturn setPMAssertionUserLevels(IOPMDriverAssertionType); 940 941 void publishSleepWakeUUID( bool shouldPublish ); 942 943 void evaluatePolicy( int stimulus, uint32_t arg = 0 ); 944 void requestFullWake( FullWakeReason reason ); 945 void willEnterFullWake( void ); 946 947 void evaluateAssertions(IOPMDriverAssertionType newAssertions, 948 IOPMDriverAssertionType oldAssertions); 949 950 void deregisterPMSettingObject( PMSettingObject * pmso ); 951 952 uint32_t checkForValidDebugData(const char *fname, vfs_context_t *ctx, 953 void *tmpBuf, struct vnode **vp); 954 void getFailureData(thread_t *thread, char *failureStr, size_t strLen); 955 void saveFailureData2File(); 956 void tracePhase2String(uint32_t tracePhase, const char **phaseString, const char **description); 957 void sleepWakeDebugMemAlloc(); 958 void sleepWakeDebugSpinDumpMemAlloc(); 959 errno_t sleepWakeDebugSaveFile(const char *name, char *buf, int len); 960 961 IOReturn changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, IOPMRequestTag tag ); 962 IOReturn changePowerStateWithTagToPriv( IOPMPowerStateIndex ordinal, IOPMRequestTag tag ); 963 IOReturn changePowerStateWithTagTo( IOPMPowerStateIndex ordinal, IOPMRequestTag tag ); 964 965 #if HIBERNATION 966 bool getSleepOption( const char * key, uint32_t * option ); 967 bool evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p, 968 int phase, uint32_t * hibMode ); 969 void evaluateSystemSleepPolicyEarly( void ); 970 void evaluateSystemSleepPolicyFinal( void ); 971 #endif /* HIBERNATION */ 972 973 bool latchDisplayWranglerTickle( bool latch ); 974 void setDisplayPowerOn( uint32_t options ); 975 976 void acceptSystemWakeEvents( uint32_t control ); 977 void systemDidNotSleep( void ); 978 void preventTransitionToUserActive( bool prevent ); 979 void setThermalState(OSObject *value); 980 void copySleepPreventersList(OSArray **idleSleepList, OSArray **systemSleepList); 981 void copySleepPreventersListWithID(OSArray **idleSleepList, OSArray **systemSleepList); 982 void recordRTCAlarm(const OSSymbol *type, OSObject *object); 983 void scheduleImmediateDebugWake( void ); 984 985 // Used to inform interested clients about low latency audio activity in the system 986 OSPtr<OSDictionary> lowLatencyAudioNotifierDict; 987 OSPtr<OSNumber> lowLatencyAudioNotifyStateVal; 988 OSPtr<OSNumber> lowLatencyAudioNotifyTimestampVal; 989 OSPtr<const OSSymbol> lowLatencyAudioNotifyStateSym; 990 OSPtr<const OSSymbol> lowLatencyAudioNotifyTimestampSym; 991 #endif /* XNU_KERNEL_PRIVATE */ 992 }; 993 994 #ifdef XNU_KERNEL_PRIVATE 995 class IORootParent : public IOService 996 { 997 OSDeclareFinalStructors(IORootParent); 998 999 public: 1000 static void initialize( void ); 1001 virtual OSPtr<OSObject> copyProperty( const char * aKey ) const APPLE_KEXT_OVERRIDE; 1002 bool start( IOService * nub ) APPLE_KEXT_OVERRIDE; 1003 void shutDownSystem( void ); 1004 void restartSystem( void ); 1005 void sleepSystem( void ); 1006 void dozeSystem( void ); 1007 void sleepToDoze( void ); 1008 void wakeSystem( void ); 1009 }; 1010 1011 void IOHibernateSystemInit(IOPMrootDomain * rootDomain); 1012 1013 IOReturn IOHibernateSystemSleep(void); 1014 IOReturn IOHibernateIOKitSleep(void); 1015 IOReturn IOHibernateSystemHasSlept(void); 1016 IOReturn IOHibernateSystemWake(void); 1017 IOReturn IOHibernateSystemPostWake(bool now); 1018 uint32_t IOHibernateWasScreenLocked(void); 1019 void IOHibernateSetScreenLocked(uint32_t lockState); 1020 void IOHibernateSetWakeCapabilities(uint32_t capability); 1021 void IOHibernateSystemRestart(void); 1022 1023 #endif /* XNU_KERNEL_PRIVATE */ 1024 1025 #endif /* _IOKIT_ROOTDOMAIN_H */ 1026