]> git.saurik.com Git - apple/xnu.git/blob - iokit/Kernel/IOPMrootDomain.cpp
projects / apple / xnu.git / blob
? search:


40a11e05eb85688a369bb73d1865ce7cae39f4cc
[apple/xnu.git] / iokit / Kernel / IOPMrootDomain.cpp
1 /*
2 * Copyright (c) 1998-2017 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 #include <libkern/c++/OSKext.h>
29 #include <libkern/c++/OSMetaClass.h>
30 #include <libkern/OSAtomic.h>
31 #include <libkern/OSDebug.h>
32 #include <IOKit/IOWorkLoop.h>
33 #include <IOKit/IOCommandGate.h>
34 #include <IOKit/IOPlatformExpert.h>
35 #include <IOKit/IOCPU.h>
36 #include <IOKit/IOKitDebug.h>
37 #include <IOKit/IOTimeStamp.h>
38 #include <IOKit/pwr_mgt/IOPMlog.h>
39 #include <IOKit/pwr_mgt/RootDomain.h>
40 #include <IOKit/pwr_mgt/IOPMPrivate.h>
41 #include <IOKit/IODeviceTreeSupport.h>
42 #include <IOKit/IOMessage.h>
43 #include <IOKit/IOReturn.h>
44 #include <IOKit/IONVRAM.h>
45 #include "RootDomainUserClient.h"
46 #include "IOKit/pwr_mgt/IOPowerConnection.h"
47 #include "IOPMPowerStateQueue.h"
48 #include <IOKit/IOCatalogue.h>
49 #include <IOKit/IOReportMacros.h>
50 #include "IOKitKernelInternal.h"
51 #if HIBERNATION
52 #include <IOKit/IOHibernatePrivate.h>
53 #endif
54 #include <console/video_console.h>
55 #include <sys/syslog.h>
56 #include <sys/sysctl.h>
57 #include <sys/vnode.h>
58 #include <sys/vnode_internal.h>
59 #include <sys/fcntl.h>
60 #include <os/log.h>
61 #include <pexpert/protos.h>
62 #include <AssertMacros.h>
63
64 #include <sys/time.h>
65 #include "IOServicePrivate.h" // _IOServiceInterestNotifier
66 #include "IOServicePMPrivate.h"
67
68 #include <libkern/zlib.h>
69
70 __BEGIN_DECLS
71 #include <mach/shared_region.h>
72 #include <kern/clock.h>
73 __END_DECLS
74
75 #if defined(__i386__) || defined(__x86_64__)
76 __BEGIN_DECLS
77 #include "IOPMrootDomainInternal.h"
78 __END_DECLS
79 #endif
80
81 #define kIOPMrootDomainClass "IOPMrootDomain"
82 #define LOG_PREFIX "PMRD: "
83
84
85 #define MSG(x...) \
86 do { kprintf(LOG_PREFIX x); IOLog(x); } while (false)
87
88 #define LOG(x...) \
89 do { kprintf(LOG_PREFIX x); } while (false)
90
91 #if DEVELOPMENT
92 #define DLOG(x...) do { \
93 if (kIOLogPMRootDomain & gIOKitDebug) \
94 kprintf(LOG_PREFIX x); \
95 else \
96 os_log(OS_LOG_DEFAULT, LOG_PREFIX x); \
97 } while (false)
98 #else
99 #define DLOG(x...) do { \
100 if (kIOLogPMRootDomain & gIOKitDebug) \
101 kprintf(LOG_PREFIX x); \
102 } while (false)
103 #endif
104
105 #define DMSG(x...) do { \
106 if (kIOLogPMRootDomain & gIOKitDebug) { \
107 kprintf(LOG_PREFIX x); \
108 } \
109 } while (false)
110
111
112 #define _LOG(x...)
113
114 #define CHECK_THREAD_CONTEXT
115 #ifdef CHECK_THREAD_CONTEXT
116 static IOWorkLoop * gIOPMWorkLoop = 0;
117 #define ASSERT_GATED() \
118 do { \
119 if (gIOPMWorkLoop && gIOPMWorkLoop->inGate() != true) { \
120 panic("RootDomain: not inside PM gate"); \
121 } \
122 } while(false)
123 #else
124 #define ASSERT_GATED()
125 #endif /* CHECK_THREAD_CONTEXT */
126
127 #define CAP_LOSS(c) \
128 (((_pendingCapability & (c)) == 0) && \
129 ((_currentCapability & (c)) != 0))
130
131 #define CAP_GAIN(c) \
132 (((_currentCapability & (c)) == 0) && \
133 ((_pendingCapability & (c)) != 0))
134
135 #define CAP_CHANGE(c) \
136 (((_currentCapability ^ _pendingCapability) & (c)) != 0)
137
138 #define CAP_CURRENT(c) \
139 ((_currentCapability & (c)) != 0)
140
141 #define CAP_HIGHEST(c) \
142 ((_highestCapability & (c)) != 0)
143
144 #if defined(__i386__) || defined(__x86_64__)
145 #define DARK_TO_FULL_EVALUATE_CLAMSHELL 1
146 #endif
147
148 // Event types for IOPMPowerStateQueue::submitPowerEvent()
149 enum {
150 kPowerEventFeatureChanged = 1, // 1
151 kPowerEventReceivedPowerNotification, // 2
152 kPowerEventSystemBootCompleted, // 3
153 kPowerEventSystemShutdown, // 4
154 kPowerEventUserDisabledSleep, // 5
155 kPowerEventRegisterSystemCapabilityClient, // 6
156 kPowerEventRegisterKernelCapabilityClient, // 7
157 kPowerEventPolicyStimulus, // 8
158 kPowerEventAssertionCreate, // 9
159 kPowerEventAssertionRelease, // 10
160 kPowerEventAssertionSetLevel, // 11
161 kPowerEventQueueSleepWakeUUID, // 12
162 kPowerEventPublishSleepWakeUUID, // 13
163 kPowerEventSetDisplayPowerOn // 14
164 };
165
166 // For evaluatePolicy()
167 // List of stimuli that affects the root domain policy.
168 enum {
169 kStimulusDisplayWranglerSleep, // 0
170 kStimulusDisplayWranglerWake, // 1
171 kStimulusAggressivenessChanged, // 2
172 kStimulusDemandSystemSleep, // 3
173 kStimulusAllowSystemSleepChanged, // 4
174 kStimulusDarkWakeActivityTickle, // 5
175 kStimulusDarkWakeEntry, // 6
176 kStimulusDarkWakeReentry, // 7
177 kStimulusDarkWakeEvaluate, // 8
178 kStimulusNoIdleSleepPreventers, // 9
179 kStimulusEnterUserActiveState, // 10
180 kStimulusLeaveUserActiveState // 11
181 };
182
183 extern "C" {
184 IOReturn OSKextSystemSleepOrWake( UInt32 );
185 }
186 extern "C" ppnum_t pmap_find_phys(pmap_t pmap, addr64_t va);
187 extern "C" addr64_t kvtophys(vm_offset_t va);
188 extern "C" boolean_t kdp_has_polled_corefile();
189
190 static void idleSleepTimerExpired( thread_call_param_t, thread_call_param_t );
191 static void notifySystemShutdown( IOService * root, uint32_t messageType );
192 static void handleAggressivesFunction( thread_call_param_t, thread_call_param_t );
193 static void pmEventTimeStamp(uint64_t *recordTS);
194
195 // "IOPMSetSleepSupported" callPlatformFunction name
196 static const OSSymbol *sleepSupportedPEFunction = NULL;
197 static const OSSymbol *sleepMessagePEFunction = NULL;
198
199 #define kIOSleepSupportedKey "IOSleepSupported"
200 #define kIOPMSystemCapabilitiesKey "System Capabilities"
201
202 #define kIORequestWranglerIdleKey "IORequestIdle"
203 #define kDefaultWranglerIdlePeriod 1000 // in milliseconds
204
205 #define kIOSleepWakeFailureString "SleepWakeFailureString"
206 #define kIOOSWatchdogFailureString "OSWatchdogFailureString"
207 #define kIOEFIBootRomFailureKey "wake-failure"
208
209 #define kRD_AllPowerSources (kIOPMSupportedOnAC \
210 | kIOPMSupportedOnBatt \
211 | kIOPMSupportedOnUPS)
212
213 #define kLocalEvalClamshellCommand (1 << 15)
214 #define kIdleSleepRetryInterval (3 * 60)
215
216 enum {
217 kWranglerPowerStateMin = 0,
218 kWranglerPowerStateSleep = 2,
219 kWranglerPowerStateDim = 3,
220 kWranglerPowerStateMax = 4
221 };
222
223 enum {
224 OFF_STATE = 0,
225 RESTART_STATE = 1,
226 SLEEP_STATE = 2,
227 ON_STATE = 3,
228 NUM_POWER_STATES
229 };
230
231 #define ON_POWER kIOPMPowerOn
232 #define RESTART_POWER kIOPMRestart
233 #define SLEEP_POWER kIOPMAuxPowerOn
234
235 static IOPMPowerState ourPowerStates[NUM_POWER_STATES] =
236 {
237 {1, 0, 0, 0, 0,0,0,0,0,0,0,0},
238 {1, kIOPMRestartCapability, kIOPMRestart, RESTART_POWER, 0,0,0,0,0,0,0,0},
239 {1, kIOPMSleepCapability, kIOPMSleep, SLEEP_POWER, 0,0,0,0,0,0,0,0},
240 {1, kIOPMPowerOn, kIOPMPowerOn, ON_POWER, 0,0,0,0,0,0,0,0}
241 };
242
243 #define kIOPMRootDomainWakeTypeSleepService "SleepService"
244 #define kIOPMRootDomainWakeTypeMaintenance "Maintenance"
245 #define kIOPMRootDomainWakeTypeSleepTimer "SleepTimer"
246 #define kIOPMrootDomainWakeTypeLowBattery "LowBattery"
247 #define kIOPMRootDomainWakeTypeUser "User"
248 #define kIOPMRootDomainWakeTypeAlarm "Alarm"
249 #define kIOPMRootDomainWakeTypeNetwork "Network"
250 #define kIOPMRootDomainWakeTypeHIDActivity "HID Activity"
251 #define kIOPMRootDomainWakeTypeNotification "Notification"
252 #define kIOPMRootDomainWakeTypeHibernateError "HibernateError"
253
254 // Special interest that entitles the interested client from receiving
255 // all system messages. Only used by powerd.
256 //
257 #define kIOPMSystemCapabilityInterest "IOPMSystemCapabilityInterest"
258
259 #define WAKEEVENT_LOCK() IOLockLock(wakeEventLock)
260 #define WAKEEVENT_UNLOCK() IOLockUnlock(wakeEventLock)
261
262 /*
263 * Aggressiveness
264 */
265 #define AGGRESSIVES_LOCK() IOLockLock(featuresDictLock)
266 #define AGGRESSIVES_UNLOCK() IOLockUnlock(featuresDictLock)
267
268 #define kAggressivesMinValue 1
269
270 enum {
271 kAggressivesStateBusy = 0x01,
272 kAggressivesStateQuickSpindown = 0x02
273 };
274
275 struct AggressivesRecord {
276 uint32_t flags;
277 uint32_t type;
278 uint32_t value;
279 };
280
281 struct AggressivesRequest {
282 queue_chain_t chain;
283 uint32_t options;
284 uint32_t dataType;
285 union {
286 IOService * service;
287 AggressivesRecord record;
288 } data;
289 };
290
291 enum {
292 kAggressivesRequestTypeService = 1,
293 kAggressivesRequestTypeRecord
294 };
295
296 enum {
297 kAggressivesOptionSynchronous = 0x00000001,
298 kAggressivesOptionQuickSpindownEnable = 0x00000100,
299 kAggressivesOptionQuickSpindownDisable = 0x00000200,
300 kAggressivesOptionQuickSpindownMask = 0x00000300
301 };
302
303 enum {
304 kAggressivesRecordFlagModified = 0x00000001,
305 kAggressivesRecordFlagMinValue = 0x00000002
306 };
307
308 // gDarkWakeFlags
309 enum {
310 kDarkWakeFlagHIDTickleEarly = 0x01, // hid tickle before gfx suppression
311 kDarkWakeFlagHIDTickleLate = 0x02, // hid tickle after gfx suppression
312 kDarkWakeFlagHIDTickleNone = 0x03, // hid tickle is not posted
313 kDarkWakeFlagHIDTickleMask = 0x03,
314 kDarkWakeFlagAlarmIsDark = 0x0100,
315 kDarkWakeFlagGraphicsPowerState1 = 0x0200,
316 kDarkWakeFlagAudioNotSuppressed = 0x0400
317 };
318
319 static IOPMrootDomain * gRootDomain;
320 static IONotifier * gSysPowerDownNotifier = 0;
321 static UInt32 gSleepOrShutdownPending = 0;
322 static UInt32 gWillShutdown = 0;
323 static UInt32 gPagingOff = 0;
324 static UInt32 gSleepWakeUUIDIsSet = false;
325 static uint32_t gAggressivesState = 0;
326 static uint32_t gHaltTimeMaxLog;
327 static uint32_t gHaltTimeMaxPanic;
328 IOLock * gHaltLogLock;
329 static char * gHaltLog;
330 enum { kHaltLogSize = 2048 };
331 static size_t gHaltLogPos;
332 static uint64_t gHaltStartTime;
333
334
335 uuid_string_t bootsessionuuid_string;
336
337 static uint32_t gDarkWakeFlags = kDarkWakeFlagHIDTickleNone;
338 static uint32_t gNoIdleFlag = 0;
339 static uint32_t gSwdPanic = 0;
340 static uint32_t gSwdSleepTimeout = 0;
341 static uint32_t gSwdWakeTimeout = 0;
342 static uint32_t gSwdSleepWakeTimeout = 0;
343 static PMStatsStruct gPMStats;
344
345
346 #if HIBERNATION
347 static IOPMSystemSleepPolicyHandler gSleepPolicyHandler = 0;
348 static IOPMSystemSleepPolicyVariables * gSleepPolicyVars = 0;
349 static void * gSleepPolicyTarget;
350 #endif
351
352 struct timeval gIOLastSleepTime;
353 struct timeval gIOLastWakeTime;
354
355 static char gWakeReasonString[128];
356 static bool gWakeReasonSysctlRegistered = false;
357 static AbsoluteTime gIOLastWakeAbsTime;
358 static AbsoluteTime gIOLastSleepAbsTime;
359 static AbsoluteTime gUserActiveAbsTime;
360 static AbsoluteTime gUserInactiveAbsTime;
361
362 #if defined(__i386__) || defined(__x86_64__)
363 static bool gSpinDumpBufferFull = false;
364 #endif
365
366 z_stream swd_zs;
367 vm_offset_t swd_zs_zmem;
368 //size_t swd_zs_zsize;
369 size_t swd_zs_zoffset;
370
371 static unsigned int gPMHaltBusyCount;
372 static unsigned int gPMHaltIdleCount;
373 static int gPMHaltDepth;
374 static uint32_t gPMHaltMessageType;
375 static IOLock * gPMHaltLock = 0;
376 static OSArray * gPMHaltArray = 0;
377 static const OSSymbol * gPMHaltClientAcknowledgeKey = 0;
378 static bool gPMQuiesced;
379
380 // Constants used as arguments to IOPMrootDomain::informCPUStateChange
381 #define kCPUUnknownIndex 9999999
382 enum {
383 kInformAC = 0,
384 kInformLid = 1,
385 kInformableCount = 2
386 };
387
388 const OSSymbol *gIOPMStatsResponseTimedOut;
389 const OSSymbol *gIOPMStatsResponseCancel;
390 const OSSymbol *gIOPMStatsResponseSlow;
391 const OSSymbol *gIOPMStatsResponsePrompt;
392 const OSSymbol *gIOPMStatsDriverPSChangeSlow;
393
394 #define kBadPMFeatureID 0
395
396 /*
397 * PMSettingHandle
398 * Opaque handle passed to clients of registerPMSettingController()
399 */
400 class PMSettingHandle : public OSObject
401 {
402 OSDeclareFinalStructors( PMSettingHandle )
403 friend class PMSettingObject;
404
405 private:
406 PMSettingObject *pmso;
407 void free(void) APPLE_KEXT_OVERRIDE;
408 };
409
410 /*
411 * PMSettingObject
412 * Internal object to track each PM setting controller
413 */
414 class PMSettingObject : public OSObject
415 {
416 OSDeclareFinalStructors( PMSettingObject )
417 friend class IOPMrootDomain;
418
419 private:
420 queue_head_t calloutQueue;
421 thread_t waitThread;
422 IOPMrootDomain *parent;
423 PMSettingHandle *pmsh;
424 IOPMSettingControllerCallback func;
425 OSObject *target;
426 uintptr_t refcon;
427 uint32_t *publishedFeatureID;
428 uint32_t settingCount;
429 bool disabled;
430
431 void free(void) APPLE_KEXT_OVERRIDE;
432
433 public:
434 static PMSettingObject *pmSettingObject(
435 IOPMrootDomain *parent_arg,
436 IOPMSettingControllerCallback handler_arg,
437 OSObject *target_arg,
438 uintptr_t refcon_arg,
439 uint32_t supportedPowerSources,
440 const OSSymbol *settings[],
441 OSObject **handle_obj);
442
443 void dispatchPMSetting(const OSSymbol *type, OSObject *object);
444 void clientHandleFreed(void);
445 };
446
447 struct PMSettingCallEntry {
448 queue_chain_t link;
449 thread_t thread;
450 };
451
452 #define PMSETTING_LOCK() IOLockLock(settingsCtrlLock)
453 #define PMSETTING_UNLOCK() IOLockUnlock(settingsCtrlLock)
454 #define PMSETTING_WAIT(p) IOLockSleep(settingsCtrlLock, p, THREAD_UNINT)
455 #define PMSETTING_WAKEUP(p) IOLockWakeup(settingsCtrlLock, p, true)
456
457 /*
458 * PMTraceWorker
459 * Internal helper object for logging trace points to RTC
460 * IOPMrootDomain and only IOPMrootDomain should instantiate
461 * exactly one of these.
462 */
463
464 typedef void (*IOPMTracePointHandler)(
465 void * target, uint32_t code, uint32_t data );
466
467 class PMTraceWorker : public OSObject
468 {
469 OSDeclareDefaultStructors(PMTraceWorker)
470 public:
471 typedef enum { kPowerChangeStart, kPowerChangeCompleted } change_t;
472
473 static PMTraceWorker *tracer( IOPMrootDomain * );
474 void tracePCIPowerChange(change_t, IOService *, uint32_t, uint32_t);
475 void tracePoint(uint8_t phase);
476 void traceDetail(uint32_t detail);
477 void traceComponentWakeProgress(uint32_t component, uint32_t data);
478 int recordTopLevelPCIDevice(IOService *);
479 void RTC_TRACE(void);
480 virtual bool serialize(OSSerialize *s) const APPLE_KEXT_OVERRIDE;
481
482 IOPMTracePointHandler tracePointHandler;
483 void * tracePointTarget;
484 uint64_t getPMStatusCode();
485 uint8_t getTracePhase();
486 uint32_t getTraceData();
487 private:
488 IOPMrootDomain *owner;
489 IOLock *pmTraceWorkerLock;
490 OSArray *pciDeviceBitMappings;
491
492 uint8_t addedToRegistry;
493 uint8_t tracePhase;
494 uint32_t traceData32;
495 uint8_t loginWindowData;
496 uint8_t coreDisplayData;
497 uint8_t coreGraphicsData;
498 };
499
500 /*
501 * PMAssertionsTracker
502 * Tracks kernel and user space PM assertions
503 */
504 class PMAssertionsTracker : public OSObject
505 {
506 OSDeclareFinalStructors(PMAssertionsTracker)
507 public:
508 static PMAssertionsTracker *pmAssertionsTracker( IOPMrootDomain * );
509
510 IOReturn createAssertion(IOPMDriverAssertionType, IOPMDriverAssertionLevel, IOService *, const char *, IOPMDriverAssertionID *);
511 IOReturn releaseAssertion(IOPMDriverAssertionID);
512 IOReturn setAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
513 IOReturn setUserAssertionLevels(IOPMDriverAssertionType);
514
515 OSArray *copyAssertionsArray(void);
516 IOPMDriverAssertionType getActivatedAssertions(void);
517 IOPMDriverAssertionLevel getAssertionLevel(IOPMDriverAssertionType);
518
519 IOReturn handleCreateAssertion(OSData *);
520 IOReturn handleReleaseAssertion(IOPMDriverAssertionID);
521 IOReturn handleSetAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
522 IOReturn handleSetUserAssertionLevels(void * arg0);
523 void publishProperties(void);
524
525 private:
526 typedef struct {
527 IOPMDriverAssertionID id;
528 IOPMDriverAssertionType assertionBits;
529 uint64_t createdTime;
530 uint64_t modifiedTime;
531 const OSSymbol *ownerString;
532 IOService *ownerService;
533 uint64_t registryEntryID;
534 IOPMDriverAssertionLevel level;
535 } PMAssertStruct;
536
537 uint32_t tabulateProducerCount;
538 uint32_t tabulateConsumerCount;
539
540 PMAssertStruct *detailsForID(IOPMDriverAssertionID, int *);
541 void tabulate(void);
542
543 IOPMrootDomain *owner;
544 OSArray *assertionsArray;
545 IOLock *assertionsArrayLock;
546 IOPMDriverAssertionID issuingUniqueID __attribute__((aligned(8))); /* aligned for atomic access */
547 IOPMDriverAssertionType assertionsKernel;
548 IOPMDriverAssertionType assertionsUser;
549 IOPMDriverAssertionType assertionsCombined;
550 };
551
552 OSDefineMetaClassAndFinalStructors(PMAssertionsTracker, OSObject);
553
554 /*
555 * PMHaltWorker
556 * Internal helper object for Shutdown/Restart notifications.
557 */
558 #define kPMHaltMaxWorkers 8
559 #define kPMHaltTimeoutMS 100
560
561 class PMHaltWorker : public OSObject
562 {
563 OSDeclareFinalStructors( PMHaltWorker )
564
565 public:
566 IOService * service; // service being worked on
567 AbsoluteTime startTime; // time when work started
568 int depth; // work on nubs at this PM-tree depth
569 int visits; // number of nodes visited (debug)
570 IOLock * lock;
571 bool timeout; // service took too long
572
573 static PMHaltWorker * worker( void );
574 static void main( void * arg, wait_result_t waitResult );
575 static void work( PMHaltWorker * me );
576 static void checkTimeout( PMHaltWorker * me, AbsoluteTime * now );
577 virtual void free( void ) APPLE_KEXT_OVERRIDE;
578 };
579
580 OSDefineMetaClassAndFinalStructors( PMHaltWorker, OSObject )
581
582
583 #define super IOService
584 OSDefineMetaClassAndFinalStructors(IOPMrootDomain, IOService)
585
586 static void IOPMRootDomainWillShutdown(void)
587 {
588 if (OSCompareAndSwap(0, 1, &gWillShutdown))
589 {
590 OSKext::willShutdown();
591 for (int i = 0; i < 100; i++)
592 {
593 if (OSCompareAndSwap(0, 1, &gSleepOrShutdownPending)) break;
594 IOSleep( 100 );
595 }
596 }
597 }
598
599 extern "C" IONotifier * registerSleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
600 {
601 return gRootDomain->registerInterest( gIOGeneralInterest, handler, self, ref );
602 }
603
604 extern "C" IONotifier * registerPrioritySleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
605 {
606 return gRootDomain->registerInterest( gIOPriorityPowerStateInterest, handler, self, ref );
607 }
608
609 extern "C" IOReturn acknowledgeSleepWakeNotification(void * PMrefcon)
610 {
611 return gRootDomain->allowPowerChange ( (unsigned long)PMrefcon );
612 }
613
614 extern "C" IOReturn vetoSleepWakeNotification(void * PMrefcon)
615 {
616 return gRootDomain->cancelPowerChange ( (unsigned long)PMrefcon );
617 }
618
619 extern "C" IOReturn rootDomainRestart ( void )
620 {
621 return gRootDomain->restartSystem();
622 }
623
624 extern "C" IOReturn rootDomainShutdown ( void )
625 {
626 return gRootDomain->shutdownSystem();
627 }
628
629 static void halt_log_putc(char c)
630 {
631 if (gHaltLogPos >= (kHaltLogSize - 2)) return;
632 gHaltLog[gHaltLogPos++] = c;
633 }
634
635 extern "C" void
636 _doprnt_log(const char *fmt,
637 va_list *argp,
638 void (*putc)(char),
639 int radix);
640
641 static int
642 halt_log(const char *fmt, ...)
643 {
644 va_list listp;
645
646 va_start(listp, fmt);
647 _doprnt_log(fmt, &listp, &halt_log_putc, 16);
648 va_end(listp);
649
650 return (0);
651 }
652
653 extern "C" void
654 halt_log_enter(const char * what, const void * pc, uint64_t time)
655 {
656 uint64_t nano, millis;
657
658 if (!gHaltLog) return;
659 absolutetime_to_nanoseconds(time, &nano);
660 millis = nano / NSEC_PER_MSEC;
661 if (millis < 100) return;
662
663 IOLockLock(gHaltLogLock);
664 if (pc) {
665 halt_log("%s: %qd ms @ 0x%lx, ", what, millis, VM_KERNEL_UNSLIDE(pc));
666 OSKext::printKextsInBacktrace((vm_offset_t *) &pc, 1, &halt_log,
667 OSKext::kPrintKextsLock | OSKext::kPrintKextsUnslide | OSKext::kPrintKextsTerse);
668 }
669 else {
670 halt_log("%s: %qd ms\n", what, millis);
671 }
672
673 gHaltLog[gHaltLogPos] = 0;
674 IOLockUnlock(gHaltLogLock);
675 }
676
677 extern uint32_t gFSState;
678
679 extern "C" void IOSystemShutdownNotification(int stage)
680 {
681 uint64_t startTime;
682
683 if (kIOSystemShutdownNotificationStageRootUnmount == stage)
684 {
685 #if !CONFIG_EMBEDDED
686 uint64_t nano, millis;
687 startTime = mach_absolute_time();
688 IOService::getPlatform()->waitQuiet(30 * NSEC_PER_SEC);
689 absolutetime_to_nanoseconds(mach_absolute_time() - startTime, &nano);
690 millis = nano / NSEC_PER_MSEC;
691 if (gHaltTimeMaxLog && (millis >= gHaltTimeMaxLog))
692 {
693 printf("waitQuiet() for unmount %qd ms\n", millis);
694 }
695 #endif
696 return;
697 }
698
699 assert(kIOSystemShutdownNotificationStageProcessExit == stage);
700
701 IOLockLock(gHaltLogLock);
702 if (!gHaltLog)
703 {
704 gHaltLog = IONew(char, kHaltLogSize);
705 gHaltStartTime = mach_absolute_time();
706 if (gHaltLog) halt_log_putc('\n');
707 }
708 IOLockUnlock(gHaltLogLock);
709
710 startTime = mach_absolute_time();
711 IOPMRootDomainWillShutdown();
712 halt_log_enter("IOPMRootDomainWillShutdown", 0, mach_absolute_time() - startTime);
713 #if HIBERNATION
714 startTime = mach_absolute_time();
715 IOHibernateSystemPostWake(true);
716 halt_log_enter("IOHibernateSystemPostWake", 0, mach_absolute_time() - startTime);
717 #endif
718 if (OSCompareAndSwap(0, 1, &gPagingOff))
719 {
720 #if !CONFIG_EMBEDDED
721 gRootDomain->handlePlatformHaltRestart(kPEPagingOff);
722 #endif
723 }
724 }
725
726
727 extern "C" int sync_internal(void);
728
729 /*
730 A device is always in the highest power state which satisfies its driver,
731 its policy-maker, and any power children it has, but within the constraint
732 of the power state provided by its parent. The driver expresses its desire by
733 calling changePowerStateTo(), the policy-maker expresses its desire by calling
734 changePowerStateToPriv(), and the children express their desires by calling
735 requestPowerDomainState().
736
737 The Root Power Domain owns the policy for idle and demand sleep for the system.
738 It is a power-managed IOService just like the others in the system.
739 It implements several power states which map to what we see as Sleep and On.
740
741 The sleep policy is as follows:
742 1. Sleep is prevented if the case is open so that nobody will think the machine
743 is off and plug/unplug cards.
744 2. Sleep is prevented if the sleep timeout slider in the prefs panel is zero.
745 3. System cannot Sleep if some object in the tree is in a power state marked
746 kIOPMPreventSystemSleep.
747
748 These three conditions are enforced using the "driver clamp" by calling
749 changePowerStateTo(). For example, if the case is opened,
750 changePowerStateTo(ON_STATE) is called to hold the system on regardless
751 of the desires of the children of the root or the state of the other clamp.
752
753 Demand Sleep is initiated by pressing the front panel power button, closing
754 the clamshell, or selecting the menu item. In this case the root's parent
755 actually initiates the power state change so that the root domain has no
756 choice and does not give applications the opportunity to veto the change.
757
758 Idle Sleep occurs if no objects in the tree are in a state marked
759 kIOPMPreventIdleSleep. When this is true, the root's children are not holding
760 the root on, so it sets the "policy-maker clamp" by calling
761 changePowerStateToPriv(ON_STATE) to hold itself on until the sleep timer expires.
762 This timer is set for the difference between the sleep timeout slider and the
763 display dim timeout slider. When the timer expires, it releases its clamp and
764 now nothing is holding it awake, so it falls asleep.
765
766 Demand sleep is prevented when the system is booting. When preferences are
767 transmitted by the loginwindow at the end of boot, a flag is cleared,
768 and this allows subsequent Demand Sleep.
769 */
770
771 //******************************************************************************
772
773 IOPMrootDomain * IOPMrootDomain::construct( void )
774 {
775 IOPMrootDomain *root;
776
777 root = new IOPMrootDomain;
778 if( root)
779 root->init();
780
781 return( root );
782 }
783
784 //******************************************************************************
785 // updateConsoleUsersCallout
786 //
787 //******************************************************************************
788
789 static void updateConsoleUsersCallout(thread_call_param_t p0, thread_call_param_t p1)
790 {
791 IOPMrootDomain * rootDomain = (IOPMrootDomain *) p0;
792 rootDomain->updateConsoleUsers();
793 }
794
795 void IOPMrootDomain::updateConsoleUsers(void)
796 {
797 IOService::updateConsoleUsers(NULL, kIOMessageSystemHasPoweredOn);
798 if (tasksSuspended)
799 {
800 tasksSuspended = FALSE;
801 tasks_system_suspend(tasksSuspended);
802 }
803 }
804
805 //******************************************************************************
806
807 static void disk_sync_callout( thread_call_param_t p0, thread_call_param_t p1 )
808 {
809 IOService * rootDomain = (IOService *) p0;
810 uint32_t notifyRef = (uint32_t)(uintptr_t) p1;
811 uint32_t powerState = rootDomain->getPowerState();
812
813 DLOG("disk_sync_callout ps=%u\n", powerState);
814
815 if (ON_STATE == powerState)
816 {
817 sync_internal();
818
819 #if HIBERNATION
820 // Block sleep until trim issued on previous wake path is completed.
821 IOHibernateSystemPostWake(true);
822 #endif
823 }
824 #if HIBERNATION
825 else
826 {
827 IOHibernateSystemPostWake(false);
828
829 if (gRootDomain)
830 gRootDomain->sleepWakeDebugSaveSpinDumpFile();
831 }
832 #endif
833
834 rootDomain->allowPowerChange(notifyRef);
835 DLOG("disk_sync_callout finish\n");
836 }
837
838 //******************************************************************************
839 static UInt32 computeDeltaTimeMS( const AbsoluteTime * startTime, AbsoluteTime * elapsedTime )
840 {
841 AbsoluteTime endTime;
842 UInt64 nano = 0;
843
844 clock_get_uptime(&endTime);
845 if (CMP_ABSOLUTETIME(&endTime, startTime) <= 0) *elapsedTime = 0;
846 else
847 {
848 SUB_ABSOLUTETIME(&endTime, startTime);
849 absolutetime_to_nanoseconds(endTime, &nano);
850 *elapsedTime = endTime;
851 }
852
853 return (UInt32)(nano / NSEC_PER_MSEC);
854 }
855
856 //******************************************************************************
857
858 static int
859 sysctl_sleepwaketime SYSCTL_HANDLER_ARGS
860 {
861 struct timeval *swt = (struct timeval *)arg1;
862 struct proc *p = req->p;
863
864 if (p == kernproc) {
865 return sysctl_io_opaque(req, swt, sizeof(*swt), NULL);
866 } else if(proc_is64bit(p)) {
867 struct user64_timeval t = {};
868 t.tv_sec = swt->tv_sec;
869 t.tv_usec = swt->tv_usec;
870 return sysctl_io_opaque(req, &t, sizeof(t), NULL);
871 } else {
872 struct user32_timeval t = {};
873 t.tv_sec = swt->tv_sec;
874 t.tv_usec = swt->tv_usec;
875 return sysctl_io_opaque(req, &t, sizeof(t), NULL);
876 }
877 }
878
879 static SYSCTL_PROC(_kern, OID_AUTO, sleeptime,
880 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
881 &gIOLastSleepTime, 0, sysctl_sleepwaketime, "S,timeval", "");
882
883 static SYSCTL_PROC(_kern, OID_AUTO, waketime,
884 CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
885 &gIOLastWakeTime, 0, sysctl_sleepwaketime, "S,timeval", "");
886
887 SYSCTL_QUAD(_kern, OID_AUTO, wake_abs_time, CTLFLAG_RD|CTLFLAG_LOCKED, &gIOLastWakeAbsTime, "");
888 SYSCTL_QUAD(_kern, OID_AUTO, sleep_abs_time, CTLFLAG_RD|CTLFLAG_LOCKED, &gIOLastSleepAbsTime, "");
889 SYSCTL_QUAD(_kern, OID_AUTO, useractive_abs_time, CTLFLAG_RD|CTLFLAG_LOCKED, &gUserActiveAbsTime, "");
890 SYSCTL_QUAD(_kern, OID_AUTO, userinactive_abs_time, CTLFLAG_RD|CTLFLAG_LOCKED, &gUserInactiveAbsTime, "");
891
892 static int
893 sysctl_willshutdown
894 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
895 {
896 int new_value, changed;
897 int error = sysctl_io_number(req, gWillShutdown, sizeof(int), &new_value, &changed);
898 if (changed) {
899 if (!gWillShutdown && (new_value == 1)) {
900 IOPMRootDomainWillShutdown();
901 } else
902 error = EINVAL;
903 }
904 return(error);
905 }
906
907 static SYSCTL_PROC(_kern, OID_AUTO, willshutdown,
908 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
909 0, 0, sysctl_willshutdown, "I", "");
910
911 extern struct sysctl_oid sysctl__kern_iokittest;
912 extern struct sysctl_oid sysctl__debug_iokit;
913
914 #if !CONFIG_EMBEDDED
915
916 static int
917 sysctl_progressmeterenable
918 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
919 {
920 int error;
921 int new_value, changed;
922
923 error = sysctl_io_number(req, vc_progressmeter_enable, sizeof(int), &new_value, &changed);
924
925 if (changed) vc_enable_progressmeter(new_value);
926
927 return (error);
928 }
929
930 static int
931 sysctl_progressmeter
932 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
933 {
934 int error;
935 int new_value, changed;
936
937 error = sysctl_io_number(req, vc_progressmeter_value, sizeof(int), &new_value, &changed);
938
939 if (changed) vc_set_progressmeter(new_value);
940
941 return (error);
942 }
943
944 static SYSCTL_PROC(_kern, OID_AUTO, progressmeterenable,
945 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
946 0, 0, sysctl_progressmeterenable, "I", "");
947
948 static SYSCTL_PROC(_kern, OID_AUTO, progressmeter,
949 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
950 0, 0, sysctl_progressmeter, "I", "");
951
952 #endif /* !CONFIG_EMBEDDED */
953
954
955
956 static int
957 sysctl_consoleoptions
958 (__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
959 {
960 int error, changed;
961 uint32_t new_value;
962
963 error = sysctl_io_number(req, vc_user_options.options, sizeof(uint32_t), &new_value, &changed);
964
965 if (changed) vc_user_options.options = new_value;
966
967 return (error);
968 }
969
970 static SYSCTL_PROC(_kern, OID_AUTO, consoleoptions,
971 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
972 0, 0, sysctl_consoleoptions, "I", "");
973
974
975 static int
976 sysctl_progressoptions SYSCTL_HANDLER_ARGS
977 {
978 return sysctl_io_opaque(req, &vc_user_options, sizeof(vc_user_options), NULL);
979 }
980
981 static SYSCTL_PROC(_kern, OID_AUTO, progressoptions,
982 CTLTYPE_STRUCT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
983 NULL, 0, sysctl_progressoptions, "S,vc_progress_user_options", "");
984
985
986 static int
987 sysctl_wakereason SYSCTL_HANDLER_ARGS
988 {
989 char wr[ sizeof(gWakeReasonString) ];
990
991 wr[0] = '\0';
992 if (gRootDomain)
993 gRootDomain->copyWakeReasonString(wr, sizeof(wr));
994
995 return sysctl_io_string(req, wr, 0, 0, NULL);
996 }
997
998 SYSCTL_PROC(_kern, OID_AUTO, wakereason,
999 CTLTYPE_STRING| CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
1000 NULL, 0, sysctl_wakereason, "A", "wakereason");
1001
1002 static int
1003 sysctl_targettype SYSCTL_HANDLER_ARGS
1004 {
1005 IOService * root;
1006 OSObject * obj;
1007 OSData * data;
1008 char tt[32];
1009
1010 tt[0] = '\0';
1011 root = IOService::getServiceRoot();
1012 if (root && (obj = root->copyProperty(gIODTTargetTypeKey)))
1013 {
1014 if ((data = OSDynamicCast(OSData, obj)))
1015 {
1016 strlcpy(tt, (const char *) data->getBytesNoCopy(), sizeof(tt));
1017 }
1018 obj->release();
1019 }
1020 return sysctl_io_string(req, tt, 0, 0, NULL);
1021 }
1022
1023 SYSCTL_PROC(_hw, OID_AUTO, targettype,
1024 CTLTYPE_STRING| CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
1025 NULL, 0, sysctl_targettype, "A", "targettype");
1026
1027 static SYSCTL_INT(_debug, OID_AUTO, darkwake, CTLFLAG_RW, &gDarkWakeFlags, 0, "");
1028 static SYSCTL_INT(_debug, OID_AUTO, noidle, CTLFLAG_RW, &gNoIdleFlag, 0, "");
1029 static SYSCTL_INT(_debug, OID_AUTO, swd_sleep_timeout, CTLFLAG_RW, &gSwdSleepTimeout, 0, "");
1030 static SYSCTL_INT(_debug, OID_AUTO, swd_wake_timeout, CTLFLAG_RW, &gSwdWakeTimeout, 0, "");
1031 static SYSCTL_INT(_debug, OID_AUTO, swd_timeout, CTLFLAG_RW, &gSwdSleepWakeTimeout, 0, "");
1032 static SYSCTL_INT(_debug, OID_AUTO, swd_panic, CTLFLAG_RW, &gSwdPanic, 0, "");
1033
1034
1035 static const OSSymbol * gIOPMSettingAutoWakeCalendarKey;
1036 static const OSSymbol * gIOPMSettingAutoWakeSecondsKey;
1037 static const OSSymbol * gIOPMSettingDebugWakeRelativeKey;
1038 static const OSSymbol * gIOPMSettingMaintenanceWakeCalendarKey;
1039 static const OSSymbol * gIOPMSettingSleepServiceWakeCalendarKey;
1040 static const OSSymbol * gIOPMSettingSilentRunningKey;
1041 static const OSSymbol * gIOPMUserTriggeredFullWakeKey;
1042 static const OSSymbol * gIOPMUserIsActiveKey;
1043
1044 //******************************************************************************
1045 // start
1046 //
1047 //******************************************************************************
1048
1049 #define kRootDomainSettingsCount 17
1050
1051 bool IOPMrootDomain::start( IOService * nub )
1052 {
1053 OSIterator *psIterator;
1054 OSDictionary *tmpDict;
1055 IORootParent * patriarch;
1056
1057 super::start(nub);
1058
1059 gRootDomain = this;
1060 gIOPMSettingAutoWakeCalendarKey = OSSymbol::withCString(kIOPMSettingAutoWakeCalendarKey);
1061 gIOPMSettingAutoWakeSecondsKey = OSSymbol::withCString(kIOPMSettingAutoWakeSecondsKey);
1062 gIOPMSettingDebugWakeRelativeKey = OSSymbol::withCString(kIOPMSettingDebugWakeRelativeKey);
1063 gIOPMSettingMaintenanceWakeCalendarKey = OSSymbol::withCString(kIOPMSettingMaintenanceWakeCalendarKey);
1064 gIOPMSettingSleepServiceWakeCalendarKey = OSSymbol::withCString(kIOPMSettingSleepServiceWakeCalendarKey);
1065 gIOPMSettingSilentRunningKey = OSSymbol::withCStringNoCopy(kIOPMSettingSilentRunningKey);
1066 gIOPMUserTriggeredFullWakeKey = OSSymbol::withCStringNoCopy(kIOPMUserTriggeredFullWakeKey);
1067 gIOPMUserIsActiveKey = OSSymbol::withCStringNoCopy(kIOPMUserIsActiveKey);
1068
1069 gIOPMStatsResponseTimedOut = OSSymbol::withCString(kIOPMStatsResponseTimedOut);
1070 gIOPMStatsResponseCancel = OSSymbol::withCString(kIOPMStatsResponseCancel);
1071 gIOPMStatsResponseSlow = OSSymbol::withCString(kIOPMStatsResponseSlow);
1072 gIOPMStatsResponsePrompt = OSSymbol::withCString(kIOPMStatsResponsePrompt);
1073 gIOPMStatsDriverPSChangeSlow = OSSymbol::withCString(kIOPMStatsDriverPSChangeSlow);
1074
1075 sleepSupportedPEFunction = OSSymbol::withCString("IOPMSetSleepSupported");
1076 sleepMessagePEFunction = OSSymbol::withCString("IOPMSystemSleepMessage");
1077
1078 const OSSymbol *settingsArr[kRootDomainSettingsCount] =
1079 {
1080 OSSymbol::withCString(kIOPMSettingSleepOnPowerButtonKey),
1081 gIOPMSettingAutoWakeSecondsKey,
1082 OSSymbol::withCString(kIOPMSettingAutoPowerSecondsKey),
1083 gIOPMSettingAutoWakeCalendarKey,
1084 OSSymbol::withCString(kIOPMSettingAutoPowerCalendarKey),
1085 gIOPMSettingDebugWakeRelativeKey,
1086 OSSymbol::withCString(kIOPMSettingDebugPowerRelativeKey),
1087 OSSymbol::withCString(kIOPMSettingWakeOnRingKey),
1088 OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey),
1089 OSSymbol::withCString(kIOPMSettingWakeOnClamshellKey),
1090 OSSymbol::withCString(kIOPMSettingWakeOnACChangeKey),
1091 OSSymbol::withCString(kIOPMSettingTimeZoneOffsetKey),
1092 OSSymbol::withCString(kIOPMSettingDisplaySleepUsesDimKey),
1093 OSSymbol::withCString(kIOPMSettingMobileMotionModuleKey),
1094 OSSymbol::withCString(kIOPMSettingGraphicsSwitchKey),
1095 OSSymbol::withCString(kIOPMStateConsoleShutdown),
1096 gIOPMSettingSilentRunningKey
1097 };
1098
1099 PE_parse_boot_argn("darkwake", &gDarkWakeFlags, sizeof(gDarkWakeFlags));
1100 PE_parse_boot_argn("noidle", &gNoIdleFlag, sizeof(gNoIdleFlag));
1101 PE_parse_boot_argn("swd_sleeptimeout", &gSwdSleepTimeout, sizeof(gSwdSleepTimeout));
1102 PE_parse_boot_argn("swd_waketimeout", &gSwdWakeTimeout, sizeof(gSwdWakeTimeout));
1103 PE_parse_boot_argn("swd_timeout", &gSwdSleepWakeTimeout, sizeof(gSwdSleepWakeTimeout));
1104 PE_parse_boot_argn("haltmspanic", &gHaltTimeMaxPanic, sizeof(gHaltTimeMaxPanic));
1105 PE_parse_boot_argn("haltmslog", &gHaltTimeMaxLog, sizeof(gHaltTimeMaxLog));
1106
1107 queue_init(&aggressivesQueue);
1108 aggressivesThreadCall = thread_call_allocate(handleAggressivesFunction, this);
1109 aggressivesData = OSData::withCapacity(
1110 sizeof(AggressivesRecord) * (kPMLastAggressivenessType + 4));
1111
1112 featuresDictLock = IOLockAlloc();
1113 settingsCtrlLock = IOLockAlloc();
1114 wakeEventLock = IOLockAlloc();
1115 gHaltLogLock = IOLockAlloc();
1116 setPMRootDomain(this);
1117
1118 extraSleepTimer = thread_call_allocate(
1119 idleSleepTimerExpired,
1120 (thread_call_param_t) this);
1121
1122 diskSyncCalloutEntry = thread_call_allocate(
1123 &disk_sync_callout,
1124 (thread_call_param_t) this);
1125 updateConsoleUsersEntry = thread_call_allocate(
1126 &updateConsoleUsersCallout,
1127 (thread_call_param_t) this);
1128
1129 #if DARK_TO_FULL_EVALUATE_CLAMSHELL
1130 fullWakeThreadCall = thread_call_allocate(
1131 OSMemberFunctionCast(thread_call_func_t, this,
1132 &IOPMrootDomain::fullWakeDelayedWork),
1133 (thread_call_param_t) this);
1134 #endif
1135
1136 setProperty(kIOSleepSupportedKey, true);
1137
1138 bzero(&gPMStats, sizeof(gPMStats));
1139
1140 pmTracer = PMTraceWorker::tracer(this);
1141
1142 pmAssertions = PMAssertionsTracker::pmAssertionsTracker(this);
1143
1144 userDisabledAllSleep = false;
1145 systemBooting = true;
1146 idleSleepEnabled = false;
1147 sleepSlider = 0;
1148 idleSleepTimerPending = false;
1149 wrangler = NULL;
1150 clamshellClosed = false;
1151 clamshellExists = false;
1152 clamshellDisabled = true;
1153 acAdaptorConnected = true;
1154 clamshellSleepDisabled = false;
1155 gWakeReasonString[0] = '\0';
1156
1157 // Initialize to user active.
1158 // Will never transition to user inactive w/o wrangler.
1159 fullWakeReason = kFullWakeReasonLocalUser;
1160 userIsActive = userWasActive = true;
1161 clock_get_uptime(&gUserActiveAbsTime);
1162 setProperty(gIOPMUserIsActiveKey, kOSBooleanTrue);
1163
1164 // Set the default system capabilities at boot.
1165 _currentCapability = kIOPMSystemCapabilityCPU |
1166 kIOPMSystemCapabilityGraphics |
1167 kIOPMSystemCapabilityAudio |
1168 kIOPMSystemCapabilityNetwork;
1169
1170 _pendingCapability = _currentCapability;
1171 _desiredCapability = _currentCapability;
1172 _highestCapability = _currentCapability;
1173 setProperty(kIOPMSystemCapabilitiesKey, _currentCapability, 64);
1174
1175 queuedSleepWakeUUIDString = NULL;
1176 initializeBootSessionUUID();
1177 pmStatsAppResponses = OSArray::withCapacity(5);
1178 _statsNameKey = OSSymbol::withCString(kIOPMStatsNameKey);
1179 _statsPIDKey = OSSymbol::withCString(kIOPMStatsPIDKey);
1180 _statsTimeMSKey = OSSymbol::withCString(kIOPMStatsTimeMSKey);
1181 _statsResponseTypeKey = OSSymbol::withCString(kIOPMStatsApplicationResponseTypeKey);
1182 _statsMessageTypeKey = OSSymbol::withCString(kIOPMStatsMessageTypeKey);
1183 _statsPowerCapsKey = OSSymbol::withCString(kIOPMStatsPowerCapabilityKey);
1184 assertOnWakeSecs = -1; // Invalid value to prevent updates
1185
1186 pmStatsLock = IOLockAlloc();
1187 idxPMCPUClamshell = kCPUUnknownIndex;
1188 idxPMCPULimitedPower = kCPUUnknownIndex;
1189
1190 tmpDict = OSDictionary::withCapacity(1);
1191 setProperty(kRootDomainSupportedFeatures, tmpDict);
1192 tmpDict->release();
1193
1194 settingsCallbacks = OSDictionary::withCapacity(1);
1195
1196 // Create a list of the valid PM settings that we'll relay to
1197 // interested clients in setProperties() => setPMSetting()
1198 allowedPMSettings = OSArray::withObjects(
1199 (const OSObject **)settingsArr,
1200 kRootDomainSettingsCount,
1201 0);
1202
1203 // List of PM settings that should not automatically publish itself
1204 // as a feature when registered by a listener.
1205 noPublishPMSettings = OSArray::withObjects(
1206 (const OSObject **) &gIOPMSettingSilentRunningKey, 1, 0);
1207
1208 fPMSettingsDict = OSDictionary::withCapacity(5);
1209 preventIdleSleepList = OSSet::withCapacity(8);
1210 preventSystemSleepList = OSSet::withCapacity(2);
1211
1212 PMinit(); // creates gIOPMWorkLoop
1213 gIOPMWorkLoop = getIOPMWorkloop();
1214
1215 // Create IOPMPowerStateQueue used to queue external power
1216 // events, and to handle those events on the PM work loop.
1217 pmPowerStateQueue = IOPMPowerStateQueue::PMPowerStateQueue(
1218 this, OSMemberFunctionCast(IOEventSource::Action, this,
1219 &IOPMrootDomain::dispatchPowerEvent));
1220 gIOPMWorkLoop->addEventSource(pmPowerStateQueue);
1221
1222 // create our power parent
1223 patriarch = new IORootParent;
1224 patriarch->init();
1225 patriarch->attach(this);
1226 patriarch->start(this);
1227 patriarch->addPowerChild(this);
1228
1229 registerPowerDriver(this, ourPowerStates, NUM_POWER_STATES);
1230 changePowerStateToPriv(ON_STATE);
1231
1232 // install power change handler
1233 gSysPowerDownNotifier = registerPrioritySleepWakeInterest( &sysPowerDownHandler, this, 0);
1234
1235 #if !NO_KERNEL_HID
1236 // Register for a notification when IODisplayWrangler is published
1237 if ((tmpDict = serviceMatching("IODisplayWrangler")))
1238 {
1239 _displayWranglerNotifier = addMatchingNotification(
1240 gIOPublishNotification, tmpDict,
1241 (IOServiceMatchingNotificationHandler) &displayWranglerMatchPublished,
1242 this, 0);
1243 tmpDict->release();
1244 }
1245 #endif
1246
1247 #if defined(__i386__) || defined(__x86_64__)
1248
1249 wranglerIdleSettings = NULL;
1250 OSNumber * wranglerIdlePeriod = NULL;
1251 wranglerIdleSettings = OSDictionary::withCapacity(1);
1252 wranglerIdlePeriod = OSNumber::withNumber(kDefaultWranglerIdlePeriod, 32);
1253
1254 if(wranglerIdleSettings && wranglerIdlePeriod)
1255 wranglerIdleSettings->setObject(kIORequestWranglerIdleKey,
1256 wranglerIdlePeriod);
1257
1258 if(wranglerIdlePeriod)
1259 wranglerIdlePeriod->release();
1260 #endif
1261
1262 const OSSymbol *ucClassName = OSSymbol::withCStringNoCopy("RootDomainUserClient");
1263 setProperty(gIOUserClientClassKey, (OSObject *) ucClassName);
1264 ucClassName->release();
1265
1266 // IOBacklightDisplay can take a long time to load at boot, or it may
1267 // not load at all if you're booting with clamshell closed. We publish
1268 // 'DisplayDims' here redundantly to get it published early and at all.
1269 OSDictionary * matching;
1270 matching = serviceMatching("IOPMPowerSource");
1271 psIterator = getMatchingServices( matching );
1272 if (matching) matching->release();
1273 if( psIterator && psIterator->getNextObject() )
1274 {
1275 // There's at least one battery on the system, so we publish
1276 // 'DisplayDims' support for the LCD.
1277 publishFeature("DisplayDims");
1278 }
1279 if(psIterator) {
1280 psIterator->release();
1281 }
1282
1283 sysctl_register_oid(&sysctl__kern_sleeptime);
1284 sysctl_register_oid(&sysctl__kern_waketime);
1285 sysctl_register_oid(&sysctl__kern_willshutdown);
1286 sysctl_register_oid(&sysctl__kern_iokittest);
1287 sysctl_register_oid(&sysctl__debug_iokit);
1288 sysctl_register_oid(&sysctl__hw_targettype);
1289
1290 #if !CONFIG_EMBEDDED
1291 sysctl_register_oid(&sysctl__kern_progressmeterenable);
1292 sysctl_register_oid(&sysctl__kern_progressmeter);
1293 sysctl_register_oid(&sysctl__kern_wakereason);
1294 #endif /* !CONFIG_EMBEDDED */
1295 sysctl_register_oid(&sysctl__kern_consoleoptions);
1296 sysctl_register_oid(&sysctl__kern_progressoptions);
1297
1298 #if HIBERNATION
1299 IOHibernateSystemInit(this);
1300 #endif
1301
1302 registerService(); // let clients find us
1303
1304 return true;
1305 }
1306
1307 //******************************************************************************
1308 // setProperties
1309 //
1310 // Receive a setProperty call
1311 // The "System Boot" property means the system is completely booted.
1312 //******************************************************************************
1313
1314 IOReturn IOPMrootDomain::setProperties( OSObject * props_obj )
1315 {
1316 IOReturn return_value = kIOReturnSuccess;
1317 OSDictionary *dict = OSDynamicCast(OSDictionary, props_obj);
1318 OSBoolean *b;
1319 OSNumber *n;
1320 const OSSymbol *key;
1321 OSObject *obj;
1322 OSCollectionIterator * iter = 0;
1323
1324 const OSSymbol *publish_simulated_battery_string = OSSymbol::withCString("SoftwareSimulatedBatteries");
1325 const OSSymbol *boot_complete_string = OSSymbol::withCString("System Boot Complete");
1326 const OSSymbol *sys_shutdown_string = OSSymbol::withCString("System Shutdown");
1327 const OSSymbol *stall_halt_string = OSSymbol::withCString("StallSystemAtHalt");
1328 const OSSymbol *battery_warning_disabled_string = OSSymbol::withCString("BatteryWarningsDisabled");
1329 const OSSymbol *idle_seconds_string = OSSymbol::withCString("System Idle Seconds");
1330 const OSSymbol *sleepdisabled_string = OSSymbol::withCString("SleepDisabled");
1331 const OSSymbol *ondeck_sleepwake_uuid_string = OSSymbol::withCString(kIOPMSleepWakeUUIDKey);
1332 const OSSymbol *loginwindow_progress_string = OSSymbol::withCString(kIOPMLoginWindowProgressKey);
1333 const OSSymbol *coredisplay_progress_string = OSSymbol::withCString(kIOPMCoreDisplayProgressKey);
1334 const OSSymbol *coregraphics_progress_string = OSSymbol::withCString(kIOPMCoreGraphicsProgressKey);
1335 #if HIBERNATION
1336 const OSSymbol *hibernatemode_string = OSSymbol::withCString(kIOHibernateModeKey);
1337 const OSSymbol *hibernatefile_string = OSSymbol::withCString(kIOHibernateFileKey);
1338 const OSSymbol *hibernatefilemin_string = OSSymbol::withCString(kIOHibernateFileMinSizeKey);
1339 const OSSymbol *hibernatefilemax_string = OSSymbol::withCString(kIOHibernateFileMaxSizeKey);
1340 const OSSymbol *hibernatefreeratio_string = OSSymbol::withCString(kIOHibernateFreeRatioKey);
1341 const OSSymbol *hibernatefreetime_string = OSSymbol::withCString(kIOHibernateFreeTimeKey);
1342 #endif
1343
1344 if (!dict)
1345 {
1346 return_value = kIOReturnBadArgument;
1347 goto exit;
1348 }
1349
1350 iter = OSCollectionIterator::withCollection(dict);
1351 if (!iter)
1352 {
1353 return_value = kIOReturnNoMemory;
1354 goto exit;
1355 }
1356
1357 while ((key = (const OSSymbol *) iter->getNextObject()) &&
1358 (obj = dict->getObject(key)))
1359 {
1360 if (key->isEqualTo(publish_simulated_battery_string))
1361 {
1362 if (OSDynamicCast(OSBoolean, obj))
1363 publishResource(key, kOSBooleanTrue);
1364 }
1365 else if (key->isEqualTo(idle_seconds_string))
1366 {
1367 if ((n = OSDynamicCast(OSNumber, obj)))
1368 {
1369 setProperty(key, n);
1370 idleSeconds = n->unsigned32BitValue();
1371 }
1372 }
1373 else if (key->isEqualTo(boot_complete_string))
1374 {
1375 pmPowerStateQueue->submitPowerEvent(kPowerEventSystemBootCompleted);
1376 }
1377 else if (key->isEqualTo(sys_shutdown_string))
1378 {
1379 if ((b = OSDynamicCast(OSBoolean, obj)))
1380 pmPowerStateQueue->submitPowerEvent(kPowerEventSystemShutdown, (void *) b);
1381 }
1382 else if (key->isEqualTo(battery_warning_disabled_string))
1383 {
1384 setProperty(key, obj);
1385 }
1386 #if HIBERNATION
1387 else if (key->isEqualTo(hibernatemode_string) ||
1388 key->isEqualTo(hibernatefilemin_string) ||
1389 key->isEqualTo(hibernatefilemax_string) ||
1390 key->isEqualTo(hibernatefreeratio_string) ||
1391 key->isEqualTo(hibernatefreetime_string))
1392 {
1393 if ((n = OSDynamicCast(OSNumber, obj)))
1394 setProperty(key, n);
1395 }
1396 else if (key->isEqualTo(hibernatefile_string))
1397 {
1398 OSString * str = OSDynamicCast(OSString, obj);
1399 if (str) setProperty(key, str);
1400 }
1401 #endif
1402 else if (key->isEqualTo(sleepdisabled_string))
1403 {
1404 if ((b = OSDynamicCast(OSBoolean, obj)))
1405 {
1406 setProperty(key, b);
1407 pmPowerStateQueue->submitPowerEvent(kPowerEventUserDisabledSleep, (void *) b);
1408 }
1409 }
1410 else if (key->isEqualTo(ondeck_sleepwake_uuid_string))
1411 {
1412 obj->retain();
1413 pmPowerStateQueue->submitPowerEvent(kPowerEventQueueSleepWakeUUID, (void *)obj);
1414 }
1415 else if (key->isEqualTo(loginwindow_progress_string))
1416 {
1417 if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
1418 uint32_t data = n->unsigned32BitValue();
1419 pmTracer->traceComponentWakeProgress(kIOPMLoginWindowProgress, data);
1420 kdebugTrace(kPMLogComponentWakeProgress, 0, kIOPMLoginWindowProgress, data);
1421 }
1422 }
1423 else if (key->isEqualTo(coredisplay_progress_string))
1424 {
1425 if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
1426 uint32_t data = n->unsigned32BitValue();
1427 pmTracer->traceComponentWakeProgress(kIOPMCoreDisplayProgress, data);
1428 kdebugTrace(kPMLogComponentWakeProgress, 0, kIOPMCoreDisplayProgress, data);
1429 }
1430 }
1431 else if (key->isEqualTo(coregraphics_progress_string))
1432 {
1433 if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
1434 uint32_t data = n->unsigned32BitValue();
1435 pmTracer->traceComponentWakeProgress(kIOPMCoreGraphicsProgress, data);
1436 kdebugTrace(kPMLogComponentWakeProgress, 0, kIOPMCoreGraphicsProgress, data);
1437 }
1438 }
1439 else if (key->isEqualTo(kIOPMDeepSleepEnabledKey) ||
1440 key->isEqualTo(kIOPMDestroyFVKeyOnStandbyKey) ||
1441 key->isEqualTo(kIOPMAutoPowerOffEnabledKey) ||
1442 key->isEqualTo(stall_halt_string))
1443 {
1444 if ((b = OSDynamicCast(OSBoolean, obj)))
1445 setProperty(key, b);
1446 }
1447 else if (key->isEqualTo(kIOPMDeepSleepDelayKey) ||
1448 key->isEqualTo(kIOPMDeepSleepTimerKey) ||
1449 key->isEqualTo(kIOPMAutoPowerOffDelayKey) ||
1450 key->isEqualTo(kIOPMAutoPowerOffTimerKey))
1451 {
1452 if ((n = OSDynamicCast(OSNumber, obj)))
1453 setProperty(key, n);
1454 }
1455 else if (key->isEqualTo(kIOPMUserWakeAlarmScheduledKey))
1456 {
1457 if (kOSBooleanTrue == obj)
1458 OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_userScheduledAlarm);
1459 else
1460 OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_userScheduledAlarm);
1461 DLOG("_userScheduledAlarm = 0x%x\n", (uint32_t) _userScheduledAlarm);
1462 }
1463
1464 // Relay our allowed PM settings onto our registered PM clients
1465 else if ((allowedPMSettings->getNextIndexOfObject(key, 0) != (unsigned int) -1))
1466 {
1467 return_value = setPMSetting(key, obj);
1468 if (kIOReturnSuccess != return_value)
1469 break;
1470
1471 if (gIOPMSettingDebugWakeRelativeKey == key)
1472 {
1473 if ((n = OSDynamicCast(OSNumber, obj)) &&
1474 (_debugWakeSeconds = n->unsigned32BitValue()))
1475 {
1476 OSBitOrAtomic(kIOPMAlarmBitDebugWake, &_scheduledAlarms);
1477 }
1478 else
1479 {
1480 _debugWakeSeconds = 0;
1481 OSBitAndAtomic(~kIOPMAlarmBitDebugWake, &_scheduledAlarms);
1482 }
1483 DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
1484 }
1485 else if (gIOPMSettingAutoWakeCalendarKey == key)
1486 {
1487 OSData * data;
1488 if ((data = OSDynamicCast(OSData, obj)) &&
1489 (data->getLength() == sizeof(IOPMCalendarStruct)))
1490 {
1491 const IOPMCalendarStruct * cs =
1492 (const IOPMCalendarStruct *) data->getBytesNoCopy();
1493
1494 if (cs->year)
1495 OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_scheduledAlarms);
1496 else
1497 OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_scheduledAlarms);
1498 DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
1499 }
1500 }
1501 }
1502 else
1503 {
1504 DLOG("setProperties(%s) not handled\n", key->getCStringNoCopy());
1505 }
1506 }
1507
1508 exit:
1509 if(publish_simulated_battery_string) publish_simulated_battery_string->release();
1510 if(boot_complete_string) boot_complete_string->release();
1511 if(sys_shutdown_string) sys_shutdown_string->release();
1512 if(stall_halt_string) stall_halt_string->release();
1513 if(battery_warning_disabled_string) battery_warning_disabled_string->release();
1514 if(idle_seconds_string) idle_seconds_string->release();
1515 if(sleepdisabled_string) sleepdisabled_string->release();
1516 if(ondeck_sleepwake_uuid_string) ondeck_sleepwake_uuid_string->release();
1517 if(loginwindow_progress_string) loginwindow_progress_string->release();
1518 if(coredisplay_progress_string) coredisplay_progress_string->release();
1519 if(coregraphics_progress_string) coregraphics_progress_string->release();
1520 #if HIBERNATION
1521 if(hibernatemode_string) hibernatemode_string->release();
1522 if(hibernatefile_string) hibernatefile_string->release();
1523 if(hibernatefreeratio_string) hibernatefreeratio_string->release();
1524 if(hibernatefreetime_string) hibernatefreetime_string->release();
1525 #endif
1526 if (iter) iter->release();
1527 return return_value;
1528 }
1529
1530 // MARK: -
1531 // MARK: Aggressiveness
1532
1533 //******************************************************************************
1534 // setAggressiveness
1535 //
1536 // Override IOService::setAggressiveness()
1537 //******************************************************************************
1538
1539 IOReturn IOPMrootDomain::setAggressiveness(
1540 unsigned long type,
1541 unsigned long value )
1542 {
1543 return setAggressiveness( type, value, 0 );
1544 }
1545
1546 /*
1547 * Private setAggressiveness() with an internal options argument.
1548 */
1549 IOReturn IOPMrootDomain::setAggressiveness(
1550 unsigned long type,
1551 unsigned long value,
1552 IOOptionBits options )
1553 {
1554 AggressivesRequest * entry;
1555 AggressivesRequest * request;
1556 bool found = false;
1557
1558 DLOG("setAggressiveness(%x) 0x%x = %u\n",
1559 (uint32_t) options, (uint32_t) type, (uint32_t) value);
1560
1561 request = IONew(AggressivesRequest, 1);
1562 if (!request)
1563 return kIOReturnNoMemory;
1564
1565 memset(request, 0, sizeof(*request));
1566 request->options = options;
1567 request->dataType = kAggressivesRequestTypeRecord;
1568 request->data.record.type = (uint32_t) type;
1569 request->data.record.value = (uint32_t) value;
1570
1571 AGGRESSIVES_LOCK();
1572
1573 // Update disk quick spindown flag used by getAggressiveness().
1574 // Never merge requests with quick spindown flags set.
1575
1576 if (options & kAggressivesOptionQuickSpindownEnable)
1577 gAggressivesState |= kAggressivesStateQuickSpindown;
1578 else if (options & kAggressivesOptionQuickSpindownDisable)
1579 gAggressivesState &= ~kAggressivesStateQuickSpindown;
1580 else
1581 {
1582 // Coalesce requests with identical aggressives types.
1583 // Deal with callers that calls us too "aggressively".
1584
1585 queue_iterate(&aggressivesQueue, entry, AggressivesRequest *, chain)
1586 {
1587 if ((entry->dataType == kAggressivesRequestTypeRecord) &&
1588 (entry->data.record.type == type) &&
1589 ((entry->options & kAggressivesOptionQuickSpindownMask) == 0))
1590 {
1591 entry->data.record.value = value;
1592 found = true;
1593 break;
1594 }
1595 }
1596 }
1597
1598 if (!found)
1599 {
1600 queue_enter(&aggressivesQueue, request, AggressivesRequest *, chain);
1601 }
1602
1603 AGGRESSIVES_UNLOCK();
1604
1605 if (found)
1606 IODelete(request, AggressivesRequest, 1);
1607
1608 if (options & kAggressivesOptionSynchronous)
1609 handleAggressivesRequests(); // not truly synchronous
1610 else
1611 thread_call_enter(aggressivesThreadCall);
1612
1613 return kIOReturnSuccess;
1614 }
1615
1616 //******************************************************************************
1617 // getAggressiveness
1618 //
1619 // Override IOService::setAggressiveness()
1620 // Fetch the aggressiveness factor with the given type.
1621 //******************************************************************************
1622
1623 IOReturn IOPMrootDomain::getAggressiveness (
1624 unsigned long type,
1625 unsigned long * outLevel )
1626 {
1627 uint32_t value = 0;
1628 int source = 0;
1629
1630 if (!outLevel)
1631 return kIOReturnBadArgument;
1632
1633 AGGRESSIVES_LOCK();
1634
1635 // Disk quick spindown in effect, report value = 1
1636
1637 if ((gAggressivesState & kAggressivesStateQuickSpindown) &&
1638 (type == kPMMinutesToSpinDown))
1639 {
1640 value = kAggressivesMinValue;
1641 source = 1;
1642 }
1643
1644 // Consult the pending request queue.
1645
1646 if (!source)
1647 {
1648 AggressivesRequest * entry;
1649
1650 queue_iterate(&aggressivesQueue, entry, AggressivesRequest *, chain)
1651 {
1652 if ((entry->dataType == kAggressivesRequestTypeRecord) &&
1653 (entry->data.record.type == type) &&
1654 ((entry->options & kAggressivesOptionQuickSpindownMask) == 0))
1655 {
1656 value = entry->data.record.value;
1657 source = 2;
1658 break;
1659 }
1660 }
1661 }
1662
1663 // Consult the backend records.
1664
1665 if (!source && aggressivesData)
1666 {
1667 AggressivesRecord * record;
1668 int i, count;
1669
1670 count = aggressivesData->getLength() / sizeof(AggressivesRecord);
1671 record = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
1672
1673 for (i = 0; i < count; i++, record++)
1674 {
1675 if (record->type == type)
1676 {
1677 value = record->value;
1678 source = 3;
1679 break;
1680 }
1681 }
1682 }
1683
1684 AGGRESSIVES_UNLOCK();
1685
1686 if (source)
1687 {
1688 DLOG("getAggressiveness(%d) 0x%x = %u\n",
1689 source, (uint32_t) type, value);
1690 *outLevel = (unsigned long) value;
1691 return kIOReturnSuccess;
1692 }
1693 else
1694 {
1695 DLOG("getAggressiveness type 0x%x not found\n", (uint32_t) type);
1696 *outLevel = 0; // default return = 0, driver may not check for error
1697 return kIOReturnInvalid;
1698 }
1699 }
1700
1701 //******************************************************************************
1702 // joinAggressiveness
1703 //
1704 // Request from IOService to join future aggressiveness broadcasts.
1705 //******************************************************************************
1706
1707 IOReturn IOPMrootDomain::joinAggressiveness(
1708 IOService * service )
1709 {
1710 AggressivesRequest * request;
1711
1712 if (!service || (service == this))
1713 return kIOReturnBadArgument;
1714
1715 DLOG("joinAggressiveness %s %p\n", service->getName(), OBFUSCATE(service));
1716
1717 request = IONew(AggressivesRequest, 1);
1718 if (!request)
1719 return kIOReturnNoMemory;
1720
1721 service->retain(); // released by synchronizeAggressives()
1722
1723 memset(request, 0, sizeof(*request));
1724 request->dataType = kAggressivesRequestTypeService;
1725 request->data.service = service;
1726
1727 AGGRESSIVES_LOCK();
1728 queue_enter(&aggressivesQueue, request, AggressivesRequest *, chain);
1729 AGGRESSIVES_UNLOCK();
1730
1731 thread_call_enter(aggressivesThreadCall);
1732
1733 return kIOReturnSuccess;
1734 }
1735
1736 //******************************************************************************
1737 // handleAggressivesRequests
1738 //
1739 // Backend thread processes all incoming aggressiveness requests in the queue.
1740 //******************************************************************************
1741
1742 static void
1743 handleAggressivesFunction(
1744 thread_call_param_t param1,
1745 thread_call_param_t param2 )
1746 {
1747 if (param1)
1748 {
1749 ((IOPMrootDomain *) param1)->handleAggressivesRequests();
1750 }
1751 }
1752
1753 void IOPMrootDomain::handleAggressivesRequests( void )
1754 {
1755 AggressivesRecord * start;
1756 AggressivesRecord * record;
1757 AggressivesRequest * request;
1758 queue_head_t joinedQueue;
1759 int i, count;
1760 bool broadcast;
1761 bool found;
1762 bool pingSelf = false;
1763
1764 AGGRESSIVES_LOCK();
1765
1766 if ((gAggressivesState & kAggressivesStateBusy) || !aggressivesData ||
1767 queue_empty(&aggressivesQueue))
1768 goto unlock_done;
1769
1770 gAggressivesState |= kAggressivesStateBusy;
1771 count = aggressivesData->getLength() / sizeof(AggressivesRecord);
1772 start = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
1773
1774 do
1775 {
1776 broadcast = false;
1777 queue_init(&joinedQueue);
1778
1779 do
1780 {
1781 // Remove request from the incoming queue in FIFO order.
1782 queue_remove_first(&aggressivesQueue, request, AggressivesRequest *, chain);
1783 switch (request->dataType)
1784 {
1785 case kAggressivesRequestTypeRecord:
1786 // Update existing record if found.
1787 found = false;
1788 for (i = 0, record = start; i < count; i++, record++)
1789 {
1790 if (record->type == request->data.record.type)
1791 {
1792 found = true;
1793
1794 if (request->options & kAggressivesOptionQuickSpindownEnable)
1795 {
1796 if ((record->flags & kAggressivesRecordFlagMinValue) == 0)
1797 {
1798 broadcast = true;
1799 record->flags |= (kAggressivesRecordFlagMinValue |
1800 kAggressivesRecordFlagModified);
1801 DLOG("disk spindown accelerated, was %u min\n",
1802 record->value);
1803 }
1804 }
1805 else if (request->options & kAggressivesOptionQuickSpindownDisable)
1806 {
1807 if (record->flags & kAggressivesRecordFlagMinValue)
1808 {
1809 broadcast = true;
1810 record->flags |= kAggressivesRecordFlagModified;
1811 record->flags &= ~kAggressivesRecordFlagMinValue;
1812 DLOG("disk spindown restored to %u min\n",
1813 record->value);
1814 }
1815 }
1816 else if (record->value != request->data.record.value)
1817 {
1818 record->value = request->data.record.value;
1819 if ((record->flags & kAggressivesRecordFlagMinValue) == 0)
1820 {
1821 broadcast = true;
1822 record->flags |= kAggressivesRecordFlagModified;
1823 }
1824 }
1825 break;
1826 }
1827 }
1828
1829 // No matching record, append a new record.
1830 if (!found &&
1831 ((request->options & kAggressivesOptionQuickSpindownDisable) == 0))
1832 {
1833 AggressivesRecord newRecord;
1834
1835 newRecord.flags = kAggressivesRecordFlagModified;
1836 newRecord.type = request->data.record.type;
1837 newRecord.value = request->data.record.value;
1838 if (request->options & kAggressivesOptionQuickSpindownEnable)
1839 {
1840 newRecord.flags |= kAggressivesRecordFlagMinValue;
1841 DLOG("disk spindown accelerated\n");
1842 }
1843
1844 aggressivesData->appendBytes(&newRecord, sizeof(newRecord));
1845
1846 // OSData may have switched to another (larger) buffer.
1847 count = aggressivesData->getLength() / sizeof(AggressivesRecord);
1848 start = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
1849 broadcast = true;
1850 }
1851
1852 // Finished processing the request, release it.
1853 IODelete(request, AggressivesRequest, 1);
1854 break;
1855
1856 case kAggressivesRequestTypeService:
1857 // synchronizeAggressives() will free request.
1858 queue_enter(&joinedQueue, request, AggressivesRequest *, chain);
1859 break;
1860
1861 default:
1862 panic("bad aggressives request type %x\n", request->dataType);
1863 break;
1864 }
1865 } while (!queue_empty(&aggressivesQueue));
1866
1867 // Release the lock to perform work, with busy flag set.
1868 if (!queue_empty(&joinedQueue) || broadcast)
1869 {
1870 AGGRESSIVES_UNLOCK();
1871 if (!queue_empty(&joinedQueue))
1872 synchronizeAggressives(&joinedQueue, start, count);
1873 if (broadcast)
1874 broadcastAggressives(start, count);
1875 AGGRESSIVES_LOCK();
1876 }
1877
1878 // Remove the modified flag from all records.
1879 for (i = 0, record = start; i < count; i++, record++)
1880 {
1881 if ((record->flags & kAggressivesRecordFlagModified) &&
1882 ((record->type == kPMMinutesToDim) ||
1883 (record->type == kPMMinutesToSleep)))
1884 pingSelf = true;
1885
1886 record->flags &= ~kAggressivesRecordFlagModified;
1887 }
1888
1889 // Check the incoming queue again since new entries may have been
1890 // added while lock was released above.
1891
1892 } while (!queue_empty(&aggressivesQueue));
1893
1894 gAggressivesState &= ~kAggressivesStateBusy;
1895
1896 unlock_done:
1897 AGGRESSIVES_UNLOCK();
1898
1899 // Root domain is interested in system and display sleep slider changes.
1900 // Submit a power event to handle those changes on the PM work loop.
1901
1902 if (pingSelf && pmPowerStateQueue) {
1903 pmPowerStateQueue->submitPowerEvent(
1904 kPowerEventPolicyStimulus,
1905 (void *) kStimulusAggressivenessChanged );
1906 }
1907 }
1908
1909 //******************************************************************************
1910 // synchronizeAggressives
1911 //
1912 // Push all known aggressiveness records to one or more IOService.
1913 //******************************************************************************
1914
1915 void IOPMrootDomain::synchronizeAggressives(
1916 queue_head_t * joinedQueue,
1917 const AggressivesRecord * array,
1918 int count )
1919 {
1920 IOService * service;
1921 AggressivesRequest * request;
1922 const AggressivesRecord * record;
1923 IOPMDriverCallEntry callEntry;
1924 uint32_t value;
1925 int i;
1926
1927 while (!queue_empty(joinedQueue))
1928 {
1929 queue_remove_first(joinedQueue, request, AggressivesRequest *, chain);
1930 if (request->dataType == kAggressivesRequestTypeService)
1931 service = request->data.service;
1932 else
1933 service = 0;
1934
1935 IODelete(request, AggressivesRequest, 1);
1936 request = 0;
1937
1938 if (service)
1939 {
1940 if (service->assertPMDriverCall(&callEntry))
1941 {
1942 for (i = 0, record = array; i < count; i++, record++)
1943 {
1944 value = record->value;
1945 if (record->flags & kAggressivesRecordFlagMinValue)
1946 value = kAggressivesMinValue;
1947
1948 _LOG("synchronizeAggressives 0x%x = %u to %s\n",
1949 record->type, value, service->getName());
1950 service->setAggressiveness(record->type, value);
1951 }
1952 service->deassertPMDriverCall(&callEntry);
1953 }
1954 service->release(); // retained by joinAggressiveness()
1955 }
1956 }
1957 }
1958
1959 //******************************************************************************
1960 // broadcastAggressives
1961 //
1962 // Traverse PM tree and call setAggressiveness() for records that have changed.
1963 //******************************************************************************
1964
1965 void IOPMrootDomain::broadcastAggressives(
1966 const AggressivesRecord * array,
1967 int count )
1968 {
1969 IORegistryIterator * iter;
1970 IORegistryEntry * entry;
1971 IOPowerConnection * connect;
1972 IOService * service;
1973 const AggressivesRecord * record;
1974 IOPMDriverCallEntry callEntry;
1975 uint32_t value;
1976 int i;
1977
1978 iter = IORegistryIterator::iterateOver(
1979 this, gIOPowerPlane, kIORegistryIterateRecursively);
1980 if (iter)
1981 {
1982 do
1983 {
1984 iter->reset();
1985 while ((entry = iter->getNextObject()))
1986 {
1987 connect = OSDynamicCast(IOPowerConnection, entry);
1988 if (!connect || !connect->getReadyFlag())
1989 continue;
1990
1991 if ((service = OSDynamicCast(IOService, connect->copyChildEntry(gIOPowerPlane))))
1992 {
1993 if (service->assertPMDriverCall(&callEntry))
1994 {
1995 for (i = 0, record = array; i < count; i++, record++)
1996 {
1997 if (record->flags & kAggressivesRecordFlagModified)
1998 {
1999 value = record->value;
2000 if (record->flags & kAggressivesRecordFlagMinValue)
2001 value = kAggressivesMinValue;
2002 _LOG("broadcastAggressives %x = %u to %s\n",
2003 record->type, value, service->getName());
2004 service->setAggressiveness(record->type, value);
2005 }
2006 }
2007 service->deassertPMDriverCall(&callEntry);
2008 }
2009 service->release();
2010 }
2011 }
2012 }
2013 while (!entry && !iter->isValid());
2014 iter->release();
2015 }
2016 }
2017
2018 // MARK: -
2019 // MARK: System Sleep
2020
2021 //******************************************************************************
2022 // startIdleSleepTimer
2023 //
2024 //******************************************************************************
2025
2026 void IOPMrootDomain::startIdleSleepTimer( uint32_t inSeconds )
2027 {
2028 AbsoluteTime deadline;
2029
2030 ASSERT_GATED();
2031 if (gNoIdleFlag) {
2032 DLOG("idle timer not set (noidle=%d)\n", gNoIdleFlag);
2033 return;
2034 }
2035 if (inSeconds)
2036 {
2037 clock_interval_to_deadline(inSeconds, kSecondScale, &deadline);
2038 thread_call_enter_delayed(extraSleepTimer, deadline);
2039 idleSleepTimerPending = true;
2040 }
2041 else
2042 {
2043 thread_call_enter(extraSleepTimer);
2044 }
2045 DLOG("idle timer set for %u seconds\n", inSeconds);
2046 }
2047
2048 //******************************************************************************
2049 // cancelIdleSleepTimer
2050 //
2051 //******************************************************************************
2052
2053 void IOPMrootDomain::cancelIdleSleepTimer( void )
2054 {
2055 ASSERT_GATED();
2056 if (idleSleepTimerPending)
2057 {
2058 DLOG("idle timer cancelled\n");
2059 thread_call_cancel(extraSleepTimer);
2060 idleSleepTimerPending = false;
2061
2062 if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
2063 AbsoluteTime now;
2064 clock_usec_t microsecs;
2065 clock_get_uptime(&now);
2066 SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
2067 absolutetime_to_microtime(now, &assertOnWakeSecs, &microsecs);
2068 if (assertOnWakeReport) {
2069 HISTREPORT_TALLYVALUE(assertOnWakeReport, (int64_t)assertOnWakeSecs);
2070 DLOG("Updated assertOnWake %lu\n", (unsigned long)assertOnWakeSecs);
2071 }
2072 }
2073 }
2074 }
2075
2076 //******************************************************************************
2077 // idleSleepTimerExpired
2078 //
2079 //******************************************************************************
2080
2081 static void idleSleepTimerExpired(
2082 thread_call_param_t us, thread_call_param_t )
2083 {
2084 ((IOPMrootDomain *)us)->handleSleepTimerExpiration();
2085 }
2086
2087 //******************************************************************************
2088 // handleSleepTimerExpiration
2089 //
2090 // The time between the sleep idle timeout and the next longest one has elapsed.
2091 // It's time to sleep. Start that by removing the clamp that's holding us awake.
2092 //******************************************************************************
2093
2094 void IOPMrootDomain::handleSleepTimerExpiration( void )
2095 {
2096 if (!gIOPMWorkLoop->inGate())
2097 {
2098 gIOPMWorkLoop->runAction(
2099 OSMemberFunctionCast(IOWorkLoop::Action, this,
2100 &IOPMrootDomain::handleSleepTimerExpiration),
2101 this);
2102 return;
2103 }
2104
2105 AbsoluteTime time;
2106
2107 DLOG("sleep timer expired\n");
2108 ASSERT_GATED();
2109
2110 idleSleepTimerPending = false;
2111
2112 clock_get_uptime(&time);
2113 setQuickSpinDownTimeout();
2114 adjustPowerState(true);
2115 }
2116
2117 //******************************************************************************
2118 // getTimeToIdleSleep
2119 //
2120 // Returns number of seconds left before going into idle sleep.
2121 // Caller has to make sure that idle sleep is allowed at the time of calling
2122 // this function
2123 //******************************************************************************
2124
2125 uint32_t IOPMrootDomain::getTimeToIdleSleep( void )
2126 {
2127
2128 AbsoluteTime now, lastActivityTime;
2129 uint64_t nanos;
2130 uint32_t minutesSinceUserInactive = 0;
2131 uint32_t sleepDelay = 0;
2132
2133 if (!idleSleepEnabled)
2134 return 0xffffffff;
2135
2136 if (userActivityTime)
2137 lastActivityTime = userActivityTime;
2138 else
2139 lastActivityTime = userBecameInactiveTime;
2140
2141 clock_get_uptime(&now);
2142 if (CMP_ABSOLUTETIME(&now, &lastActivityTime) > 0)
2143 {
2144 SUB_ABSOLUTETIME(&now, &lastActivityTime);
2145 absolutetime_to_nanoseconds(now, &nanos);
2146 minutesSinceUserInactive = nanos / (60000000000ULL);
2147
2148 if (minutesSinceUserInactive >= sleepSlider)
2149 sleepDelay = 0;
2150 else
2151 sleepDelay = sleepSlider - minutesSinceUserInactive;
2152 }
2153 else
2154 {
2155 sleepDelay = sleepSlider;
2156 }
2157
2158 DLOG("user inactive %u min, time to idle sleep %u min\n",
2159 minutesSinceUserInactive, sleepDelay);
2160
2161 return (sleepDelay * 60);
2162 }
2163
2164 //******************************************************************************
2165 // setQuickSpinDownTimeout
2166 //
2167 //******************************************************************************
2168
2169 void IOPMrootDomain::setQuickSpinDownTimeout( void )
2170 {
2171 ASSERT_GATED();
2172 setAggressiveness(
2173 kPMMinutesToSpinDown, 0, kAggressivesOptionQuickSpindownEnable );
2174 }
2175
2176 //******************************************************************************
2177 // restoreUserSpinDownTimeout
2178 //
2179 //******************************************************************************
2180
2181 void IOPMrootDomain::restoreUserSpinDownTimeout( void )
2182 {
2183 ASSERT_GATED();
2184 setAggressiveness(
2185 kPMMinutesToSpinDown, 0, kAggressivesOptionQuickSpindownDisable );
2186 }
2187
2188 //******************************************************************************
2189 // sleepSystem
2190 //
2191 //******************************************************************************
2192
2193 /* public */
2194 IOReturn IOPMrootDomain::sleepSystem( void )
2195 {
2196 return sleepSystemOptions(NULL);
2197 }
2198
2199 /* private */
2200 IOReturn IOPMrootDomain::sleepSystemOptions( OSDictionary *options )
2201 {
2202 OSObject *obj = NULL;
2203 OSString *reason = NULL;
2204 /* sleepSystem is a public function, and may be called by any kernel driver.
2205 * And that's bad - drivers should sleep the system by calling
2206 * receivePowerNotification() instead. Drivers should not use sleepSystem.
2207 *
2208 * Note that user space app calls to IOPMSleepSystem() will also travel
2209 * this code path and thus be correctly identified as software sleeps.
2210 */
2211
2212 if (options && options->getObject("OSSwitch"))
2213 {
2214 // Log specific sleep cause for OS Switch hibernation
2215 return privateSleepSystem( kIOPMSleepReasonOSSwitchHibernate);
2216 }
2217
2218 if (options && (obj = options->getObject("Sleep Reason")))
2219 {
2220 reason = OSDynamicCast(OSString, obj);
2221 if (reason && reason->isEqualTo(kIOPMDarkWakeThermalEmergencyKey))
2222 return privateSleepSystem(kIOPMSleepReasonDarkWakeThermalEmergency);
2223 }
2224
2225 return privateSleepSystem( kIOPMSleepReasonSoftware);
2226 }
2227
2228 /* private */
2229 IOReturn IOPMrootDomain::privateSleepSystem( uint32_t sleepReason )
2230 {
2231 /* Called from both gated and non-gated context */
2232
2233 if (!checkSystemSleepEnabled() || !pmPowerStateQueue)
2234 {
2235 return kIOReturnNotPermitted;
2236 }
2237
2238 pmPowerStateQueue->submitPowerEvent(
2239 kPowerEventPolicyStimulus,
2240 (void *) kStimulusDemandSystemSleep,
2241 sleepReason);
2242
2243 return kIOReturnSuccess;
2244 }
2245
2246 //******************************************************************************
2247 // powerChangeDone
2248 //
2249 // This overrides powerChangeDone in IOService.
2250 //******************************************************************************
2251
2252 void IOPMrootDomain::powerChangeDone( unsigned long previousPowerState )
2253 {
2254 #if !__i386__ && !__x86_64__
2255 uint64_t timeSinceReset = 0;
2256 #endif
2257 uint64_t now;
2258 ASSERT_GATED();
2259 DLOG("PowerChangeDone: %u->%u\n",
2260 (uint32_t) previousPowerState, (uint32_t) getPowerState());
2261
2262 notifierThread = current_thread();
2263 switch ( getPowerState() )
2264 {
2265 case SLEEP_STATE: {
2266 if (previousPowerState != ON_STATE)
2267 break;
2268
2269 acceptSystemWakeEvents(true);
2270
2271 // re-enable this timer for next sleep
2272 cancelIdleSleepTimer();
2273
2274 clock_sec_t secs;
2275 clock_usec_t microsecs;
2276 clock_get_calendar_absolute_and_microtime(&secs, &microsecs, &now);
2277 logtime(secs);
2278 gIOLastSleepTime.tv_sec = secs;
2279 gIOLastSleepTime.tv_usec = microsecs;
2280 gIOLastWakeTime.tv_sec = 0;
2281 gIOLastWakeTime.tv_usec = 0;
2282 gIOLastSleepAbsTime = now;
2283
2284 if (wake2DarkwakeDelay && sleepDelaysReport) {
2285 clock_usec_t microsecs;
2286 clock_sec_t wake2DarkwakeSecs, darkwake2SleepSecs;
2287 // Update 'wake2DarkwakeDelay' histogram if this is a fullwake->sleep transition
2288
2289 SUB_ABSOLUTETIME(&now, &ts_sleepStart);
2290 absolutetime_to_microtime(now, &darkwake2SleepSecs, &microsecs);
2291 absolutetime_to_microtime(wake2DarkwakeDelay, &wake2DarkwakeSecs, &microsecs);
2292 HISTREPORT_TALLYVALUE(sleepDelaysReport,
2293 (int64_t)(wake2DarkwakeSecs+darkwake2SleepSecs));
2294
2295 DLOG("Updated sleepDelaysReport %lu %lu\n", (unsigned long)wake2DarkwakeSecs, (unsigned long)darkwake2SleepSecs);
2296 wake2DarkwakeDelay = 0;
2297 }
2298 #if HIBERNATION
2299 LOG("System %sSleep\n", gIOHibernateState ? "Safe" : "");
2300
2301 IOHibernateSystemHasSlept();
2302
2303 evaluateSystemSleepPolicyFinal();
2304 #else
2305 LOG("System Sleep\n");
2306 #endif
2307 if (thermalWarningState) {
2308 const OSSymbol *event = OSSymbol::withCString(kIOPMThermalLevelWarningKey);
2309 if (event) {
2310 systemPowerEventOccurred(event, kIOPMThermalLevelUnknown);
2311 event->release();
2312 }
2313 }
2314 assertOnWakeSecs = 0;
2315 lowBatteryCondition = false;
2316
2317 #if DEVELOPMENT || DEBUG
2318 extern int g_should_log_clock_adjustments;
2319 if (g_should_log_clock_adjustments) {
2320 clock_sec_t secs = 0;
2321 clock_usec_t microsecs = 0;
2322 uint64_t now_b = mach_absolute_time();
2323
2324 PEGetUTCTimeOfDay(&secs, &microsecs);
2325
2326 uint64_t now_a = mach_absolute_time();
2327 os_log(OS_LOG_DEFAULT, "%s PMU before going to sleep %lu s %d u %llu abs_b_PEG %llu abs_a_PEG \n",
2328 __func__, (unsigned long)secs, microsecs, now_b, now_a);
2329 }
2330 #endif
2331
2332 getPlatform()->sleepKernel();
2333
2334 // The CPU(s) are off at this point,
2335 // Code will resume execution here upon wake.
2336
2337 clock_get_uptime(&gIOLastWakeAbsTime);
2338 IOLog("gIOLastWakeAbsTime: %lld\n", gIOLastWakeAbsTime);
2339 _highestCapability = 0;
2340
2341 #if HIBERNATION
2342 IOHibernateSystemWake();
2343 #endif
2344
2345 // sleep transition complete
2346 gSleepOrShutdownPending = 0;
2347
2348 // trip the reset of the calendar clock
2349 {
2350 clock_sec_t wakeSecs;
2351 clock_usec_t wakeMicrosecs;
2352
2353 clock_wakeup_calendar();
2354
2355 clock_get_calendar_microtime(&wakeSecs, &wakeMicrosecs);
2356 gIOLastWakeTime.tv_sec = wakeSecs;
2357 gIOLastWakeTime.tv_usec = wakeMicrosecs;
2358 }
2359
2360 #if HIBERNATION
2361 LOG("System %sWake\n", gIOHibernateState ? "SafeSleep " : "");
2362 #endif
2363
2364 lastSleepReason = 0;
2365
2366 _lastDebugWakeSeconds = _debugWakeSeconds;
2367 _debugWakeSeconds = 0;
2368 _scheduledAlarms = 0;
2369
2370 #if defined(__i386__) || defined(__x86_64__)
2371 kdebugTrace(kPMLogSystemWake, 0, 0, 0);
2372 wranglerTickled = false;
2373 graphicsSuppressed = false;
2374 darkWakePostTickle = false;
2375 darkWakeHibernateError = false;
2376 darkWakeToSleepASAP = true;
2377 logGraphicsClamp = true;
2378 sleepTimerMaintenance = false;
2379 sleepToStandby = false;
2380 wranglerTickleLatched = false;
2381 userWasActive = false;
2382 fullWakeReason = kFullWakeReasonNone;
2383
2384 OSString * wakeType = OSDynamicCast(
2385 OSString, getProperty(kIOPMRootDomainWakeTypeKey));
2386 OSString * wakeReason = OSDynamicCast(
2387 OSString, getProperty(kIOPMRootDomainWakeReasonKey));
2388
2389 if (wakeReason && (wakeReason->getLength() >= 2) &&
2390 gWakeReasonString[0] == '\0')
2391 {
2392 // Until the platform driver can claim its wake reasons
2393 strlcat(gWakeReasonString, wakeReason->getCStringNoCopy(),
2394 sizeof(gWakeReasonString));
2395 }
2396
2397 if (wakeType && wakeType->isEqualTo(kIOPMrootDomainWakeTypeLowBattery))
2398 {
2399 lowBatteryCondition = true;
2400 darkWakeMaintenance = true;
2401 }
2402 else if ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) != 0)
2403 {
2404 #if HIBERNATION
2405 OSNumber * hibOptions = OSDynamicCast(
2406 OSNumber, getProperty(kIOHibernateOptionsKey));
2407 if (hibernateAborted || ((hibOptions &&
2408 !(hibOptions->unsigned32BitValue() & kIOHibernateOptionDarkWake))))
2409 {
2410 // Hibernate aborted, or EFI brought up graphics
2411 wranglerTickled = true;
2412 DLOG("hibernation aborted %d, options 0x%x\n",
2413 hibernateAborted,
2414 hibOptions ? hibOptions->unsigned32BitValue() : 0);
2415 }
2416 else
2417 #endif
2418 if (wakeType && (
2419 wakeType->isEqualTo(kIOPMRootDomainWakeTypeUser) ||
2420 wakeType->isEqualTo(kIOPMRootDomainWakeTypeAlarm)))
2421 {
2422 // User wake or RTC alarm
2423 wranglerTickled = true;
2424 }
2425 else
2426 if (wakeType &&
2427 wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepTimer))
2428 {
2429 // SMC standby timer trumps SleepX
2430 darkWakeMaintenance = true;
2431 sleepTimerMaintenance = true;
2432 }
2433 else
2434 if ((_lastDebugWakeSeconds != 0) &&
2435 ((gDarkWakeFlags & kDarkWakeFlagAlarmIsDark) == 0))
2436 {
2437 // SleepX before maintenance
2438 wranglerTickled = true;
2439 }
2440 else
2441 if (wakeType &&
2442 wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance))
2443 {
2444 darkWakeMaintenance = true;
2445 }
2446 else
2447 if (wakeType &&
2448 wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepService))
2449 {
2450 darkWakeMaintenance = true;
2451 darkWakeSleepService = true;
2452 #if HIBERNATION
2453 if (kIOHibernateStateWakingFromHibernate == gIOHibernateState) {
2454 sleepToStandby = true;
2455 }
2456 #endif
2457 }
2458 else
2459 if (wakeType &&
2460 wakeType->isEqualTo(kIOPMRootDomainWakeTypeHibernateError))
2461 {
2462 darkWakeMaintenance = true;
2463 darkWakeHibernateError = true;
2464 }
2465 else
2466 {
2467 // Unidentified wake source, resume to full wake if debug
2468 // alarm is pending.
2469
2470 if (_lastDebugWakeSeconds &&
2471 (!wakeReason || wakeReason->isEqualTo("")))
2472 wranglerTickled = true;
2473 }
2474 }
2475 else
2476 {
2477 if (wakeType &&
2478 wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepTimer))
2479 {
2480 darkWakeMaintenance = true;
2481 sleepTimerMaintenance = true;
2482 }
2483 else if (hibernateAborted || !wakeType ||
2484 !wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance) ||
2485 !wakeReason || !wakeReason->isEqualTo("RTC"))
2486 {
2487 // Post a HID tickle immediately - except for RTC maintenance wake.
2488 wranglerTickled = true;
2489 }
2490 else
2491 {
2492 darkWakeMaintenance = true;
2493 }
2494 }
2495
2496 if (wranglerTickled)
2497 {
2498 darkWakeToSleepASAP = false;
2499 fullWakeReason = kFullWakeReasonLocalUser;
2500 reportUserInput();
2501 }
2502 else if (displayPowerOnRequested && checkSystemCanSustainFullWake())
2503 {
2504 handleDisplayPowerOn();
2505 }
2506 else if (!darkWakeMaintenance)
2507 {
2508 // Early/late tickle for non-maintenance wake.
2509 if (((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
2510 kDarkWakeFlagHIDTickleEarly) ||
2511 ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
2512 kDarkWakeFlagHIDTickleLate))
2513 {
2514 darkWakePostTickle = true;
2515 }
2516 }
2517 #else /* !__i386__ && !__x86_64__ */
2518 timeSinceReset = ml_get_time_since_reset();
2519
2520 kdebugTrace(kPMLogSystemWake, 0, timeSinceReset >> 32, timeSinceReset);
2521 // stay awake for at least 30 seconds
2522 wranglerTickled = true;
2523 fullWakeReason = kFullWakeReasonLocalUser;
2524 startIdleSleepTimer(30);
2525 #endif
2526 sleepCnt++;
2527
2528 thread_call_enter(updateConsoleUsersEntry);
2529
2530 changePowerStateToPriv(ON_STATE);
2531 } break;
2532 #if !__i386__ && !__x86_64__
2533 case ON_STATE: {
2534 if (previousPowerState != ON_STATE)
2535 {
2536 DLOG("Force re-evaluating aggressiveness\n");
2537 /* Force re-evaluate the aggressiveness values to set appropriate idle sleep timer */
2538 pmPowerStateQueue->submitPowerEvent(
2539 kPowerEventPolicyStimulus,
2540 (void *) kStimulusNoIdleSleepPreventers );
2541 }
2542 break;
2543 }
2544
2545 #endif
2546
2547 }
2548 notifierThread = NULL;
2549 }
2550
2551 //******************************************************************************
2552 // requestPowerDomainState
2553 //
2554 // Extend implementation in IOService. Running on PM work loop thread.
2555 //******************************************************************************
2556
2557 IOReturn IOPMrootDomain::requestPowerDomainState (
2558 IOPMPowerFlags childDesire,
2559 IOPowerConnection * childConnection,
2560 unsigned long specification )
2561 {
2562 // Idle and system sleep prevention flags affects driver desire.
2563 // Children desire are irrelevant so they are cleared.
2564
2565 return super::requestPowerDomainState(0, childConnection, specification);
2566 }
2567
2568
2569 //******************************************************************************
2570 // updatePreventIdleSleepList
2571 //
2572 // Called by IOService on PM work loop.
2573 // Returns true if PM policy recognized the driver's desire to prevent idle
2574 // sleep and updated the list of idle sleep preventers. Returns false otherwise
2575 //******************************************************************************
2576
2577 bool IOPMrootDomain::updatePreventIdleSleepList(
2578 IOService * service, bool addNotRemove )
2579 {
2580 unsigned int oldCount, newCount;
2581
2582 ASSERT_GATED();
2583
2584 #if defined(__i386__) || defined(__x86_64__)
2585 // Disregard disk I/O (besides the display wrangler) as a factor preventing
2586 // idle sleep, except in the case of legacy disk I/O
2587 if ((service != wrangler) && (service != this))
2588 {
2589 return false;
2590 }
2591 #endif
2592
2593 oldCount = preventIdleSleepList->getCount();
2594 if (addNotRemove)
2595 {
2596 preventIdleSleepList->setObject(service);
2597 DLOG("prevent idle sleep list: %s+ (%u)\n",
2598 service->getName(), preventIdleSleepList->getCount());
2599 }
2600 else if (preventIdleSleepList->member(service))
2601 {
2602 preventIdleSleepList->removeObject(service);
2603 DLOG("prevent idle sleep list: %s- (%u)\n",
2604 service->getName(), preventIdleSleepList->getCount());
2605 }
2606 newCount = preventIdleSleepList->getCount();
2607
2608 if ((oldCount == 0) && (newCount != 0))
2609 {
2610 // Driver added to empty prevent list.
2611 // Update the driver desire to prevent idle sleep.
2612 // Driver desire does not prevent demand sleep.
2613
2614 changePowerStateTo(ON_STATE);
2615 }
2616 else if ((oldCount != 0) && (newCount == 0))
2617 {
2618 // Last driver removed from prevent list.
2619 // Drop the driver clamp to allow idle sleep.
2620
2621 changePowerStateTo(SLEEP_STATE);
2622 evaluatePolicy( kStimulusNoIdleSleepPreventers );
2623 }
2624 messageClient(kIOPMMessageIdleSleepPreventers, systemCapabilityNotifier,
2625 &newCount, sizeof(newCount));
2626
2627 #if defined(__i386__) || defined(__x86_64__)
2628 if (addNotRemove && (service == wrangler) && !checkSystemCanSustainFullWake())
2629 {
2630 DLOG("Cannot cancel idle sleep\n");
2631 return false; // do not idle-cancel
2632 }
2633 #endif
2634
2635 return true;
2636 }
2637
2638 //******************************************************************************
2639 // startSpinDump
2640 //******************************************************************************
2641
2642 void IOPMrootDomain::startSpinDump(uint32_t spindumpKind)
2643 {
2644 messageClients(kIOPMMessageLaunchBootSpinDump, (void *)(uintptr_t)spindumpKind);
2645 }
2646
2647 //******************************************************************************
2648 // preventSystemSleepListUpdate
2649 //
2650 // Called by IOService on PM work loop.
2651 //******************************************************************************
2652
2653 void IOPMrootDomain::updatePreventSystemSleepList(
2654 IOService * service, bool addNotRemove )
2655 {
2656 unsigned int oldCount, newCount;
2657
2658 ASSERT_GATED();
2659 if (this == service)
2660 return;
2661
2662 oldCount = preventSystemSleepList->getCount();
2663 if (addNotRemove)
2664 {
2665 preventSystemSleepList->setObject(service);
2666 DLOG("prevent system sleep list: %s+ (%u)\n",
2667 service->getName(), preventSystemSleepList->getCount());
2668 if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
2669 AbsoluteTime now;
2670 clock_usec_t microsecs;
2671 clock_get_uptime(&now);
2672 SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
2673 absolutetime_to_microtime(now, &assertOnWakeSecs, &microsecs);
2674 if (assertOnWakeReport) {
2675 HISTREPORT_TALLYVALUE(assertOnWakeReport, (int64_t)assertOnWakeSecs);
2676 DLOG("Updated assertOnWake %lu\n", (unsigned long)assertOnWakeSecs);
2677 }
2678 }
2679 }
2680 else if (preventSystemSleepList->member(service))
2681 {
2682 preventSystemSleepList->removeObject(service);
2683 DLOG("prevent system sleep list: %s- (%u)\n",
2684 service->getName(), preventSystemSleepList->getCount());
2685
2686 if ((oldCount != 0) && (preventSystemSleepList->getCount() == 0))
2687 {
2688 // Lost all system sleep preventers.
2689 // Send stimulus if system sleep was blocked, and is in dark wake.
2690 evaluatePolicy( kStimulusDarkWakeEvaluate );
2691 }
2692 }
2693 newCount = preventSystemSleepList->getCount();
2694 messageClient(kIOPMMessageSystemSleepPreventers, systemCapabilityNotifier,
2695 &newCount, sizeof(newCount));
2696 }
2697
2698 void IOPMrootDomain::copySleepPreventersList(OSArray **idleSleepList, OSArray **systemSleepList)
2699 {
2700
2701 OSCollectionIterator *iterator = NULL;
2702 OSObject *object = NULL;
2703 OSArray *array = NULL;
2704
2705 if (!gIOPMWorkLoop->inGate())
2706 {
2707 gIOPMWorkLoop->runAction(
2708 OSMemberFunctionCast(IOWorkLoop::Action, this,
2709 &IOPMrootDomain::IOPMrootDomain::copySleepPreventersList),
2710 this, (void *)idleSleepList, (void *)systemSleepList);
2711 return;
2712 }
2713
2714 if (idleSleepList && preventIdleSleepList && (preventIdleSleepList->getCount() != 0))
2715 {
2716 iterator = OSCollectionIterator::withCollection(preventIdleSleepList);
2717 array = OSArray::withCapacity(5);
2718
2719 while ((object = iterator->getNextObject()))
2720 {
2721 IOService *service = OSDynamicCast(IOService, object);
2722 if (object)
2723 {
2724 array->setObject(OSSymbol::withCString(service->getName()));
2725 }
2726 }
2727
2728 iterator->release();
2729 *idleSleepList = array;
2730 }
2731
2732 if (systemSleepList && preventSystemSleepList && (preventSystemSleepList->getCount() != 0))
2733 {
2734 iterator = OSCollectionIterator::withCollection(preventSystemSleepList);
2735 array = OSArray::withCapacity(5);
2736
2737 while ((object = iterator->getNextObject()))
2738 {
2739 IOService *service = OSDynamicCast(IOService, object);
2740 if (object)
2741 {
2742 array->setObject(OSSymbol::withCString(service->getName()));
2743 }
2744 }
2745
2746 iterator->release();
2747 *systemSleepList = array;
2748 }
2749 }
2750
2751 //******************************************************************************
2752 // tellChangeDown
2753 //
2754 // Override the superclass implementation to send a different message type.
2755 //******************************************************************************
2756
2757 bool IOPMrootDomain::tellChangeDown( unsigned long stateNum )
2758 {
2759 DLOG("tellChangeDown %u->%u\n",
2760 (uint32_t) getPowerState(), (uint32_t) stateNum);
2761
2762 if (SLEEP_STATE == stateNum)
2763 {
2764 // Legacy apps were already told in the full->dark transition
2765 if (!ignoreTellChangeDown)
2766 tracePoint( kIOPMTracePointSleepApplications );
2767 else
2768 tracePoint( kIOPMTracePointSleepPriorityClients );
2769 }
2770
2771 if (!ignoreTellChangeDown) {
2772 userActivityAtSleep = userActivityCount;
2773 DLOG("tellChangeDown::userActivityAtSleep %d\n", userActivityAtSleep);
2774
2775 if (SLEEP_STATE == stateNum) {
2776 hibernateAborted = false;
2777
2778 // Direct callout into OSKext so it can disable kext unloads
2779 // during sleep/wake to prevent deadlocks.
2780 OSKextSystemSleepOrWake( kIOMessageSystemWillSleep );
2781
2782 IOService::updateConsoleUsers(NULL, kIOMessageSystemWillSleep);
2783
2784 // Two change downs are sent by IOServicePM. Ignore the 2nd.
2785 // But tellClientsWithResponse() must be called for both.
2786 ignoreTellChangeDown = true;
2787 }
2788 }
2789
2790 return super::tellClientsWithResponse( kIOMessageSystemWillSleep );
2791 }
2792
2793 //******************************************************************************
2794 // askChangeDown
2795 //
2796 // Override the superclass implementation to send a different message type.
2797 // This must be idle sleep since we don't ask during any other power change.
2798 //******************************************************************************
2799
2800 bool IOPMrootDomain::askChangeDown( unsigned long stateNum )
2801 {
2802 DLOG("askChangeDown %u->%u\n",
2803 (uint32_t) getPowerState(), (uint32_t) stateNum);
2804
2805 // Don't log for dark wake entry
2806 if (kSystemTransitionSleep == _systemTransitionType)
2807 tracePoint( kIOPMTracePointSleepApplications );
2808
2809 return super::tellClientsWithResponse( kIOMessageCanSystemSleep );
2810 }
2811
2812 //******************************************************************************
2813 // askChangeDownDone
2814 //
2815 // An opportunity for root domain to cancel the power transition,
2816 // possibily due to an assertion created by powerd in response to
2817 // kIOMessageCanSystemSleep.
2818 //
2819 // Idle sleep:
2820 // full -> dark wake transition
2821 // 1. Notify apps and powerd with kIOMessageCanSystemSleep
2822 // 2. askChangeDownDone()
2823 // dark -> sleep transition
2824 // 1. Notify powerd with kIOMessageCanSystemSleep
2825 // 2. askChangeDownDone()
2826 //
2827 // Demand sleep:
2828 // full -> dark wake transition
2829 // 1. Notify powerd with kIOMessageCanSystemSleep
2830 // 2. askChangeDownDone()
2831 // dark -> sleep transition
2832 // 1. Notify powerd with kIOMessageCanSystemSleep
2833 // 2. askChangeDownDone()
2834 //******************************************************************************
2835
2836 void IOPMrootDomain::askChangeDownDone(
2837 IOPMPowerChangeFlags * inOutChangeFlags, bool * cancel )
2838 {
2839 DLOG("askChangeDownDone(0x%x, %u) type %x, cap %x->%x\n",
2840 *inOutChangeFlags, *cancel,
2841 _systemTransitionType,
2842 _currentCapability, _pendingCapability);
2843
2844 if ((false == *cancel) && (kSystemTransitionSleep == _systemTransitionType))
2845 {
2846 // Dark->Sleep transition.
2847 // Check if there are any deny sleep assertions.
2848 // lastSleepReason already set by handleOurPowerChangeStart()
2849
2850 if (!checkSystemCanSleep(lastSleepReason))
2851 {
2852 // Cancel dark wake to sleep transition.
2853 // Must re-scan assertions upon entering dark wake.
2854
2855 *cancel = true;
2856 DLOG("cancel dark->sleep\n");
2857 }
2858 }
2859 }
2860
2861 //******************************************************************************
2862 // systemDidNotSleep
2863 //
2864 // Work common to both canceled or aborted sleep.
2865 //******************************************************************************
2866
2867 void IOPMrootDomain::systemDidNotSleep( void )
2868 {
2869 // reset console lock state
2870 thread_call_enter(updateConsoleUsersEntry);
2871
2872 if (!wrangler)
2873 {
2874 if (idleSleepEnabled)
2875 {
2876 // stay awake for at least idleSeconds
2877 startIdleSleepTimer(idleSeconds);
2878 }
2879 }
2880 else
2881 {
2882 if (idleSleepEnabled && !userIsActive)
2883 {
2884 // Manually start the idle sleep timer besides waiting for
2885 // the user to become inactive.
2886 startIdleSleepTimer( kIdleSleepRetryInterval );
2887 }
2888 }
2889
2890 preventTransitionToUserActive(false);
2891 IOService::setAdvisoryTickleEnable( true );
2892
2893 // After idle revert and cancel, send a did-change message to powerd
2894 // to balance the previous will-change message. Kernel clients do not
2895 // need this since sleep cannot be canceled once they are notified.
2896
2897 if (toldPowerdCapWillChange && systemCapabilityNotifier &&
2898 (_pendingCapability != _currentCapability) &&
2899 ((_systemMessageClientMask & kSystemMessageClientPowerd) != 0))
2900 {
2901 // Differs from a real capability gain change where notifyRef != 0,
2902 // but it is zero here since no response is expected.
2903
2904 IOPMSystemCapabilityChangeParameters params;
2905
2906 bzero(&params, sizeof(params));
2907 params.fromCapabilities = _pendingCapability;
2908 params.toCapabilities = _currentCapability;
2909 params.changeFlags = kIOPMSystemCapabilityDidChange;
2910
2911 DLOG("MESG cap %x->%x did change\n",
2912 params.fromCapabilities, params.toCapabilities);
2913 messageClient(kIOMessageSystemCapabilityChange, systemCapabilityNotifier,
2914 &params, sizeof(params));
2915 }
2916 }
2917
2918 //******************************************************************************
2919 // tellNoChangeDown
2920 //
2921 // Notify registered applications and kernel clients that we are not dropping
2922 // power.
2923 //
2924 // We override the superclass implementation so we can send a different message
2925 // type to the client or application being notified.
2926 //
2927 // This must be a vetoed idle sleep, since no other power change can be vetoed.
2928 //******************************************************************************
2929
2930 void IOPMrootDomain::tellNoChangeDown( unsigned long stateNum )
2931 {
2932 DLOG("tellNoChangeDown %u->%u\n",
2933 (uint32_t) getPowerState(), (uint32_t) stateNum);
2934
2935 // Sleep canceled, clear the sleep trace point.
2936 tracePoint(kIOPMTracePointSystemUp);
2937
2938 systemDidNotSleep();
2939 return tellClients( kIOMessageSystemWillNotSleep );
2940 }
2941
2942 //******************************************************************************
2943 // tellChangeUp
2944 //
2945 // Notify registered applications and kernel clients that we are raising power.
2946 //
2947 // We override the superclass implementation so we can send a different message
2948 // type to the client or application being notified.
2949 //******************************************************************************
2950
2951 void IOPMrootDomain::tellChangeUp( unsigned long stateNum )
2952 {
2953 DLOG("tellChangeUp %u->%u\n",
2954 (uint32_t) getPowerState(), (uint32_t) stateNum);
2955
2956 ignoreTellChangeDown = false;
2957
2958 if ( stateNum == ON_STATE )
2959 {
2960 // Direct callout into OSKext so it can disable kext unloads
2961 // during sleep/wake to prevent deadlocks.
2962 OSKextSystemSleepOrWake( kIOMessageSystemHasPoweredOn );
2963
2964 // Notify platform that sleep was cancelled or resumed.
2965 getPlatform()->callPlatformFunction(
2966 sleepMessagePEFunction, false,
2967 (void *)(uintptr_t) kIOMessageSystemHasPoweredOn,
2968 NULL, NULL, NULL);
2969
2970 if (getPowerState() == ON_STATE)
2971 {
2972 // this is a quick wake from aborted sleep
2973 systemDidNotSleep();
2974 tellClients( kIOMessageSystemWillPowerOn );
2975 }
2976
2977 tracePoint( kIOPMTracePointWakeApplications );
2978 tellClients( kIOMessageSystemHasPoweredOn );
2979 }
2980 }
2981
2982 #define CAP_WILL_CHANGE_TO_OFF(params, flag) \
2983 (((params)->changeFlags & kIOPMSystemCapabilityWillChange) && \
2984 ((params)->fromCapabilities & (flag)) && \
2985 (((params)->toCapabilities & (flag)) == 0))
2986
2987 #define CAP_DID_CHANGE_TO_ON(params, flag) \
2988 (((params)->changeFlags & kIOPMSystemCapabilityDidChange) && \
2989 ((params)->toCapabilities & (flag)) && \
2990 (((params)->fromCapabilities & (flag)) == 0))
2991
2992 #define CAP_DID_CHANGE_TO_OFF(params, flag) \
2993 (((params)->changeFlags & kIOPMSystemCapabilityDidChange) && \
2994 ((params)->fromCapabilities & (flag)) && \
2995 (((params)->toCapabilities & (flag)) == 0))
2996
2997 #define CAP_WILL_CHANGE_TO_ON(params, flag) \
2998 (((params)->changeFlags & kIOPMSystemCapabilityWillChange) && \
2999 ((params)->toCapabilities & (flag)) && \
3000 (((params)->fromCapabilities & (flag)) == 0))
3001
3002 //******************************************************************************
3003 // sysPowerDownHandler
3004 //
3005 // Perform a vfs sync before system sleep.
3006 //******************************************************************************
3007
3008 IOReturn IOPMrootDomain::sysPowerDownHandler(
3009 void * target, void * refCon,
3010 UInt32 messageType, IOService * service,
3011 void * messageArgs, vm_size_t argSize )
3012 {
3013 IOReturn ret = 0;
3014
3015 DLOG("sysPowerDownHandler message %s\n", getIOMessageString(messageType));
3016
3017 if (!gRootDomain)
3018 return kIOReturnUnsupported;
3019
3020 if (messageType == kIOMessageSystemCapabilityChange)
3021 {
3022 IOPMSystemCapabilityChangeParameters * params =
3023 (IOPMSystemCapabilityChangeParameters *) messageArgs;
3024
3025 // Interested applications have been notified of an impending power
3026 // change and have acked (when applicable).
3027 // This is our chance to save whatever state we can before powering
3028 // down.
3029 // We call sync_internal defined in xnu/bsd/vfs/vfs_syscalls.c,
3030 // via callout
3031
3032 DLOG("sysPowerDownHandler cap %x -> %x (flags %x)\n",
3033 params->fromCapabilities, params->toCapabilities,
3034 params->changeFlags);
3035
3036 if (CAP_WILL_CHANGE_TO_OFF(params, kIOPMSystemCapabilityCPU))
3037 {
3038 // We will ack within 20 seconds
3039 params->maxWaitForReply = 20 * 1000 * 1000;
3040
3041 #if HIBERNATION
3042 gRootDomain->evaluateSystemSleepPolicyEarly();
3043
3044 // add in time we could spend freeing pages
3045 if (gRootDomain->hibernateMode && !gRootDomain->hibernateDisabled)
3046 {
3047 params->maxWaitForReply = kCapabilityClientMaxWait;
3048 }
3049 DLOG("sysPowerDownHandler max wait %d s\n",
3050 (int) (params->maxWaitForReply / 1000 / 1000));
3051 #endif
3052
3053 // Notify platform that sleep has begun, after the early
3054 // sleep policy evaluation.
3055 getPlatform()->callPlatformFunction(
3056 sleepMessagePEFunction, false,
3057 (void *)(uintptr_t) kIOMessageSystemWillSleep,
3058 NULL, NULL, NULL);
3059
3060 if ( !OSCompareAndSwap( 0, 1, &gSleepOrShutdownPending ) )
3061 {
3062 // Purposely delay the ack and hope that shutdown occurs quickly.
3063 // Another option is not to schedule the thread and wait for
3064 // ack timeout...
3065 AbsoluteTime deadline;
3066 clock_interval_to_deadline( 30, kSecondScale, &deadline );
3067 thread_call_enter1_delayed(
3068 gRootDomain->diskSyncCalloutEntry,
3069 (thread_call_param_t)(uintptr_t) params->notifyRef,
3070 deadline );
3071 }
3072 else
3073 thread_call_enter1(
3074 gRootDomain->diskSyncCalloutEntry,
3075 (thread_call_param_t)(uintptr_t) params->notifyRef);
3076 }
3077 #if HIBERNATION
3078 else if (CAP_DID_CHANGE_TO_ON(params, kIOPMSystemCapabilityCPU))
3079 {
3080 // We will ack within 110 seconds
3081 params->maxWaitForReply = 110 * 1000 * 1000;
3082
3083 thread_call_enter1(
3084 gRootDomain->diskSyncCalloutEntry,
3085 (thread_call_param_t)(uintptr_t) params->notifyRef);
3086 }
3087 #endif
3088 ret = kIOReturnSuccess;
3089 }
3090
3091 return ret;
3092 }
3093
3094 //******************************************************************************
3095 // handleQueueSleepWakeUUID
3096 //
3097 // Called from IOPMrootDomain when we're initiating a sleep,
3098 // or indirectly from PM configd when PM decides to clear the UUID.
3099 // PM clears the UUID several minutes after successful wake from sleep,
3100 // so that we might associate App spindumps with the immediately previous
3101 // sleep/wake.
3102 //
3103 // @param obj has a retain on it. We're responsible for releasing that retain.
3104 //******************************************************************************
3105
3106 void IOPMrootDomain::handleQueueSleepWakeUUID(OSObject *obj)
3107 {
3108 OSString *str = NULL;
3109
3110 if (kOSBooleanFalse == obj)
3111 {
3112 handlePublishSleepWakeUUID(NULL);
3113 }
3114 else if ((str = OSDynamicCast(OSString, obj)))
3115 {
3116 // This branch caches the UUID for an upcoming sleep/wake
3117 if (queuedSleepWakeUUIDString) {
3118 queuedSleepWakeUUIDString->release();
3119 queuedSleepWakeUUIDString = NULL;
3120 }
3121 queuedSleepWakeUUIDString = str;
3122 queuedSleepWakeUUIDString->retain();
3123
3124 DLOG("SleepWake UUID queued: %s\n", queuedSleepWakeUUIDString->getCStringNoCopy());
3125 }
3126
3127 if (obj) {
3128 obj->release();
3129 }
3130 return;
3131
3132 }
3133 //******************************************************************************
3134 // handlePublishSleepWakeUUID
3135 //
3136 // Called from IOPMrootDomain when we're initiating a sleep,
3137 // or indirectly from PM configd when PM decides to clear the UUID.
3138 // PM clears the UUID several minutes after successful wake from sleep,
3139 // so that we might associate App spindumps with the immediately previous
3140 // sleep/wake.
3141 //******************************************************************************
3142
3143 void IOPMrootDomain::handlePublishSleepWakeUUID( bool shouldPublish )
3144 {
3145 ASSERT_GATED();
3146
3147 /*
3148 * Clear the current UUID
3149 */
3150 if (gSleepWakeUUIDIsSet)
3151 {
3152 DLOG("SleepWake UUID cleared\n");
3153
3154 gSleepWakeUUIDIsSet = false;
3155
3156 removeProperty(kIOPMSleepWakeUUIDKey);
3157 messageClients(kIOPMMessageSleepWakeUUIDChange, kIOPMMessageSleepWakeUUIDCleared);
3158 }
3159
3160 /*
3161 * Optionally, publish a new UUID
3162 */
3163 if (queuedSleepWakeUUIDString && shouldPublish) {
3164
3165 OSString *publishThisUUID = NULL;
3166
3167 publishThisUUID = queuedSleepWakeUUIDString;
3168 publishThisUUID->retain();
3169
3170 if (publishThisUUID)
3171 {
3172 setProperty(kIOPMSleepWakeUUIDKey, publishThisUUID);
3173 publishThisUUID->release();
3174 }
3175
3176 gSleepWakeUUIDIsSet = true;
3177 messageClients(kIOPMMessageSleepWakeUUIDChange, kIOPMMessageSleepWakeUUIDSet);
3178
3179 queuedSleepWakeUUIDString->release();
3180 queuedSleepWakeUUIDString = NULL;
3181 }
3182 }
3183
3184 //******************************************************************************
3185 // IOPMGetSleepWakeUUIDKey
3186 //
3187 // Return the truth value of gSleepWakeUUIDIsSet and optionally copy the key.
3188 // To get the full key -- a C string -- the buffer must large enough for
3189 // the end-of-string character.
3190 // The key is expected to be an UUID string
3191 //******************************************************************************
3192
3193 extern "C" bool
3194 IOPMCopySleepWakeUUIDKey(char *buffer, size_t buf_len)
3195 {
3196 if (!gSleepWakeUUIDIsSet) {
3197 return (false);
3198 }
3199
3200 if (buffer != NULL) {
3201 OSString *string;
3202
3203 string = (OSString *)
3204 gRootDomain->copyProperty(kIOPMSleepWakeUUIDKey);
3205
3206 if (string == NULL) {
3207 *buffer = '\0';
3208 } else {
3209 strlcpy(buffer, string->getCStringNoCopy(), buf_len);
3210
3211 string->release();
3212 }
3213 }
3214
3215 return (true);
3216 }
3217
3218 //******************************************************************************
3219 // initializeBootSessionUUID
3220 //
3221 // Initialize the boot session uuid at boot up and sets it into registry.
3222 //******************************************************************************
3223
3224 void IOPMrootDomain::initializeBootSessionUUID(void)
3225 {
3226 uuid_t new_uuid;
3227 uuid_string_t new_uuid_string;
3228
3229 uuid_generate(new_uuid);
3230 uuid_unparse_upper(new_uuid, new_uuid_string);
3231 memcpy(bootsessionuuid_string, new_uuid_string, sizeof(uuid_string_t));
3232
3233 setProperty(kIOPMBootSessionUUIDKey, new_uuid_string);
3234 }
3235
3236 //******************************************************************************
3237 // changePowerStateTo & changePowerStateToPriv
3238 //
3239 // Override of these methods for logging purposes.
3240 //******************************************************************************
3241
3242 IOReturn IOPMrootDomain::changePowerStateTo( unsigned long ordinal )
3243 {
3244 DLOG("changePowerStateTo(%lu)\n", ordinal);
3245
3246 if ((ordinal != ON_STATE) && (ordinal != SLEEP_STATE))
3247 return kIOReturnUnsupported;
3248
3249 return super::changePowerStateTo(ordinal);
3250 }
3251
3252 IOReturn IOPMrootDomain::changePowerStateToPriv( unsigned long ordinal )
3253 {
3254 DLOG("changePowerStateToPriv(%lu)\n", ordinal);
3255
3256 if ((ordinal != ON_STATE) && (ordinal != SLEEP_STATE))
3257 return kIOReturnUnsupported;
3258
3259 return super::changePowerStateToPriv(ordinal);
3260 }
3261
3262 //******************************************************************************
3263 // activity detect
3264 //
3265 //******************************************************************************
3266
3267 bool IOPMrootDomain::activitySinceSleep(void)
3268 {
3269 return (userActivityCount != userActivityAtSleep);
3270 }
3271
3272 bool IOPMrootDomain::abortHibernation(void)
3273 {
3274 bool ret = activitySinceSleep();
3275
3276 if (ret && !hibernateAborted && checkSystemCanSustainFullWake())
3277 {
3278 DLOG("activitySinceSleep ABORT [%d, %d]\n", userActivityCount, userActivityAtSleep);
3279 hibernateAborted = true;
3280 }
3281 return (ret);
3282 }
3283
3284 extern "C" int
3285 hibernate_should_abort(void)
3286 {
3287 if (gRootDomain)
3288 return (gRootDomain->abortHibernation());
3289 else
3290 return (0);
3291 }
3292
3293 //******************************************************************************
3294 // willNotifyPowerChildren
3295 //
3296 // Called after all interested drivers have all acknowledged the power change,
3297 // but before any power children is informed. Dispatched though a thread call,
3298 // so it is safe to perform work that might block on a sleeping disk. PM state
3299 // machine (not thread) will block w/o timeout until this function returns.
3300 //******************************************************************************
3301
3302 void IOPMrootDomain::willNotifyPowerChildren( IOPMPowerStateIndex newPowerState )
3303 {
3304 OSDictionary *dict;
3305 OSNumber *secs;
3306
3307 if (SLEEP_STATE == newPowerState)
3308 {
3309 notifierThread = current_thread();
3310 if (!tasksSuspended)
3311 {
3312 AbsoluteTime deadline;
3313 tasksSuspended = TRUE;
3314 tasks_system_suspend(tasksSuspended);
3315
3316 clock_interval_to_deadline(10, kSecondScale, &deadline);
3317 #if !CONFIG_EMBEDDED
3318 vm_pageout_wait(AbsoluteTime_to_scalar(&deadline));
3319 #endif /* !CONFIG_EMBEDDED */
3320 }
3321
3322 #if HIBERNATION
3323 IOHibernateSystemSleep();
3324 IOHibernateIOKitSleep();
3325 #endif
3326 if (gRootDomain->activitySinceSleep()) {
3327 dict = OSDictionary::withCapacity(1);
3328 secs = OSNumber::withNumber(1, 32);
3329
3330 if (dict && secs) {
3331 dict->setObject(gIOPMSettingDebugWakeRelativeKey, secs);
3332 gRootDomain->setProperties(dict);
3333 MSG("Reverting sleep with relative wake\n");
3334 }
3335 if (dict) dict->release();
3336 if (secs) secs->release();
3337 }
3338
3339 notifierThread = NULL;
3340 }
3341 }
3342
3343 //******************************************************************************
3344 // sleepOnClamshellClosed
3345 //
3346 // contains the logic to determine if the system should sleep when the clamshell
3347 // is closed.
3348 //******************************************************************************
3349
3350 bool IOPMrootDomain::shouldSleepOnClamshellClosed( void )
3351 {
3352 if (!clamshellExists)
3353 return false;
3354
3355 DLOG("clamshell closed %d, disabled %d, desktopMode %d, ac %d sleepDisabled %d\n",
3356 clamshellClosed, clamshellDisabled, desktopMode, acAdaptorConnected, clamshellSleepDisabled);
3357
3358 return ( !clamshellDisabled && !(desktopMode && acAdaptorConnected) && !clamshellSleepDisabled );
3359 }
3360
3361 void IOPMrootDomain::sendClientClamshellNotification( void )
3362 {
3363 /* Only broadcast clamshell alert if clamshell exists. */
3364 if (!clamshellExists)
3365 return;
3366
3367 setProperty(kAppleClamshellStateKey,
3368 clamshellClosed ? kOSBooleanTrue : kOSBooleanFalse);
3369
3370 setProperty(kAppleClamshellCausesSleepKey,
3371 shouldSleepOnClamshellClosed() ? kOSBooleanTrue : kOSBooleanFalse);
3372
3373 /* Argument to message is a bitfiel of
3374 * ( kClamshellStateBit | kClamshellSleepBit )
3375 */
3376 messageClients(kIOPMMessageClamshellStateChange,
3377 (void *)(uintptr_t) ( (clamshellClosed ? kClamshellStateBit : 0)
3378 | ( shouldSleepOnClamshellClosed() ? kClamshellSleepBit : 0)) );
3379 }
3380
3381 //******************************************************************************
3382 // getSleepSupported
3383 //
3384 // Deprecated
3385 //******************************************************************************
3386
3387 IOOptionBits IOPMrootDomain::getSleepSupported( void )
3388 {
3389 return( platformSleepSupport );
3390 }
3391
3392 //******************************************************************************
3393 // setSleepSupported
3394 //
3395 // Deprecated
3396 //******************************************************************************
3397
3398 void IOPMrootDomain::setSleepSupported( IOOptionBits flags )
3399 {
3400 DLOG("setSleepSupported(%x)\n", (uint32_t) flags);
3401 OSBitOrAtomic(flags, &platformSleepSupport);
3402 }
3403
3404 //******************************************************************************
3405 // setDisableClamShellSleep
3406 //
3407 //******************************************************************************
3408
3409 void IOPMrootDomain::setDisableClamShellSleep( bool val )
3410 {
3411 if (gIOPMWorkLoop->inGate() == false) {
3412
3413 gIOPMWorkLoop->runAction(
3414 OSMemberFunctionCast(IOWorkLoop::Action, this, &IOPMrootDomain::setDisableClamShellSleep),
3415 (OSObject *)this,
3416 (void *)val);
3417
3418 return;
3419 }
3420 else {
3421 DLOG("setDisableClamShellSleep(%x)\n", (uint32_t) val);
3422 if ( clamshellSleepDisabled != val )
3423 {
3424 clamshellSleepDisabled = val;
3425 // If clamshellSleepDisabled is reset to 0, reevaluate if
3426 // system need to go to sleep due to clamshell state
3427 if ( !clamshellSleepDisabled && clamshellClosed)
3428 handlePowerNotification(kLocalEvalClamshellCommand);
3429 }
3430 }
3431 }
3432
3433 //******************************************************************************
3434 // wakeFromDoze
3435 //
3436 // Deprecated.
3437 //******************************************************************************
3438
3439 void IOPMrootDomain::wakeFromDoze( void )
3440 {
3441 // Preserve symbol for familes (IOUSBFamily and IOGraphics)
3442 }
3443
3444 // MARK: -
3445 // MARK: Features
3446
3447 //******************************************************************************
3448 // publishFeature
3449 //
3450 // Adds a new feature to the supported features dictionary
3451 //******************************************************************************
3452
3453 void IOPMrootDomain::publishFeature( const char * feature )
3454 {
3455 publishFeature(feature, kRD_AllPowerSources, NULL);
3456 }
3457
3458 //******************************************************************************
3459 // publishFeature (with supported power source specified)
3460 //
3461 // Adds a new feature to the supported features dictionary
3462 //******************************************************************************
3463
3464 void IOPMrootDomain::publishFeature(
3465 const char *feature,
3466 uint32_t supportedWhere,
3467 uint32_t *uniqueFeatureID)
3468 {
3469 static uint16_t next_feature_id = 500;
3470
3471 OSNumber *new_feature_data = NULL;
3472 OSNumber *existing_feature = NULL;
3473 OSArray *existing_feature_arr = NULL;
3474 OSObject *osObj = NULL;
3475 uint32_t feature_value = 0;
3476
3477 supportedWhere &= kRD_AllPowerSources; // mask off any craziness!
3478
3479 if(!supportedWhere) {
3480 // Feature isn't supported anywhere!
3481 return;
3482 }
3483
3484 if(next_feature_id > 5000) {
3485 // Far, far too many features!
3486 return;
3487 }
3488
3489 if(featuresDictLock) IOLockLock(featuresDictLock);
3490
3491 OSDictionary *features =
3492 (OSDictionary *) getProperty(kRootDomainSupportedFeatures);
3493
3494 // Create new features dict if necessary
3495 if ( features && OSDynamicCast(OSDictionary, features)) {
3496 features = OSDictionary::withDictionary(features);
3497 } else {
3498 features = OSDictionary::withCapacity(1);
3499 }
3500
3501 // Create OSNumber to track new feature
3502
3503 next_feature_id += 1;
3504 if( uniqueFeatureID ) {
3505 // We don't really mind if the calling kext didn't give us a place
3506 // to stash their unique id. Many kexts don't plan to unload, and thus
3507 // have no need to remove themselves later.
3508 *uniqueFeatureID = next_feature_id;
3509 }
3510
3511 feature_value = (uint32_t)next_feature_id;
3512 feature_value <<= 16;
3513 feature_value += supportedWhere;
3514
3515 new_feature_data = OSNumber::withNumber(
3516 (unsigned long long)feature_value, 32);
3517
3518 // Does features object already exist?
3519 if( (osObj = features->getObject(feature)) )
3520 {
3521 if(( existing_feature = OSDynamicCast(OSNumber, osObj) ))
3522 {
3523 // We need to create an OSArray to hold the now 2 elements.
3524 existing_feature_arr = OSArray::withObjects(
3525 (const OSObject **)&existing_feature, 1, 2);
3526 } else if(( existing_feature_arr = OSDynamicCast(OSArray, osObj) ))
3527 {
3528 // Add object to existing array
3529 existing_feature_arr = OSArray::withArray(
3530 existing_feature_arr,
3531 existing_feature_arr->getCount() + 1);
3532 }
3533
3534 if (existing_feature_arr)
3535 {
3536 existing_feature_arr->setObject(new_feature_data);
3537 features->setObject(feature, existing_feature_arr);
3538 existing_feature_arr->release();
3539 existing_feature_arr = 0;
3540 }
3541 } else {
3542 // The easy case: no previously existing features listed. We simply
3543 // set the OSNumber at key 'feature' and we're on our way.
3544 features->setObject(feature, new_feature_data);
3545 }
3546
3547 new_feature_data->release();
3548
3549 setProperty(kRootDomainSupportedFeatures, features);
3550
3551 features->release();
3552
3553 if(featuresDictLock) IOLockUnlock(featuresDictLock);
3554
3555 // Notify EnergySaver and all those in user space so they might
3556 // re-populate their feature specific UI
3557 if(pmPowerStateQueue) {
3558 pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
3559 }
3560 }
3561
3562 //******************************************************************************
3563 // removePublishedFeature
3564 //
3565 // Removes previously published feature
3566 //******************************************************************************
3567
3568 IOReturn IOPMrootDomain::removePublishedFeature( uint32_t removeFeatureID )
3569 {
3570 IOReturn ret = kIOReturnError;
3571 uint32_t feature_value = 0;
3572 uint16_t feature_id = 0;
3573 bool madeAChange = false;
3574
3575 OSSymbol *dictKey = NULL;
3576 OSCollectionIterator *dictIterator = NULL;
3577 OSArray *arrayMember = NULL;
3578 OSNumber *numberMember = NULL;
3579 OSObject *osObj = NULL;
3580 OSNumber *osNum = NULL;
3581 OSArray *arrayMemberCopy;
3582
3583 if (kBadPMFeatureID == removeFeatureID)
3584 return kIOReturnNotFound;
3585
3586 if(featuresDictLock) IOLockLock(featuresDictLock);
3587
3588 OSDictionary *features =
3589 (OSDictionary *) getProperty(kRootDomainSupportedFeatures);
3590
3591 if ( features && OSDynamicCast(OSDictionary, features) )
3592 {
3593 // Any modifications to the dictionary are made to the copy to prevent
3594 // races & crashes with userland clients. Dictionary updated
3595 // automically later.
3596 features = OSDictionary::withDictionary(features);
3597 } else {
3598 features = NULL;
3599 ret = kIOReturnNotFound;
3600 goto exit;
3601 }
3602
3603 // We iterate 'features' dictionary looking for an entry tagged
3604 // with 'removeFeatureID'. If found, we remove it from our tracking
3605 // structures and notify the OS via a general interest message.
3606
3607 dictIterator = OSCollectionIterator::withCollection(features);
3608 if(!dictIterator) {
3609 goto exit;
3610 }
3611
3612 while( (dictKey = OSDynamicCast(OSSymbol, dictIterator->getNextObject())) )
3613 {
3614 osObj = features->getObject(dictKey);
3615
3616 // Each Feature is either tracked by an OSNumber
3617 if( osObj && (numberMember = OSDynamicCast(OSNumber, osObj)) )
3618 {
3619 feature_value = numberMember->unsigned32BitValue();
3620 feature_id = (uint16_t)(feature_value >> 16);
3621
3622 if( feature_id == (uint16_t)removeFeatureID )
3623 {
3624 // Remove this node
3625 features->removeObject(dictKey);
3626 madeAChange = true;
3627 break;
3628 }
3629
3630 // Or tracked by an OSArray of OSNumbers
3631 } else if( osObj && (arrayMember = OSDynamicCast(OSArray, osObj)) )
3632 {
3633 unsigned int arrayCount = arrayMember->getCount();
3634
3635 for(unsigned int i=0; i<arrayCount; i++)
3636 {
3637 osNum = OSDynamicCast(OSNumber, arrayMember->getObject(i));
3638 if(!osNum) {
3639 continue;
3640 }
3641
3642 feature_value = osNum->unsigned32BitValue();
3643 feature_id = (uint16_t)(feature_value >> 16);
3644
3645 if( feature_id == (uint16_t)removeFeatureID )
3646 {
3647 // Remove this node
3648 if( 1 == arrayCount ) {
3649 // If the array only contains one element, remove
3650 // the whole thing.
3651 features->removeObject(dictKey);
3652 } else {
3653 // Otherwise remove the element from a copy of the array.
3654 arrayMemberCopy = OSArray::withArray(arrayMember);
3655 if (arrayMemberCopy)
3656 {
3657 arrayMemberCopy->removeObject(i);
3658 features->setObject(dictKey, arrayMemberCopy);
3659 arrayMemberCopy->release();
3660 }
3661 }
3662
3663 madeAChange = true;
3664 break;
3665 }
3666 }
3667 }
3668 }
3669
3670 dictIterator->release();
3671
3672 if( madeAChange )
3673 {
3674 ret = kIOReturnSuccess;
3675
3676 setProperty(kRootDomainSupportedFeatures, features);
3677
3678 // Notify EnergySaver and all those in user space so they might
3679 // re-populate their feature specific UI
3680 if(pmPowerStateQueue) {
3681 pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
3682 }
3683 } else {
3684 ret = kIOReturnNotFound;
3685 }
3686
3687 exit:
3688 if(features) features->release();
3689 if(featuresDictLock) IOLockUnlock(featuresDictLock);
3690 return ret;
3691 }
3692
3693 //******************************************************************************
3694 // publishPMSetting (private)
3695 //
3696 // Should only be called by PMSettingObject to publish a PM Setting as a
3697 // supported feature.
3698 //******************************************************************************
3699
3700 void IOPMrootDomain::publishPMSetting(
3701 const OSSymbol * feature, uint32_t where, uint32_t * featureID )
3702 {
3703 if (noPublishPMSettings &&
3704 (noPublishPMSettings->getNextIndexOfObject(feature, 0) != (unsigned int)-1))
3705 {
3706 // Setting found in noPublishPMSettings array
3707 *featureID = kBadPMFeatureID;
3708 return;
3709 }
3710
3711 publishFeature(
3712 feature->getCStringNoCopy(), where, featureID);
3713 }
3714
3715 //******************************************************************************
3716 // setPMSetting (private)
3717 //
3718 // Internal helper to relay PM settings changes from user space to individual
3719 // drivers. Should be called only by IOPMrootDomain::setProperties.
3720 //******************************************************************************
3721
3722 IOReturn IOPMrootDomain::setPMSetting(
3723 const OSSymbol *type,
3724 OSObject *object )
3725 {
3726 PMSettingCallEntry *entries = 0;
3727 OSArray *chosen = 0;
3728 const OSArray *array;
3729 PMSettingObject *pmso;
3730 thread_t thisThread;
3731 int i, j, count, capacity;
3732
3733 if (NULL == type)
3734 return kIOReturnBadArgument;
3735
3736 PMSETTING_LOCK();
3737
3738 // Update settings dict so changes are visible from copyPMSetting().
3739 fPMSettingsDict->setObject(type, object);
3740
3741 // Prep all PMSetting objects with the given 'type' for callout.
3742 array = OSDynamicCast(OSArray, settingsCallbacks->getObject(type));
3743 if (!array || ((capacity = array->getCount()) == 0))
3744 goto unlock_exit;
3745
3746 // Array to retain PMSetting objects targeted for callout.
3747 chosen = OSArray::withCapacity(capacity);
3748 if (!chosen)
3749 goto unlock_exit; // error
3750
3751 entries = IONew(PMSettingCallEntry, capacity);
3752 if (!entries)
3753 goto unlock_exit; // error
3754 memset(entries, 0, sizeof(PMSettingCallEntry) * capacity);
3755
3756 thisThread = current_thread();
3757
3758 for (i = 0, j = 0; i<capacity; i++)
3759 {
3760 pmso = (PMSettingObject *) array->getObject(i);
3761 if (pmso->disabled)
3762 continue;
3763 entries[j].thread = thisThread;
3764 queue_enter(&pmso->calloutQueue, &entries[j], PMSettingCallEntry *, link);
3765 chosen->setObject(pmso);
3766 j++;
3767 }
3768 count = j;
3769 if (!count)
3770 goto unlock_exit;
3771
3772 PMSETTING_UNLOCK();
3773
3774 // Call each pmso in the chosen array.
3775 for (i=0; i<count; i++)
3776 {
3777 pmso = (PMSettingObject *) chosen->getObject(i);
3778 pmso->dispatchPMSetting(type, object);
3779 }
3780
3781 PMSETTING_LOCK();
3782 for (i=0; i<count; i++)
3783 {
3784 pmso = (PMSettingObject *) chosen->getObject(i);
3785 queue_remove(&pmso->calloutQueue, &entries[i], PMSettingCallEntry *, link);
3786 if (pmso->waitThread)
3787 {
3788 PMSETTING_WAKEUP(pmso);
3789 }
3790 }
3791 unlock_exit:
3792 PMSETTING_UNLOCK();
3793
3794 if (chosen) chosen->release();
3795 if (entries) IODelete(entries, PMSettingCallEntry, capacity);
3796
3797 return kIOReturnSuccess;
3798 }
3799
3800 //******************************************************************************
3801 // copyPMSetting (public)
3802 //
3803 // Allows kexts to safely read setting values, without being subscribed to
3804 // notifications.
3805 //******************************************************************************
3806
3807 OSObject * IOPMrootDomain::copyPMSetting(
3808 OSSymbol *whichSetting)
3809 {
3810 OSObject *obj = NULL;
3811
3812 if(!whichSetting) return NULL;
3813
3814 PMSETTING_LOCK();
3815 obj = fPMSettingsDict->getObject(whichSetting);
3816 if(obj) {
3817 obj->retain();
3818 }
3819 PMSETTING_UNLOCK();
3820
3821 return obj;
3822 }
3823
3824 //******************************************************************************
3825 // registerPMSettingController (public)
3826 //
3827 // direct wrapper to registerPMSettingController with uint32_t power source arg
3828 //******************************************************************************
3829
3830 IOReturn IOPMrootDomain::registerPMSettingController(
3831 const OSSymbol * settings[],
3832 IOPMSettingControllerCallback func,
3833 OSObject *target,
3834 uintptr_t refcon,
3835 OSObject **handle)
3836 {
3837 return registerPMSettingController(
3838 settings,
3839 (kIOPMSupportedOnAC | kIOPMSupportedOnBatt | kIOPMSupportedOnUPS),
3840 func, target, refcon, handle);
3841 }
3842
3843 //******************************************************************************
3844 // registerPMSettingController (public)
3845 //
3846 // Kexts may register for notifications when a particular setting is changed.
3847 // A list of settings is available in IOPM.h.
3848 // Arguments:
3849 // * settings - An OSArray containing OSSymbols. Caller should populate this
3850 // array with a list of settings caller wants notifications from.
3851 // * func - A C function callback of the type IOPMSettingControllerCallback
3852 // * target - caller may provide an OSObject *, which PM will pass as an
3853 // target to calls to "func"
3854 // * refcon - caller may provide an void *, which PM will pass as an
3855 // argument to calls to "func"
3856 // * handle - This is a return argument. We will populate this pointer upon
3857 // call success. Hold onto this and pass this argument to
3858 // IOPMrootDomain::deRegisterPMSettingCallback when unloading your kext
3859 // Returns:
3860 // kIOReturnSuccess on success
3861 //******************************************************************************
3862
3863 IOReturn IOPMrootDomain::registerPMSettingController(
3864 const OSSymbol * settings[],
3865 uint32_t supportedPowerSources,
3866 IOPMSettingControllerCallback func,
3867 OSObject *target,
3868 uintptr_t refcon,
3869 OSObject **handle)
3870 {
3871 PMSettingObject *pmso = NULL;
3872 OSObject *pmsh = NULL;
3873 OSArray *list = NULL;
3874 int i;
3875
3876 if (NULL == settings ||
3877 NULL == func ||
3878 NULL == handle)
3879 {
3880 return kIOReturnBadArgument;
3881 }
3882
3883 pmso = PMSettingObject::pmSettingObject(
3884 (IOPMrootDomain *) this, func, target,
3885 refcon, supportedPowerSources, settings, &pmsh);
3886
3887 if (!pmso) {
3888 *handle = NULL;
3889 return kIOReturnInternalError;
3890 }
3891
3892 PMSETTING_LOCK();
3893 for (i=0; settings[i]; i++)
3894 {
3895 list = OSDynamicCast(OSArray, settingsCallbacks->getObject(settings[i]));
3896 if (!list) {
3897 // New array of callbacks for this setting
3898 list = OSArray::withCapacity(1);
3899 settingsCallbacks->setObject(settings[i], list);
3900 list->release();
3901 }
3902
3903 // Add caller to the callback list
3904 list->setObject(pmso);
3905 }
3906 PMSETTING_UNLOCK();
3907
3908 // Return handle to the caller, the setting object is private.
3909 *handle = pmsh;
3910
3911 return kIOReturnSuccess;
3912 }
3913
3914 //******************************************************************************
3915 // deregisterPMSettingObject (private)
3916 //
3917 // Only called from PMSettingObject.
3918 //******************************************************************************
3919
3920 void IOPMrootDomain::deregisterPMSettingObject( PMSettingObject * pmso )
3921 {
3922 thread_t thisThread = current_thread();
3923 PMSettingCallEntry *callEntry;
3924 OSCollectionIterator *iter;
3925 OSSymbol *sym;
3926 OSArray *array;
3927 int index;
3928 bool wait;
3929
3930 PMSETTING_LOCK();
3931
3932 pmso->disabled = true;
3933
3934 // Wait for all callout threads to finish.
3935 do {
3936 wait = false;
3937 queue_iterate(&pmso->calloutQueue, callEntry, PMSettingCallEntry *, link)
3938 {
3939 if (callEntry->thread != thisThread)
3940 {
3941 wait = true;
3942 break;
3943 }
3944 }
3945 if (wait)
3946 {
3947 assert(0 == pmso->waitThread);
3948 pmso->waitThread = thisThread;
3949 PMSETTING_WAIT(pmso);
3950 pmso->waitThread = 0;
3951 }
3952 } while (wait);
3953
3954 // Search each PM settings array in the kernel.
3955 iter = OSCollectionIterator::withCollection(settingsCallbacks);
3956 if (iter)
3957 {
3958 while ((sym = OSDynamicCast(OSSymbol, iter->getNextObject())))
3959 {
3960 array = OSDynamicCast(OSArray, settingsCallbacks->getObject(sym));
3961 index = array->getNextIndexOfObject(pmso, 0);
3962 if (-1 != index) {
3963 array->removeObject(index);
3964 }
3965 }
3966 iter->release();
3967 }
3968
3969 PMSETTING_UNLOCK();
3970
3971 pmso->release();
3972 }
3973
3974 //******************************************************************************
3975 // informCPUStateChange
3976 //
3977 // Call into PM CPU code so that CPU power savings may dynamically adjust for
3978 // running on battery, with the lid closed, etc.
3979 //
3980 // informCPUStateChange is a no-op on non x86 systems
3981 // only x86 has explicit support in the IntelCPUPowerManagement kext
3982 //******************************************************************************
3983
3984 void IOPMrootDomain::informCPUStateChange(
3985 uint32_t type,
3986 uint32_t value )
3987 {
3988 #if defined(__i386__) || defined(__x86_64__)
3989
3990 pmioctlVariableInfo_t varInfoStruct;
3991 int pmCPUret = 0;
3992 const char *varNameStr = NULL;
3993 int32_t *varIndex = NULL;
3994
3995 if (kInformAC == type) {
3996 varNameStr = kIOPMRootDomainBatPowerCString;
3997 varIndex = &idxPMCPULimitedPower;
3998 } else if (kInformLid == type) {
3999 varNameStr = kIOPMRootDomainLidCloseCString;
4000 varIndex = &idxPMCPUClamshell;
4001 } else {
4002 return;
4003 }
4004
4005 // Set the new value!
4006 // pmCPUControl will assign us a new ID if one doesn't exist yet
4007 bzero(&varInfoStruct, sizeof(pmioctlVariableInfo_t));
4008 varInfoStruct.varID = *varIndex;
4009 varInfoStruct.varType = vBool;
4010 varInfoStruct.varInitValue = value;
4011 varInfoStruct.varCurValue = value;
4012 strlcpy( (char *)varInfoStruct.varName,
4013 (const char *)varNameStr,
4014 sizeof(varInfoStruct.varName));
4015
4016 // Set!
4017 pmCPUret = pmCPUControl( PMIOCSETVARINFO, (void *)&varInfoStruct );
4018
4019 // pmCPU only assigns numerical id's when a new varName is specified
4020 if ((0 == pmCPUret)
4021 && (*varIndex == kCPUUnknownIndex))
4022 {
4023 // pmCPUControl has assigned us a new variable ID.
4024 // Let's re-read the structure we just SET to learn that ID.
4025 pmCPUret = pmCPUControl( PMIOCGETVARNAMEINFO, (void *)&varInfoStruct );
4026
4027 if (0 == pmCPUret)
4028 {
4029 // Store it in idxPMCPUClamshell or idxPMCPULimitedPower
4030 *varIndex = varInfoStruct.varID;
4031 }
4032 }
4033
4034 return;
4035
4036 #endif /* __i386__ || __x86_64__ */
4037 }
4038
4039 // MARK: -
4040 // MARK: Deep Sleep Policy
4041
4042 #if HIBERNATION
4043
4044 //******************************************************************************
4045 // evaluateSystemSleepPolicy
4046 //******************************************************************************
4047
4048 #define kIOPlatformSystemSleepPolicyKey "IOPlatformSystemSleepPolicy"
4049
4050 // Sleep flags
4051 enum {
4052 kIOPMSleepFlagHibernate = 0x00000001,
4053 kIOPMSleepFlagSleepTimerEnable = 0x00000002
4054 };
4055
4056 struct IOPMSystemSleepPolicyEntry
4057 {
4058 uint32_t factorMask;
4059 uint32_t factorBits;
4060 uint32_t sleepFlags;
4061 uint32_t wakeEvents;
4062 } __attribute__((packed));
4063
4064 struct IOPMSystemSleepPolicyTable
4065 {
4066 uint32_t signature;
4067 uint16_t version;
4068 uint16_t entryCount;
4069 IOPMSystemSleepPolicyEntry entries[];
4070 } __attribute__((packed));
4071
4072 enum {
4073 kIOPMSleepAttributeHibernateSetup = 0x00000001,
4074 kIOPMSleepAttributeHibernateSleep = 0x00000002
4075 };
4076
4077 static uint32_t
4078 getSleepTypeAttributes( uint32_t sleepType )
4079 {
4080 static const uint32_t sleepTypeAttributes[ kIOPMSleepTypeLast ] =
4081 {
4082 /* invalid */ 0,
4083 /* abort */ 0,
4084 /* normal */ 0,
4085 /* safesleep */ kIOPMSleepAttributeHibernateSetup,
4086 /* hibernate */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
4087 /* standby */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
4088 /* poweroff */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
4089 /* deepidle */ 0
4090 };
4091
4092 if (sleepType >= kIOPMSleepTypeLast)
4093 return 0;
4094
4095 return sleepTypeAttributes[sleepType];
4096 }
4097
4098 bool IOPMrootDomain::evaluateSystemSleepPolicy(
4099 IOPMSystemSleepParameters * params, int sleepPhase, uint32_t * hibMode )
4100 {
4101 const IOPMSystemSleepPolicyTable * pt;
4102 OSObject * prop = 0;
4103 OSData * policyData;
4104 uint64_t currentFactors = 0;
4105 uint32_t standbyDelay = 0;
4106 uint32_t powerOffDelay = 0;
4107 uint32_t powerOffTimer = 0;
4108 uint32_t standbyTimer = 0;
4109 uint32_t mismatch;
4110 bool standbyEnabled;
4111 bool powerOffEnabled;
4112 bool found = false;
4113
4114 // Get platform's sleep policy table
4115 if (!gSleepPolicyHandler)
4116 {
4117 prop = getServiceRoot()->copyProperty(kIOPlatformSystemSleepPolicyKey);
4118 if (!prop) goto done;
4119 }
4120
4121 // Fetch additional settings
4122 standbyEnabled = (getSleepOption(kIOPMDeepSleepDelayKey, &standbyDelay)
4123 && (getProperty(kIOPMDeepSleepEnabledKey) == kOSBooleanTrue));
4124 powerOffEnabled = (getSleepOption(kIOPMAutoPowerOffDelayKey, &powerOffDelay)
4125 && (getProperty(kIOPMAutoPowerOffEnabledKey) == kOSBooleanTrue));
4126 if (!getSleepOption(kIOPMAutoPowerOffTimerKey, &powerOffTimer))
4127 powerOffTimer = powerOffDelay;
4128 if (!getSleepOption(kIOPMDeepSleepTimerKey, &standbyTimer))
4129 standbyTimer = standbyDelay;
4130
4131 DLOG("phase %d, standby %d delay %u timer %u, poweroff %d delay %u timer %u, hibernate 0x%x\n",
4132 sleepPhase, standbyEnabled, standbyDelay, standbyTimer,
4133 powerOffEnabled, powerOffDelay, powerOffTimer, *hibMode);
4134
4135 // pmset level overrides
4136 if ((*hibMode & kIOHibernateModeOn) == 0)
4137 {
4138 if (!gSleepPolicyHandler)
4139 {
4140 standbyEnabled = false;
4141 powerOffEnabled = false;
4142 }
4143 }
4144 else if (!(*hibMode & kIOHibernateModeSleep))
4145 {
4146 // Force hibernate (i.e. mode 25)
4147 // If standby is enabled, force standy.
4148 // If poweroff is enabled, force poweroff.
4149 if (standbyEnabled)
4150 currentFactors |= kIOPMSleepFactorStandbyForced;
4151 else if (powerOffEnabled)
4152 currentFactors |= kIOPMSleepFactorAutoPowerOffForced;
4153 else
4154 currentFactors |= kIOPMSleepFactorHibernateForced;
4155 }
4156
4157 // Current factors based on environment and assertions
4158 if (sleepTimerMaintenance)
4159 currentFactors |= kIOPMSleepFactorSleepTimerWake;
4160 if (standbyEnabled && sleepToStandby && !gSleepPolicyHandler)
4161 currentFactors |= kIOPMSleepFactorSleepTimerWake;
4162 if (!clamshellClosed)
4163 currentFactors |= kIOPMSleepFactorLidOpen;
4164 if (acAdaptorConnected)
4165 currentFactors |= kIOPMSleepFactorACPower;
4166 if (lowBatteryCondition)
4167 currentFactors |= kIOPMSleepFactorBatteryLow;
4168 if (!standbyDelay || !standbyTimer)
4169 currentFactors |= kIOPMSleepFactorStandbyNoDelay;
4170 if (standbyNixed || !standbyEnabled)
4171 currentFactors |= kIOPMSleepFactorStandbyDisabled;
4172 if (resetTimers)
4173 {
4174 currentFactors |= kIOPMSleepFactorLocalUserActivity;
4175 currentFactors &= ~kIOPMSleepFactorSleepTimerWake;
4176 }
4177 if (getPMAssertionLevel(kIOPMDriverAssertionUSBExternalDeviceBit) !=
4178 kIOPMDriverAssertionLevelOff)
4179 currentFactors |= kIOPMSleepFactorUSBExternalDevice;
4180 if (getPMAssertionLevel(kIOPMDriverAssertionBluetoothHIDDevicePairedBit) !=
4181 kIOPMDriverAssertionLevelOff)
4182 currentFactors |= kIOPMSleepFactorBluetoothHIDDevice;
4183 if (getPMAssertionLevel(kIOPMDriverAssertionExternalMediaMountedBit) !=
4184 kIOPMDriverAssertionLevelOff)
4185 currentFactors |= kIOPMSleepFactorExternalMediaMounted;
4186 if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit5) !=
4187 kIOPMDriverAssertionLevelOff)
4188 currentFactors |= kIOPMSleepFactorThunderboltDevice;
4189 if (_scheduledAlarms != 0)
4190 currentFactors |= kIOPMSleepFactorRTCAlarmScheduled;
4191 if (getPMAssertionLevel(kIOPMDriverAssertionMagicPacketWakeEnabledBit) !=
4192 kIOPMDriverAssertionLevelOff)
4193 currentFactors |= kIOPMSleepFactorMagicPacketWakeEnabled;
4194 #define TCPKEEPALIVE 1
4195 #if TCPKEEPALIVE
4196 if (getPMAssertionLevel(kIOPMDriverAssertionNetworkKeepAliveActiveBit) !=
4197 kIOPMDriverAssertionLevelOff)
4198 currentFactors |= kIOPMSleepFactorNetworkKeepAliveActive;
4199 #endif
4200 if (!powerOffEnabled)
4201 currentFactors |= kIOPMSleepFactorAutoPowerOffDisabled;
4202 if (desktopMode)
4203 currentFactors |= kIOPMSleepFactorExternalDisplay;
4204 if (userWasActive)
4205 currentFactors |= kIOPMSleepFactorLocalUserActivity;
4206 if (darkWakeHibernateError && !CAP_HIGHEST(kIOPMSystemCapabilityGraphics))
4207 currentFactors |= kIOPMSleepFactorHibernateFailed;
4208 if (thermalWarningState)
4209 currentFactors |= kIOPMSleepFactorThermalWarning;
4210
4211 DLOG("sleep factors 0x%llx\n", currentFactors);
4212
4213 if (gSleepPolicyHandler)
4214 {
4215 uint32_t savedHibernateMode;
4216 IOReturn result;
4217
4218 if (!gSleepPolicyVars)
4219 {
4220 gSleepPolicyVars = IONew(IOPMSystemSleepPolicyVariables, 1);
4221 if (!gSleepPolicyVars)
4222 goto done;
4223 bzero(gSleepPolicyVars, sizeof(*gSleepPolicyVars));
4224 }
4225 gSleepPolicyVars->signature = kIOPMSystemSleepPolicySignature;
4226 gSleepPolicyVars->version = kIOPMSystemSleepPolicyVersion;
4227 gSleepPolicyVars->currentCapability = _currentCapability;
4228 gSleepPolicyVars->highestCapability = _highestCapability;
4229 gSleepPolicyVars->sleepFactors = currentFactors;
4230 gSleepPolicyVars->sleepReason = lastSleepReason;
4231 gSleepPolicyVars->sleepPhase = sleepPhase;
4232 gSleepPolicyVars->standbyDelay = standbyDelay;
4233 gSleepPolicyVars->standbyTimer = standbyTimer;
4234 gSleepPolicyVars->poweroffDelay = powerOffDelay;
4235 gSleepPolicyVars->scheduledAlarms = _scheduledAlarms | _userScheduledAlarm;
4236 gSleepPolicyVars->poweroffTimer = powerOffTimer;
4237
4238 if (kIOPMSleepPhase0 == sleepPhase)
4239 {
4240 // preserve hibernateMode
4241 savedHibernateMode = gSleepPolicyVars->hibernateMode;
4242 gSleepPolicyVars->hibernateMode = *hibMode;
4243 }
4244 else if (kIOPMSleepPhase1 == sleepPhase)
4245 {
4246 // use original hibernateMode for phase2
4247 gSleepPolicyVars->hibernateMode = *hibMode;
4248 }
4249
4250 result = gSleepPolicyHandler(gSleepPolicyTarget, gSleepPolicyVars, params);
4251
4252 if (kIOPMSleepPhase0 == sleepPhase)
4253 {
4254 // restore hibernateMode
4255 gSleepPolicyVars->hibernateMode = savedHibernateMode;
4256 }
4257
4258 if ((result != kIOReturnSuccess) ||
4259 (kIOPMSleepTypeInvalid == params->sleepType) ||
4260 (params->sleepType >= kIOPMSleepTypeLast) ||
4261 (kIOPMSystemSleepParametersVersion != params->version))
4262 {
4263 MSG("sleep policy handler error\n");
4264 goto done;
4265 }
4266
4267 if ((getSleepTypeAttributes(params->sleepType) &
4268 kIOPMSleepAttributeHibernateSetup) &&
4269 ((*hibMode & kIOHibernateModeOn) == 0))
4270 {
4271 *hibMode |= (kIOHibernateModeOn | kIOHibernateModeSleep);
4272 }
4273
4274 DLOG("sleep params v%u, type %u, flags 0x%x, wake 0x%x, timer %u, poweroff %u\n",
4275 params->version, params->sleepType, params->sleepFlags,
4276 params->ecWakeEvents, params->ecWakeTimer, params->ecPoweroffTimer);
4277 found = true;
4278 goto done;
4279 }
4280
4281 // Policy table is meaningless without standby enabled
4282 if (!standbyEnabled)
4283 goto done;
4284
4285 // Validate the sleep policy table
4286 policyData = OSDynamicCast(OSData, prop);
4287 if (!policyData || (policyData->getLength() <= sizeof(IOPMSystemSleepPolicyTable)))
4288 goto done;
4289
4290 pt = (const IOPMSystemSleepPolicyTable *) policyData->getBytesNoCopy();
4291 if ((pt->signature != kIOPMSystemSleepPolicySignature) ||
4292 (pt->version != 1) || (0 == pt->entryCount))
4293 goto done;
4294
4295 if (((policyData->getLength() - sizeof(IOPMSystemSleepPolicyTable)) !=
4296 (sizeof(IOPMSystemSleepPolicyEntry) * pt->entryCount)))
4297 goto done;
4298
4299 for (uint32_t i = 0; i < pt->entryCount; i++)
4300 {
4301 const IOPMSystemSleepPolicyEntry * entry = &pt->entries[i];
4302 mismatch = (((uint32_t)currentFactors ^ entry->factorBits) & entry->factorMask);
4303
4304 DLOG("mask 0x%08x, bits 0x%08x, flags 0x%08x, wake 0x%08x, mismatch 0x%08x\n",
4305 entry->factorMask, entry->factorBits,
4306 entry->sleepFlags, entry->wakeEvents, mismatch);
4307 if (mismatch)
4308 continue;
4309
4310 DLOG("^ found match\n");
4311 found = true;
4312
4313 params->version = kIOPMSystemSleepParametersVersion;
4314 params->reserved1 = 1;
4315 if (entry->sleepFlags & kIOPMSleepFlagHibernate)
4316 params->sleepType = kIOPMSleepTypeStandby;
4317 else
4318 params->sleepType = kIOPMSleepTypeNormalSleep;
4319
4320 params->ecWakeEvents = entry->wakeEvents;
4321 if (entry->sleepFlags & kIOPMSleepFlagSleepTimerEnable)
4322 {
4323 if (kIOPMSleepPhase2 == sleepPhase)
4324 {
4325 clock_sec_t now_secs = gIOLastSleepTime.tv_sec;
4326
4327 if (!_standbyTimerResetSeconds ||
4328 (now_secs <= _standbyTimerResetSeconds))
4329 {
4330 // Reset standby timer adjustment
4331 _standbyTimerResetSeconds = now_secs;
4332 DLOG("standby delay %u, reset %u\n",
4333 standbyDelay, (uint32_t) _standbyTimerResetSeconds);
4334 }
4335 else if (standbyDelay)
4336 {
4337 // Shorten the standby delay timer
4338 clock_sec_t elapsed = now_secs - _standbyTimerResetSeconds;
4339 if (standbyDelay > elapsed)
4340 standbyDelay -= elapsed;
4341 else
4342 standbyDelay = 1; // must be > 0
4343
4344 DLOG("standby delay %u, elapsed %u\n",
4345 standbyDelay, (uint32_t) elapsed);
4346 }
4347 }
4348 params->ecWakeTimer = standbyDelay;
4349 }
4350 else if (kIOPMSleepPhase2 == sleepPhase)
4351 {
4352 // A sleep that does not enable the sleep timer will reset
4353 // the standby delay adjustment.
4354 _standbyTimerResetSeconds = 0;
4355 }
4356 break;
4357 }
4358
4359 done:
4360 if (prop)
4361 prop->release();
4362
4363 return found;
4364 }
4365
4366 static IOPMSystemSleepParameters gEarlySystemSleepParams;
4367
4368 void IOPMrootDomain::evaluateSystemSleepPolicyEarly( void )
4369 {
4370 // Evaluate early (priority interest phase), before drivers sleep.
4371
4372 DLOG("%s\n", __FUNCTION__);
4373 removeProperty(kIOPMSystemSleepParametersKey);
4374
4375 // Full wake resets the standby timer delay adjustment
4376 if (_highestCapability & kIOPMSystemCapabilityGraphics)
4377 _standbyTimerResetSeconds = 0;
4378
4379 hibernateDisabled = false;
4380 hibernateMode = 0;
4381 getSleepOption(kIOHibernateModeKey, &hibernateMode);
4382
4383 // Save for late evaluation if sleep is aborted
4384 bzero(&gEarlySystemSleepParams, sizeof(gEarlySystemSleepParams));
4385
4386 if (evaluateSystemSleepPolicy(&gEarlySystemSleepParams, kIOPMSleepPhase1,
4387 &hibernateMode))
4388 {
4389 if (!hibernateRetry &&
4390 ((getSleepTypeAttributes(gEarlySystemSleepParams.sleepType) &
4391 kIOPMSleepAttributeHibernateSetup) == 0))
4392 {
4393 // skip hibernate setup
4394 hibernateDisabled = true;
4395 }
4396 }
4397
4398 // Publish IOPMSystemSleepType
4399 uint32_t sleepType = gEarlySystemSleepParams.sleepType;
4400 if (sleepType == kIOPMSleepTypeInvalid)
4401 {
4402 // no sleep policy
4403 sleepType = kIOPMSleepTypeNormalSleep;
4404 if (hibernateMode & kIOHibernateModeOn)
4405 sleepType = (hibernateMode & kIOHibernateModeSleep) ?
4406 kIOPMSleepTypeSafeSleep : kIOPMSleepTypeHibernate;
4407 }
4408 else if ((sleepType == kIOPMSleepTypeStandby) &&
4409 (gEarlySystemSleepParams.ecPoweroffTimer))
4410 {
4411 // report the lowest possible sleep state
4412 sleepType = kIOPMSleepTypePowerOff;
4413 }
4414
4415 setProperty(kIOPMSystemSleepTypeKey, sleepType, 32);
4416 }
4417
4418 void IOPMrootDomain::evaluateSystemSleepPolicyFinal( void )
4419 {
4420 IOPMSystemSleepParameters params;
4421 OSData * paramsData;
4422 bool wakeNow;
4423 // Evaluate sleep policy after sleeping drivers but before platform sleep.
4424
4425 DLOG("%s\n", __FUNCTION__);
4426
4427 bzero(&params, sizeof(params));
4428 wakeNow = false;
4429 if (evaluateSystemSleepPolicy(&params, kIOPMSleepPhase2, &hibernateMode))
4430 {
4431 if ((kIOPMSleepTypeStandby == params.sleepType)
4432 && gIOHibernateStandbyDisabled && gSleepPolicyVars
4433 && (!((kIOPMSleepFactorStandbyForced|kIOPMSleepFactorAutoPowerOffForced|kIOPMSleepFactorHibernateForced)
4434 & gSleepPolicyVars->sleepFactors)))
4435 {
4436 standbyNixed = true;
4437 wakeNow = true;
4438 }
4439 if (wakeNow
4440 || ((hibernateDisabled || hibernateAborted) &&
4441 (getSleepTypeAttributes(params.sleepType) &
4442 kIOPMSleepAttributeHibernateSetup)))
4443 {
4444 // Final evaluation picked a state requiring hibernation,
4445 // but hibernate isn't going to proceed. Arm a short sleep using
4446 // the early non-hibernate sleep parameters.
4447 bcopy(&gEarlySystemSleepParams, &params, sizeof(params));
4448 params.sleepType = kIOPMSleepTypeAbortedSleep;
4449 params.ecWakeTimer = 1;
4450 if (standbyNixed)
4451 {
4452 resetTimers = true;
4453 }
4454 else
4455 {
4456 // Set hibernateRetry flag to force hibernate setup on the
4457 // next sleep.
4458 hibernateRetry = true;
4459 }
4460 DLOG("wake in %u secs for hibernateDisabled %d, hibernateAborted %d, standbyNixed %d\n",
4461 params.ecWakeTimer, hibernateDisabled, hibernateAborted, standbyNixed);
4462 }
4463 else
4464 {
4465 hibernateRetry = false;
4466 }
4467
4468 if (kIOPMSleepTypeAbortedSleep != params.sleepType)
4469 {
4470 resetTimers = false;
4471 }
4472
4473 paramsData = OSData::withBytes(&params, sizeof(params));
4474 if (paramsData)
4475 {
4476 setProperty(kIOPMSystemSleepParametersKey, paramsData);
4477 paramsData->release();
4478 }
4479
4480 if (getSleepTypeAttributes(params.sleepType) &
4481 kIOPMSleepAttributeHibernateSleep)
4482 {
4483 // Disable sleep to force hibernation
4484 gIOHibernateMode &= ~kIOHibernateModeSleep;
4485 }
4486 }
4487 }
4488
4489 bool IOPMrootDomain::getHibernateSettings(
4490 uint32_t * hibernateModePtr,
4491 uint32_t * hibernateFreeRatio,
4492 uint32_t * hibernateFreeTime )
4493 {
4494 // Called by IOHibernateSystemSleep() after evaluateSystemSleepPolicyEarly()
4495 // has updated the hibernateDisabled flag.
4496
4497 bool ok = getSleepOption(kIOHibernateModeKey, hibernateModePtr);
4498 getSleepOption(kIOHibernateFreeRatioKey, hibernateFreeRatio);
4499 getSleepOption(kIOHibernateFreeTimeKey, hibernateFreeTime);
4500 if (hibernateDisabled)
4501 *hibernateModePtr = 0;
4502 else if (gSleepPolicyHandler)
4503 *hibernateModePtr = hibernateMode;
4504 DLOG("hibernateMode 0x%x\n", *hibernateModePtr);
4505 return ok;
4506 }
4507
4508 bool IOPMrootDomain::getSleepOption( const char * key, uint32_t * option )
4509 {
4510 OSObject * optionsProp;
4511 OSDictionary * optionsDict;
4512 OSObject * obj = 0;
4513 OSNumber * num;
4514 bool ok = false;
4515
4516 optionsProp = copyProperty(kRootDomainSleepOptionsKey);
4517 optionsDict = OSDynamicCast(OSDictionary, optionsProp);
4518
4519 if (optionsDict)
4520 {
4521 obj = optionsDict->getObject(key);
4522 if (obj) obj->retain();
4523 }
4524 if (!obj)
4525 {
4526 obj = copyProperty(key);
4527 }
4528 if (obj)
4529 {
4530 if ((num = OSDynamicCast(OSNumber, obj)))
4531 {
4532 *option = num->unsigned32BitValue();
4533 ok = true;
4534 }
4535 else if (OSDynamicCast(OSBoolean, obj))
4536 {
4537 *option = (obj == kOSBooleanTrue) ? 1 : 0;
4538 ok = true;
4539 }
4540 }
4541
4542 if (obj)
4543 obj->release();
4544 if (optionsProp)
4545 optionsProp->release();
4546
4547 return ok;
4548 }
4549 #endif /* HIBERNATION */
4550
4551 IOReturn IOPMrootDomain::getSystemSleepType( uint32_t * sleepType, uint32_t * standbyTimer )
4552 {
4553 #if HIBERNATION
4554 IOPMSystemSleepParameters params;
4555 uint32_t hibMode = 0;
4556 bool ok;
4557
4558 if (gIOPMWorkLoop->inGate() == false)
4559 {
4560 IOReturn ret = gIOPMWorkLoop->runAction(
4561 OSMemberFunctionCast(IOWorkLoop::Action, this,
4562 &IOPMrootDomain::getSystemSleepType),
4563 (OSObject *) this,
4564 (void *) sleepType, (void *) standbyTimer);
4565 return ret;
4566 }
4567
4568 getSleepOption(kIOHibernateModeKey, &hibMode);
4569 bzero(&params, sizeof(params));
4570
4571 ok = evaluateSystemSleepPolicy(&params, kIOPMSleepPhase0, &hibMode);
4572 if (ok)
4573 {
4574 *sleepType = params.sleepType;
4575 if (!getSleepOption(kIOPMDeepSleepTimerKey, standbyTimer) &&
4576 !getSleepOption(kIOPMDeepSleepDelayKey, standbyTimer)) {
4577 DLOG("Standby delay is not set\n");
4578 *standbyTimer = 0;
4579 }
4580 return kIOReturnSuccess;
4581 }
4582 #endif
4583
4584 return kIOReturnUnsupported;
4585 }
4586
4587 // MARK: -
4588 // MARK: Shutdown and Restart
4589
4590 //******************************************************************************
4591 // handlePlatformHaltRestart
4592 //
4593 //******************************************************************************
4594
4595 // Phases while performing shutdown/restart
4596 typedef enum {
4597 kNotifyDone = 0x00,
4598 kNotifyPriorityClients = 0x10,
4599 kNotifyPowerPlaneDrivers = 0x20,
4600 kNotifyHaltRestartAction = 0x30,
4601 kQuiescePM = 0x40,
4602 } shutdownPhase_t;
4603
4604
4605 struct HaltRestartApplierContext {
4606 IOPMrootDomain * RootDomain;
4607 unsigned long PowerState;
4608 IOPMPowerFlags PowerFlags;
4609 UInt32 MessageType;
4610 UInt32 Counter;
4611 const char * LogString;
4612 shutdownPhase_t phase;
4613
4614 IOServiceInterestHandler handler;
4615 } gHaltRestartCtx;
4616
4617 const char *shutdownPhase2String(shutdownPhase_t phase)
4618 {
4619 switch(phase) {
4620 case kNotifyDone:
4621 return "Notifications completed";
4622 case kNotifyPriorityClients:
4623 return "Notifying priority clients";
4624 case kNotifyPowerPlaneDrivers:
4625 return "Notifying power plane drivers";
4626 case kNotifyHaltRestartAction:
4627 return "Notifying HaltRestart action handlers";
4628 case kQuiescePM:
4629 return "Quiescing PM";
4630 default:
4631 return "Unknown";
4632 }
4633
4634 }
4635
4636 static void
4637 platformHaltRestartApplier( OSObject * object, void * context )
4638 {
4639 IOPowerStateChangeNotification notify;
4640 HaltRestartApplierContext * ctx;
4641 AbsoluteTime startTime, elapsedTime;
4642 uint32_t deltaTime;
4643
4644 ctx = (HaltRestartApplierContext *) context;
4645
4646 _IOServiceInterestNotifier * notifier;
4647 notifier = OSDynamicCast(_IOServiceInterestNotifier, object);
4648 memset(&notify, 0, sizeof(notify));
4649 notify.powerRef = (void *)(uintptr_t)ctx->Counter;
4650 notify.returnValue = 0;
4651 notify.stateNumber = ctx->PowerState;
4652 notify.stateFlags = ctx->PowerFlags;
4653
4654 if (notifier) {
4655 ctx->handler = notifier->handler;
4656 }
4657
4658 clock_get_uptime(&startTime);
4659 ctx->RootDomain->messageClient( ctx->MessageType, object, (void *)&notify );
4660 deltaTime = computeDeltaTimeMS(&startTime, &elapsedTime);
4661
4662 if ((deltaTime > kPMHaltTimeoutMS) && notifier) {
4663
4664 LOG("%s handler %p took %u ms\n",
4665 ctx->LogString, OBFUSCATE(notifier->handler), deltaTime);
4666 halt_log_enter("PowerOff/Restart message to priority client", (const void *) notifier->handler, elapsedTime);
4667 }
4668
4669 ctx->handler = 0;
4670 ctx->Counter++;
4671 }
4672
4673 static void quiescePowerTreeCallback( void * target, void * param )
4674 {
4675 IOLockLock(gPMHaltLock);
4676 gPMQuiesced = true;
4677 thread_wakeup(param);
4678 IOLockUnlock(gPMHaltLock);
4679 }
4680
4681 void IOPMrootDomain::handlePlatformHaltRestart( UInt32 pe_type )
4682 {
4683 AbsoluteTime startTime, elapsedTime;
4684 uint32_t deltaTime;
4685
4686 memset(&gHaltRestartCtx, 0, sizeof(gHaltRestartCtx));
4687 gHaltRestartCtx.RootDomain = this;
4688
4689 clock_get_uptime(&startTime);
4690 switch (pe_type)
4691 {
4692 case kPEHaltCPU:
4693 case kPEUPSDelayHaltCPU:
4694 gHaltRestartCtx.PowerState = OFF_STATE;
4695 gHaltRestartCtx.MessageType = kIOMessageSystemWillPowerOff;
4696 gHaltRestartCtx.LogString = "PowerOff";
4697 break;
4698
4699 case kPERestartCPU:
4700 gHaltRestartCtx.PowerState = RESTART_STATE;
4701 gHaltRestartCtx.MessageType = kIOMessageSystemWillRestart;
4702 gHaltRestartCtx.LogString = "Restart";
4703 break;
4704
4705 case kPEPagingOff:
4706 gHaltRestartCtx.PowerState = ON_STATE;
4707 gHaltRestartCtx.MessageType = kIOMessageSystemPagingOff;
4708 gHaltRestartCtx.LogString = "PagingOff";
4709 IOService::updateConsoleUsers(NULL, kIOMessageSystemPagingOff);
4710 #if HIBERNATION
4711 IOHibernateSystemRestart();
4712 #endif
4713 break;
4714
4715 default:
4716 return;
4717 }
4718
4719 gHaltRestartCtx.phase = kNotifyPriorityClients;
4720 // Notify legacy clients
4721 applyToInterested(gIOPriorityPowerStateInterest, platformHaltRestartApplier, &gHaltRestartCtx);
4722
4723 // For normal shutdown, turn off File Server Mode.
4724 if (kPEHaltCPU == pe_type)
4725 {
4726 const OSSymbol * setting = OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey);
4727 OSNumber * num = OSNumber::withNumber((unsigned long long) 0, 32);
4728 if (setting && num)
4729 {
4730 setPMSetting(setting, num);
4731 setting->release();
4732 num->release();
4733 }
4734 }
4735
4736
4737 if (kPEPagingOff != pe_type)
4738 {
4739 gHaltRestartCtx.phase = kNotifyPowerPlaneDrivers;
4740 // Notify in power tree order
4741 notifySystemShutdown(this, gHaltRestartCtx.MessageType);
4742 }
4743
4744 gHaltRestartCtx.phase = kNotifyHaltRestartAction;
4745 IOCPURunPlatformHaltRestartActions(pe_type);
4746
4747 // Wait for PM to quiesce
4748 if ((kPEPagingOff != pe_type) && gPMHaltLock)
4749 {
4750 gHaltRestartCtx.phase = kQuiescePM;
4751 AbsoluteTime quiesceTime = mach_absolute_time();
4752
4753 IOLockLock(gPMHaltLock);
4754 gPMQuiesced = false;
4755 if (quiescePowerTree(this, &quiescePowerTreeCallback, &gPMQuiesced) ==
4756 kIOReturnSuccess)
4757 {
4758 while (!gPMQuiesced)
4759 {
4760 IOLockSleep(gPMHaltLock, &gPMQuiesced, THREAD_UNINT);
4761 }
4762 }
4763 IOLockUnlock(gPMHaltLock);
4764 deltaTime = computeDeltaTimeMS(&quiesceTime, &elapsedTime);
4765 DLOG("PM quiesce took %u ms\n", deltaTime);
4766 halt_log_enter("Quiesce", NULL, elapsedTime);
4767 }
4768 gHaltRestartCtx.phase = kNotifyDone;
4769
4770 deltaTime = computeDeltaTimeMS(&startTime, &elapsedTime);
4771 LOG("%s all drivers took %u ms\n", gHaltRestartCtx.LogString, deltaTime);
4772
4773 halt_log_enter(gHaltRestartCtx.LogString, NULL, elapsedTime);
4774
4775 deltaTime = computeDeltaTimeMS(&gHaltStartTime, &elapsedTime);
4776 LOG("%s total %u ms\n", gHaltRestartCtx.LogString, deltaTime);
4777
4778 if (gHaltLog && gHaltTimeMaxLog && (deltaTime >= gHaltTimeMaxLog))
4779 {
4780 printf("%s total %d ms:%s\n", gHaltRestartCtx.LogString, deltaTime, gHaltLog);
4781 }
4782
4783 checkShutdownTimeout();
4784 }
4785
4786 bool IOPMrootDomain::checkShutdownTimeout()
4787 {
4788 AbsoluteTime elapsedTime;
4789 uint32_t deltaTime = computeDeltaTimeMS(&gHaltStartTime, &elapsedTime);
4790
4791 if (gHaltTimeMaxPanic && (deltaTime >= gHaltTimeMaxPanic)) {
4792 return true;
4793 }
4794 return false;
4795 }
4796
4797 void IOPMrootDomain::panicWithShutdownLog(uint32_t timeoutInMs)
4798 {
4799 if (gHaltLog) {
4800 if ((gHaltRestartCtx.phase == kNotifyPriorityClients) && gHaltRestartCtx.handler) {
4801 halt_log_enter("Blocked on priority client", (void *)gHaltRestartCtx.handler, mach_absolute_time() - gHaltStartTime);
4802 }
4803 panic("%s timed out in phase '%s'. Total %d ms:%s",
4804 gHaltRestartCtx.LogString, shutdownPhase2String(gHaltRestartCtx.phase), timeoutInMs, gHaltLog);
4805 }
4806 else {
4807 panic("%s timed out in phase \'%s\'. Total %d ms",
4808 gHaltRestartCtx.LogString, shutdownPhase2String(gHaltRestartCtx.phase), timeoutInMs);
4809 }
4810 }
4811
4812 //******************************************************************************
4813 // shutdownSystem
4814 //
4815 //******************************************************************************
4816
4817 IOReturn IOPMrootDomain::shutdownSystem( void )
4818 {
4819 return kIOReturnUnsupported;
4820 }
4821
4822 //******************************************************************************
4823 // restartSystem
4824 //
4825 //******************************************************************************
4826
4827 IOReturn IOPMrootDomain::restartSystem( void )
4828 {
4829 return kIOReturnUnsupported;
4830 }
4831
4832 // MARK: -
4833 // MARK: System Capability
4834
4835 //******************************************************************************
4836 // tagPowerPlaneService
4837 //
4838 // Running on PM work loop thread.
4839 //******************************************************************************
4840
4841 void IOPMrootDomain::tagPowerPlaneService(
4842 IOService * service,
4843 IOPMActions * actions )
4844 {
4845 uint32_t flags = 0;
4846 bool isDisplayWrangler;
4847
4848 memset(actions, 0, sizeof(*actions));
4849 actions->target = this;
4850
4851 if (service == this)
4852 {
4853 actions->actionPowerChangeStart =
4854 OSMemberFunctionCast(
4855 IOPMActionPowerChangeStart, this,
4856 &IOPMrootDomain::handleOurPowerChangeStart);
4857
4858 actions->actionPowerChangeDone =
4859 OSMemberFunctionCast(
4860 IOPMActionPowerChangeDone, this,
4861 &IOPMrootDomain::handleOurPowerChangeDone);
4862
4863 actions->actionPowerChangeOverride =
4864 OSMemberFunctionCast(
4865 IOPMActionPowerChangeOverride, this,
4866 &IOPMrootDomain::overrideOurPowerChange);
4867 return;
4868 }
4869
4870 #if !NO_KERNEL_HID
4871 isDisplayWrangler = (0 != service->metaCast("IODisplayWrangler"));
4872 if (isDisplayWrangler)
4873 {
4874 wrangler = service;
4875 // found the display wrangler, check for any display assertions already created
4876 if (pmAssertions->getActivatedAssertions() & kIOPMDriverAssertionPreventDisplaySleepBit) {
4877 DLOG("wrangler setIgnoreIdleTimer\(1) due to pre-existing assertion\n");
4878 wrangler->setIgnoreIdleTimer( true );
4879 }
4880 }
4881 #else
4882 isDisplayWrangler = false;
4883 #endif
4884
4885 #if defined(__i386__) || defined(__x86_64__)
4886 if (isDisplayWrangler)
4887 flags |= kPMActionsFlagIsDisplayWrangler;
4888 if (service->getProperty("IOPMStrictTreeOrder"))
4889 flags |= kPMActionsFlagIsGraphicsDevice;
4890 if (service->getProperty("IOPMUnattendedWakePowerState"))
4891 flags |= kPMActionsFlagIsAudioDevice;
4892 #endif
4893
4894 // Find the power connection object that is a child of the PCI host
4895 // bridge, and has a graphics/audio device attached below. Mark the
4896 // power branch for delayed child notifications.
4897
4898 if (flags)
4899 {
4900 IORegistryEntry * child = service;
4901 IORegistryEntry * parent = child->getParentEntry(gIOPowerPlane);
4902
4903 while (child != this)
4904 {
4905 if (parent->metaCast("IOPCIDevice") ||
4906 (parent == this))
4907 {
4908 if (OSDynamicCast(IOPowerConnection, child))
4909 {
4910 IOPowerConnection * conn = (IOPowerConnection *) child;
4911 conn->delayChildNotification = true;
4912 DLOG("delayChildNotification for 0x%llx\n", conn->getRegistryEntryID());
4913 }
4914 break;
4915 }
4916 child = parent;
4917 parent = child->getParentEntry(gIOPowerPlane);
4918 }
4919 }
4920
4921 if (flags)
4922 {
4923 DLOG("%s tag flags %x\n", service->getName(), flags);
4924 actions->parameter |= flags;
4925 actions->actionPowerChangeOverride =
4926 OSMemberFunctionCast(
4927 IOPMActionPowerChangeOverride, this,
4928 &IOPMrootDomain::overridePowerChangeForUIService);
4929
4930 if (flags & kPMActionsFlagIsDisplayWrangler)
4931 {
4932 actions->actionActivityTickle =
4933 OSMemberFunctionCast(
4934 IOPMActionActivityTickle, this,
4935 &IOPMrootDomain::handleActivityTickleForDisplayWrangler);
4936
4937 actions->actionUpdatePowerClient =
4938 OSMemberFunctionCast(
4939 IOPMActionUpdatePowerClient, this,
4940 &IOPMrootDomain::handleUpdatePowerClientForDisplayWrangler);
4941 }
4942 return;
4943 }
4944
4945 // Locate the first PCI host bridge for PMTrace.
4946 if (!pciHostBridgeDevice && service->metaCast("IOPCIBridge"))
4947 {
4948 IOService * provider = service->getProvider();
4949 if (OSDynamicCast(IOPlatformDevice, provider) &&
4950 provider->inPlane(gIODTPlane))
4951 {
4952 pciHostBridgeDevice = provider;
4953 pciHostBridgeDriver = service;
4954 DLOG("PMTrace found PCI host bridge %s->%s\n",
4955 provider->getName(), service->getName());
4956 }
4957 }
4958
4959 // Tag top-level PCI devices. The order of PMinit() call does not
4960 // change across boots and is used as the PCI bit number.
4961 if (pciHostBridgeDevice && service->metaCast("IOPCIDevice"))
4962 {
4963 // Would prefer to check built-in property, but tagPowerPlaneService()
4964 // is called before pciDevice->registerService().
4965 IORegistryEntry * parent = service->getParentEntry(gIODTPlane);
4966 if ((parent == pciHostBridgeDevice) && service->getProperty("acpi-device"))
4967 {
4968 int bit = pmTracer->recordTopLevelPCIDevice( service );
4969 if (bit >= 0)
4970 {
4971 // Save the assigned bit for fast lookup.
4972 actions->parameter |= (bit & kPMActionsPCIBitNumberMask);
4973
4974 actions->actionPowerChangeStart =
4975 OSMemberFunctionCast(
4976 IOPMActionPowerChangeStart, this,
4977 &IOPMrootDomain::handlePowerChangeStartForPCIDevice);
4978
4979 actions->actionPowerChangeDone =
4980 OSMemberFunctionCast(
4981 IOPMActionPowerChangeDone, this,
4982 &IOPMrootDomain::handlePowerChangeDoneForPCIDevice);
4983 }
4984 }
4985 }
4986 }
4987
4988 //******************************************************************************
4989 // PM actions for root domain
4990 //******************************************************************************
4991
4992 void IOPMrootDomain::overrideOurPowerChange(
4993 IOService * service,
4994 IOPMActions * actions,
4995 IOPMPowerStateIndex * inOutPowerState,
4996 IOPMPowerChangeFlags * inOutChangeFlags,
4997 IOPMRequestTag requestTag )
4998 {
4999 uint32_t powerState = (uint32_t) *inOutPowerState;
5000 uint32_t changeFlags = *inOutChangeFlags;
5001 uint32_t currentPowerState = (uint32_t) getPowerState();
5002
5003 if (changeFlags & kIOPMParentInitiated)
5004 {
5005 // Root parent is permanently pegged at max power,
5006 // a parent initiated power change is unexpected.
5007 *inOutChangeFlags |= kIOPMNotDone;
5008 return;
5009 }
5010
5011 if (powerState < currentPowerState)
5012 {
5013 if (CAP_CURRENT(kIOPMSystemCapabilityGraphics))
5014 {
5015 // Root domain is dropping power state ON->SLEEP.
5016 // If system is in full wake, first enter dark wake by
5017 // converting the power drop to a capability change.
5018 // Once in dark wake, transition to sleep state ASAP.
5019
5020 darkWakeToSleepASAP = true;
5021
5022 // Drop graphics and audio capability
5023 _desiredCapability &= ~(
5024 kIOPMSystemCapabilityGraphics |
5025 kIOPMSystemCapabilityAudio );
5026
5027 // Convert to capability change (ON->ON)
5028 *inOutPowerState = ON_STATE;
5029 *inOutChangeFlags |= kIOPMSynchronize;
5030
5031 // Revert device desire from SLEEP to ON
5032 changePowerStateToPriv(ON_STATE);
5033 }
5034 else
5035 {
5036 // System is in dark wake, ok to drop power state.
5037 // Broadcast root powering down to entire tree.
5038 *inOutChangeFlags |= kIOPMRootChangeDown;
5039 }
5040 }
5041 else if (powerState > currentPowerState)
5042 {
5043 if ((_currentCapability & kIOPMSystemCapabilityCPU) == 0)
5044 {
5045 // Broadcast power up when waking from sleep, but not for the
5046 // initial power change at boot by checking for cpu capability.
5047 *inOutChangeFlags |= kIOPMRootChangeUp;
5048 }
5049 }
5050 }
5051
5052 void IOPMrootDomain::handleOurPowerChangeStart(
5053 IOService * service,
5054 IOPMActions * actions,
5055 IOPMPowerStateIndex powerState,
5056 IOPMPowerChangeFlags * inOutChangeFlags,
5057 IOPMRequestTag requestTag )
5058 {
5059 uint32_t changeFlags = *inOutChangeFlags;
5060 uint32_t currentPowerState = (uint32_t) getPowerState();
5061 uint32_t sleepReason = requestTag ? requestTag : kIOPMSleepReasonIdle;
5062 bool publishSleepReason = false;
5063
5064 _systemTransitionType = kSystemTransitionNone;
5065 _systemMessageClientMask = 0;
5066 capabilityLoss = false;
5067 toldPowerdCapWillChange = false;
5068
5069 if (lowBatteryCondition)
5070 {
5071 // Low battery notification may arrive after the initial sleep request
5072 // has been queued. Override the sleep reason so powerd and others can
5073 // treat this as an emergency sleep.
5074 sleepReason = kIOPMSleepReasonLowPower;
5075 }
5076
5077 // 1. Explicit capability change.
5078
5079 if (changeFlags & kIOPMSynchronize)
5080 {
5081 if (powerState == ON_STATE)
5082 {
5083 if (changeFlags & kIOPMSyncNoChildNotify)
5084 _systemTransitionType = kSystemTransitionNewCapClient;
5085 else
5086 _systemTransitionType = kSystemTransitionCapability;
5087 }
5088 }
5089
5090 // 2. Going to sleep (cancellation still possible).
5091
5092 else if (powerState < currentPowerState)
5093 _systemTransitionType = kSystemTransitionSleep;
5094
5095 // 3. Woke from (idle or demand) sleep.
5096
5097 else if (!systemBooting &&
5098 (changeFlags & kIOPMSelfInitiated) &&
5099 (powerState > currentPowerState))
5100 {
5101 _systemTransitionType = kSystemTransitionWake;
5102 _desiredCapability = kIOPMSystemCapabilityCPU |
5103 kIOPMSystemCapabilityNetwork;
5104
5105 // Early exit from dark wake to full (e.g. LID open)
5106 if (kFullWakeReasonNone != fullWakeReason)
5107 {
5108 _desiredCapability |= (
5109 kIOPMSystemCapabilityGraphics |
5110 kIOPMSystemCapabilityAudio );
5111 }
5112 #if HIBERNATION
5113 IOHibernateSetWakeCapabilities(_desiredCapability);
5114 #endif
5115 }
5116
5117 // Update pending wake capability at the beginning of every
5118 // state transition (including synchronize). This will become
5119 // the current capability at the end of the transition.
5120
5121 if (kSystemTransitionSleep == _systemTransitionType)
5122 {
5123 _pendingCapability = 0;
5124 capabilityLoss = true;
5125
5126 }
5127 else if (kSystemTransitionNewCapClient != _systemTransitionType)
5128 {
5129 _pendingCapability = _desiredCapability |
5130 kIOPMSystemCapabilityCPU |
5131 kIOPMSystemCapabilityNetwork;
5132
5133 if (_pendingCapability & kIOPMSystemCapabilityGraphics)
5134 _pendingCapability |= kIOPMSystemCapabilityAudio;
5135
5136 if ((kSystemTransitionCapability == _systemTransitionType) &&
5137 (_pendingCapability == _currentCapability))
5138 {
5139 // Cancel the PM state change.
5140 _systemTransitionType = kSystemTransitionNone;
5141 *inOutChangeFlags |= kIOPMNotDone;
5142 }
5143 if (__builtin_popcount(_pendingCapability) <
5144 __builtin_popcount(_currentCapability))
5145 capabilityLoss = true;
5146 }
5147
5148 // 1. Capability change.
5149
5150 if (kSystemTransitionCapability == _systemTransitionType)
5151 {
5152 // Dark to Full transition.
5153 if (CAP_GAIN(kIOPMSystemCapabilityGraphics))
5154 {
5155 tracePoint( kIOPMTracePointDarkWakeExit );
5156
5157 willEnterFullWake();
5158 }
5159
5160 // Full to Dark transition.
5161 if (CAP_LOSS(kIOPMSystemCapabilityGraphics))
5162 {
5163 // Clear previous stats
5164 IOLockLock(pmStatsLock);
5165 if (pmStatsAppResponses)
5166 {
5167 pmStatsAppResponses->release();
5168 pmStatsAppResponses = OSArray::withCapacity(5);
5169 }
5170 IOLockUnlock(pmStatsLock);
5171
5172
5173 tracePoint( kIOPMTracePointDarkWakeEntry );
5174 *inOutChangeFlags |= kIOPMSyncTellPowerDown;
5175 _systemMessageClientMask = kSystemMessageClientPowerd |
5176 kSystemMessageClientLegacyApp;
5177
5178
5179 // rdar://15971327
5180 // Prevent user active transitions before notifying clients
5181 // that system will sleep.
5182 preventTransitionToUserActive(true);
5183
5184 IOService::setAdvisoryTickleEnable( false );
5185
5186 // Publish the sleep reason for full to dark wake
5187 publishSleepReason = true;
5188 lastSleepReason = fullToDarkReason = sleepReason;
5189
5190 // Publish a UUID for the Sleep --> Wake cycle
5191 handlePublishSleepWakeUUID(true);
5192 if (sleepDelaysReport) {
5193 clock_get_uptime(&ts_sleepStart);
5194 DLOG("sleepDelaysReport f->9 start at 0x%llx\n", ts_sleepStart);
5195 }
5196
5197 wranglerTickled = false;
5198 }
5199 }
5200
5201 // 2. System sleep.
5202
5203 else if (kSystemTransitionSleep == _systemTransitionType)
5204 {
5205 // Beginning of a system sleep transition.
5206 // Cancellation is still possible.
5207 tracePoint( kIOPMTracePointSleepStarted );
5208
5209 _systemMessageClientMask = kSystemMessageClientAll;
5210 if ((_currentCapability & kIOPMSystemCapabilityGraphics) == 0)
5211 _systemMessageClientMask &= ~kSystemMessageClientLegacyApp;
5212 if ((_highestCapability & kIOPMSystemCapabilityGraphics) == 0)
5213 _systemMessageClientMask &= ~kSystemMessageClientKernel;
5214 #if HIBERNATION
5215 gIOHibernateState = 0;
5216 #endif
5217
5218 // Record the reason for dark wake back to sleep
5219 // System may not have ever achieved full wake
5220
5221 publishSleepReason = true;
5222 lastSleepReason = sleepReason;
5223 if (sleepDelaysReport) {
5224 clock_get_uptime(&ts_sleepStart);
5225 DLOG("sleepDelaysReport 9->0 start at 0x%llx\n", ts_sleepStart);
5226 }
5227 }
5228
5229 // 3. System wake.
5230
5231 else if (kSystemTransitionWake == _systemTransitionType)
5232 {
5233 tracePoint( kIOPMTracePointWakeWillPowerOnClients );
5234 // Clear stats about sleep
5235
5236 if (_pendingCapability & kIOPMSystemCapabilityGraphics)
5237 {
5238 willEnterFullWake();
5239 }
5240 else
5241 {
5242 // Message powerd only
5243 _systemMessageClientMask = kSystemMessageClientPowerd;
5244 tellClients(kIOMessageSystemWillPowerOn);
5245 }
5246 }
5247
5248 // The only location where the sleep reason is published. At this point
5249 // sleep can still be cancelled, but sleep reason should be published
5250 // early for logging purposes.
5251
5252 if (publishSleepReason)
5253 {
5254 static const char * IOPMSleepReasons[] =
5255 {
5256 kIOPMClamshellSleepKey,
5257 kIOPMPowerButtonSleepKey,
5258 kIOPMSoftwareSleepKey,
5259 kIOPMOSSwitchHibernationKey,
5260 kIOPMIdleSleepKey,
5261 kIOPMLowPowerSleepKey,
5262 kIOPMThermalEmergencySleepKey,
5263 kIOPMMaintenanceSleepKey,
5264 kIOPMSleepServiceExitKey,
5265 kIOPMDarkWakeThermalEmergencyKey
5266 };
5267
5268 // Record sleep cause in IORegistry
5269 uint32_t reasonIndex = sleepReason - kIOPMSleepReasonClamshell;
5270 if (reasonIndex < sizeof(IOPMSleepReasons)/sizeof(IOPMSleepReasons[0])) {
5271 DLOG("sleep reason %s\n", IOPMSleepReasons[reasonIndex]);
5272 setProperty(kRootDomainSleepReasonKey, IOPMSleepReasons[reasonIndex]);
5273 }
5274 }
5275
5276 if ((kSystemTransitionNone != _systemTransitionType) &&
5277 (kSystemTransitionNewCapClient != _systemTransitionType))
5278 {
5279 _systemStateGeneration++;
5280 systemDarkWake = false;
5281
5282 DLOG("=== START (%u->%u, 0x%x) type %u, gen %u, msg %x, "
5283 "dcp %x:%x:%x\n",
5284 currentPowerState, (uint32_t) powerState, *inOutChangeFlags,
5285 _systemTransitionType, _systemStateGeneration,
5286 _systemMessageClientMask,
5287 _desiredCapability, _currentCapability, _pendingCapability);
5288 }
5289 }
5290
5291 void IOPMrootDomain::handleOurPowerChangeDone(
5292 IOService * service,
5293 IOPMActions * actions,
5294 IOPMPowerStateIndex powerState,
5295 IOPMPowerChangeFlags changeFlags,
5296 IOPMRequestTag requestTag __unused )
5297 {
5298 if (kSystemTransitionNewCapClient == _systemTransitionType)
5299 {
5300 _systemTransitionType = kSystemTransitionNone;
5301 return;
5302 }
5303
5304 if (_systemTransitionType != kSystemTransitionNone)
5305 {
5306 uint32_t currentPowerState = (uint32_t) getPowerState();
5307
5308 if (changeFlags & kIOPMNotDone)
5309 {
5310 // Power down was cancelled or vetoed.
5311 _pendingCapability = _currentCapability;
5312 lastSleepReason = 0;
5313
5314 if (!CAP_CURRENT(kIOPMSystemCapabilityGraphics) &&
5315 CAP_CURRENT(kIOPMSystemCapabilityCPU))
5316 {
5317 #if !CONFIG_EMBEDDED
5318 pmPowerStateQueue->submitPowerEvent(
5319 kPowerEventPolicyStimulus,
5320 (void *) kStimulusDarkWakeReentry,
5321 _systemStateGeneration );
5322 #else
5323 // On embedded, there are no factors that can prolong a
5324 // "darkWake" when a power down is vetoed. We need to
5325 // promote to "fullWake" at least once so that factors
5326 // that prevent idle sleep can assert themselves if required
5327 pmPowerStateQueue->submitPowerEvent(
5328 kPowerEventPolicyStimulus,
5329 (void *) kStimulusDarkWakeActivityTickle);
5330 #endif
5331 }
5332
5333 // Revert device desire to max.
5334 changePowerStateToPriv(ON_STATE);
5335 }
5336 else
5337 {
5338 // Send message on dark wake to full wake promotion.
5339 // tellChangeUp() handles the normal SLEEP->ON case.
5340
5341 if (kSystemTransitionCapability == _systemTransitionType)
5342 {
5343 if (CAP_GAIN(kIOPMSystemCapabilityGraphics))
5344 {
5345 lastSleepReason = 0; // stop logging wrangler tickles
5346 tellClients(kIOMessageSystemHasPoweredOn);
5347 }
5348 if (CAP_LOSS(kIOPMSystemCapabilityGraphics))
5349 {
5350 // Going dark, reset full wake state
5351 // userIsActive will be cleared by wrangler powering down
5352 fullWakeReason = kFullWakeReasonNone;
5353
5354 if (ts_sleepStart) {
5355 clock_get_uptime(&wake2DarkwakeDelay);
5356 SUB_ABSOLUTETIME(&wake2DarkwakeDelay, &ts_sleepStart);
5357 DLOG("sleepDelaysReport f->9 end 0x%llx\n", wake2DarkwakeDelay);
5358 ts_sleepStart = 0;
5359 }
5360 }
5361 }
5362
5363 // Reset state after exiting from dark wake.
5364
5365 if (CAP_GAIN(kIOPMSystemCapabilityGraphics) ||
5366 CAP_LOSS(kIOPMSystemCapabilityCPU))
5367 {
5368 darkWakeMaintenance = false;
5369 darkWakeToSleepASAP = false;
5370 pciCantSleepValid = false;
5371 darkWakeSleepService = false;
5372
5373 if (CAP_LOSS(kIOPMSystemCapabilityCPU))
5374 {
5375 // Remove the influence of display power assertion
5376 // before next system wake.
5377 if (wrangler) wrangler->changePowerStateForRootDomain(
5378 kWranglerPowerStateMin );
5379 removeProperty(gIOPMUserTriggeredFullWakeKey);
5380 }
5381 }
5382
5383 // Entered dark mode.
5384
5385 if (((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
5386 (_pendingCapability & kIOPMSystemCapabilityCPU))
5387 {
5388 // Queue an evaluation of whether to remain in dark wake,
5389 // and for how long. This serves the purpose of draining
5390 // any assertions from the queue.
5391
5392 pmPowerStateQueue->submitPowerEvent(
5393 kPowerEventPolicyStimulus,
5394 (void *) kStimulusDarkWakeEntry,
5395 _systemStateGeneration );
5396 }
5397 }
5398
5399 DLOG("=== FINISH (%u->%u, 0x%x) type %u, gen %u, msg %x, "
5400 "dcp %x:%x:%x, dbgtimer %u\n",
5401 currentPowerState, (uint32_t) powerState, changeFlags,
5402 _systemTransitionType, _systemStateGeneration,
5403 _systemMessageClientMask,
5404 _desiredCapability, _currentCapability, _pendingCapability,
5405 _lastDebugWakeSeconds);
5406
5407 if (_pendingCapability & kIOPMSystemCapabilityGraphics)
5408 {
5409 displayWakeCnt++;
5410 #if DARK_TO_FULL_EVALUATE_CLAMSHELL
5411 if (clamshellExists && fullWakeThreadCall &&
5412 CAP_HIGHEST(kIOPMSystemCapabilityGraphics))
5413 {
5414 // Not the initial graphics full power, graphics won't
5415 // send a power notification to trigger a lid state
5416 // evaluation.
5417
5418 AbsoluteTime deadline;
5419 clock_interval_to_deadline(45, kSecondScale, &deadline);
5420 thread_call_enter_delayed(fullWakeThreadCall, deadline);
5421 }
5422 #endif
5423 }
5424 else if (CAP_GAIN(kIOPMSystemCapabilityCPU))
5425 darkWakeCnt++;
5426
5427 // Update current system capability.
5428 if (_currentCapability != _pendingCapability)
5429 _currentCapability = _pendingCapability;
5430
5431 // Update highest system capability.
5432
5433 _highestCapability |= _currentCapability;
5434
5435 if (darkWakePostTickle &&
5436 (kSystemTransitionWake == _systemTransitionType) &&
5437 (gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
5438 kDarkWakeFlagHIDTickleLate)
5439 {
5440 darkWakePostTickle = false;
5441 reportUserInput();
5442 }
5443 else if (wranglerTickled) {
5444 requestFullWake( kFullWakeReasonLocalUser );
5445 }
5446
5447 // Reset tracepoint at completion of capability change,
5448 // completion of wake transition, and aborted sleep transition.
5449
5450 if ((_systemTransitionType == kSystemTransitionCapability) ||
5451 (_systemTransitionType == kSystemTransitionWake) ||
5452 ((_systemTransitionType == kSystemTransitionSleep) &&
5453 (changeFlags & kIOPMNotDone)))
5454 {
5455 setProperty(kIOPMSystemCapabilitiesKey, _currentCapability, 64);
5456 tracePoint( kIOPMTracePointSystemUp );
5457 }
5458
5459 _systemTransitionType = kSystemTransitionNone;
5460 _systemMessageClientMask = 0;
5461 toldPowerdCapWillChange = false;
5462
5463 logGraphicsClamp = false;
5464
5465 if (lowBatteryCondition) {
5466 privateSleepSystem (kIOPMSleepReasonLowPower);
5467 }
5468 else if ((fullWakeReason == kFullWakeReasonDisplayOn) && (!displayPowerOnRequested)) {
5469 // Request for full wake is removed while system is waking up to full wake
5470 DLOG("DisplayOn fullwake request is removed\n");
5471 handleDisplayPowerOn();
5472 }
5473
5474 }
5475 }
5476
5477 //******************************************************************************
5478 // PM actions for graphics and audio.
5479 //******************************************************************************
5480
5481 void IOPMrootDomain::overridePowerChangeForUIService(
5482 IOService * service,
5483 IOPMActions * actions,
5484 IOPMPowerStateIndex * inOutPowerState,
5485 IOPMPowerChangeFlags * inOutChangeFlags )
5486 {
5487 uint32_t powerState = (uint32_t) *inOutPowerState;
5488 uint32_t changeFlags = (uint32_t) *inOutChangeFlags;
5489
5490 if (kSystemTransitionNone == _systemTransitionType)
5491 {
5492 // Not in midst of a system transition.
5493 // Do not modify power limit enable state.
5494 }
5495 else if ((actions->parameter & kPMActionsFlagLimitPower) == 0)
5496 {
5497 // Activate power limiter.
5498
5499 if ((actions->parameter & kPMActionsFlagIsDisplayWrangler) &&
5500 ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
5501 (changeFlags & kIOPMSynchronize))
5502 {
5503 actions->parameter |= kPMActionsFlagLimitPower;
5504 }
5505 else if ((actions->parameter & kPMActionsFlagIsAudioDevice) &&
5506 ((gDarkWakeFlags & kDarkWakeFlagAudioNotSuppressed) == 0) &&
5507 ((_pendingCapability & kIOPMSystemCapabilityAudio) == 0) &&
5508 (changeFlags & kIOPMSynchronize))
5509 {
5510 actions->parameter |= kPMActionsFlagLimitPower;
5511 }
5512 else if ((actions->parameter & kPMActionsFlagIsGraphicsDevice) &&
5513 (_systemTransitionType == kSystemTransitionSleep))
5514 {
5515 // For graphics devices, arm the limiter when entering
5516 // system sleep. Not when dropping to dark wake.
5517 actions->parameter |= kPMActionsFlagLimitPower;
5518 }
5519
5520 if (actions->parameter & kPMActionsFlagLimitPower)
5521 {
5522 DLOG("+ plimit %s %p\n",
5523 service->getName(), OBFUSCATE(service));
5524 }
5525 }
5526 else
5527 {
5528 // Remove power limit.
5529
5530 if ((actions->parameter & (
5531 kPMActionsFlagIsDisplayWrangler |
5532 kPMActionsFlagIsGraphicsDevice )) &&
5533 (_pendingCapability & kIOPMSystemCapabilityGraphics))
5534 {
5535 actions->parameter &= ~kPMActionsFlagLimitPower;
5536 }
5537 else if ((actions->parameter & kPMActionsFlagIsAudioDevice) &&
5538 (_pendingCapability & kIOPMSystemCapabilityAudio))
5539 {
5540 actions->parameter &= ~kPMActionsFlagLimitPower;
5541 }
5542
5543 if ((actions->parameter & kPMActionsFlagLimitPower) == 0)
5544 {
5545 DLOG("- plimit %s %p\n",
5546 service->getName(), OBFUSCATE(service));
5547 }
5548 }
5549
5550 if (actions->parameter & kPMActionsFlagLimitPower)
5551 {
5552 uint32_t maxPowerState = (uint32_t)(-1);
5553
5554 if (changeFlags & (kIOPMDomainDidChange | kIOPMDomainWillChange))
5555 {
5556 // Enforce limit for system power/cap transitions.
5557
5558 maxPowerState = 0;
5559 if ((service->getPowerState() > maxPowerState) &&
5560 (actions->parameter & kPMActionsFlagIsDisplayWrangler))
5561 {
5562 maxPowerState++;
5563
5564 // Remove lingering effects of any tickle before entering
5565 // dark wake. It will take a new tickle to return to full
5566 // wake, so the existing tickle state is useless.
5567
5568 if (changeFlags & kIOPMDomainDidChange)
5569 *inOutChangeFlags |= kIOPMExpireIdleTimer;
5570 }
5571 else if (actions->parameter & kPMActionsFlagIsGraphicsDevice)
5572 {
5573 maxPowerState++;
5574 }
5575 }
5576 else
5577 {
5578 // Deny all self-initiated changes when power is limited.
5579 // Wrangler tickle should never defeat the limiter.
5580
5581 maxPowerState = service->getPowerState();
5582 }
5583
5584 if (powerState > maxPowerState)
5585 {
5586 DLOG("> plimit %s %p (%u->%u, 0x%x)\n",
5587 service->getName(), OBFUSCATE(service), powerState, maxPowerState,
5588 changeFlags);
5589 *inOutPowerState = maxPowerState;
5590
5591 if (darkWakePostTickle &&
5592 (actions->parameter & kPMActionsFlagIsDisplayWrangler) &&
5593 (changeFlags & kIOPMDomainWillChange) &&
5594 ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
5595 kDarkWakeFlagHIDTickleEarly))
5596 {
5597 darkWakePostTickle = false;
5598 reportUserInput();
5599 }
5600 }
5601
5602 if (!graphicsSuppressed && (changeFlags & kIOPMDomainDidChange))
5603 {
5604 if (logGraphicsClamp)
5605 {
5606 AbsoluteTime now;
5607 uint64_t nsec;
5608
5609 clock_get_uptime(&now);
5610 SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
5611 absolutetime_to_nanoseconds(now, &nsec);
5612 if (kIOLogPMRootDomain & gIOKitDebug)
5613 MSG("Graphics suppressed %u ms\n",
5614 ((int)((nsec) / NSEC_PER_MSEC)));
5615 }
5616 graphicsSuppressed = true;
5617 }
5618 }
5619 }
5620
5621 void IOPMrootDomain::handleActivityTickleForDisplayWrangler(
5622 IOService * service,
5623 IOPMActions * actions )
5624 {
5625 #if !NO_KERNEL_HID
5626 // Warning: Not running in PM work loop context - don't modify state !!!
5627 // Trap tickle directed to IODisplayWrangler while running with graphics
5628 // capability suppressed.
5629
5630 assert(service == wrangler);
5631
5632 clock_get_uptime(&userActivityTime);
5633 bool aborting = ((lastSleepReason == kIOPMSleepReasonIdle)
5634 || (lastSleepReason == kIOPMSleepReasonMaintenance)
5635 || (lastSleepReason == kIOPMSleepReasonSoftware));
5636 if (aborting) {
5637 userActivityCount++;
5638 DLOG("display wrangler tickled1 %d lastSleepReason %d\n",
5639 userActivityCount, lastSleepReason);
5640 }
5641
5642 if (!wranglerTickled &&
5643 ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0))
5644 {
5645 DLOG("display wrangler tickled\n");
5646 if (kIOLogPMRootDomain & gIOKitDebug)
5647 OSReportWithBacktrace("Dark wake display tickle");
5648 if (pmPowerStateQueue)
5649 {
5650 pmPowerStateQueue->submitPowerEvent(
5651 kPowerEventPolicyStimulus,
5652 (void *) kStimulusDarkWakeActivityTickle,
5653 true /* set wake type */ );
5654 }
5655 }
5656 #endif
5657 }
5658
5659 void IOPMrootDomain::handleUpdatePowerClientForDisplayWrangler(
5660 IOService * service,
5661 IOPMActions * actions,
5662 const OSSymbol * powerClient,
5663 IOPMPowerStateIndex oldPowerState,
5664 IOPMPowerStateIndex newPowerState )
5665 {
5666 #if !NO_KERNEL_HID
5667 assert(service == wrangler);
5668
5669 // This function implements half of the user active detection
5670 // by monitoring changes to the display wrangler's device desire.
5671 //
5672 // User becomes active when either:
5673 // 1. Wrangler's DeviceDesire increases to max, but wrangler is already
5674 // in max power state. This desire change in absence of a power state
5675 // change is detected within. This handles the case when user becomes
5676 // active while the display is already lit by setDisplayPowerOn().
5677 //
5678 // 2. Power state change to max, and DeviceDesire is also at max.
5679 // Handled by displayWranglerNotification().
5680 //
5681 // User becomes inactive when DeviceDesire drops to sleep state or below.
5682
5683 DLOG("wrangler %s (ps %u, %u->%u)\n",
5684 powerClient->getCStringNoCopy(),
5685 (uint32_t) service->getPowerState(),
5686 (uint32_t) oldPowerState, (uint32_t) newPowerState);
5687
5688 if (powerClient == gIOPMPowerClientDevice)
5689 {
5690 if ((newPowerState > oldPowerState) &&
5691 (newPowerState == kWranglerPowerStateMax) &&
5692 (service->getPowerState() == kWranglerPowerStateMax))
5693 {
5694 evaluatePolicy( kStimulusEnterUserActiveState );
5695 }
5696 else
5697 if ((newPowerState < oldPowerState) &&
5698 (newPowerState <= kWranglerPowerStateSleep))
5699 {
5700 evaluatePolicy( kStimulusLeaveUserActiveState );
5701 }
5702 }
5703
5704 if (newPowerState <= kWranglerPowerStateSleep) {
5705 evaluatePolicy( kStimulusDisplayWranglerSleep );
5706 }
5707 else if (newPowerState == kWranglerPowerStateMax) {
5708 evaluatePolicy( kStimulusDisplayWranglerWake );
5709 }
5710 #endif
5711 }
5712
5713 //******************************************************************************
5714 // User active state management
5715 //******************************************************************************
5716
5717 void IOPMrootDomain::preventTransitionToUserActive( bool prevent )
5718 {
5719 #if !NO_KERNEL_HID
5720 _preventUserActive = prevent;
5721 if (wrangler && !_preventUserActive)
5722 {
5723 // Allowing transition to user active, but the wrangler may have
5724 // already powered ON in case of sleep cancel/revert. Poll the
5725 // same conditions checked for in displayWranglerNotification()
5726 // to bring the user active state up to date.
5727
5728 if ((wrangler->getPowerState() == kWranglerPowerStateMax) &&
5729 (wrangler->getPowerStateForClient(gIOPMPowerClientDevice) ==
5730 kWranglerPowerStateMax))
5731 {
5732 evaluatePolicy( kStimulusEnterUserActiveState );
5733 }
5734 }
5735 #endif
5736 }
5737
5738 //******************************************************************************
5739 // Approve usage of delayed child notification by PM.
5740 //******************************************************************************
5741
5742 bool IOPMrootDomain::shouldDelayChildNotification(
5743 IOService * service )
5744 {
5745 if (((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) != 0) &&
5746 (kFullWakeReasonNone == fullWakeReason) &&
5747 (kSystemTransitionWake == _systemTransitionType))
5748 {
5749 DLOG("%s: delay child notify\n", service->getName());
5750 return true;
5751 }
5752 return false;
5753 }
5754
5755 //******************************************************************************
5756 // PM actions for PCI device.
5757 //******************************************************************************
5758
5759 void IOPMrootDomain::handlePowerChangeStartForPCIDevice(
5760 IOService * service,
5761 IOPMActions * actions,
5762 IOPMPowerStateIndex powerState,
5763 IOPMPowerChangeFlags * inOutChangeFlags )
5764 {
5765 pmTracer->tracePCIPowerChange(
5766 PMTraceWorker::kPowerChangeStart,
5767 service, *inOutChangeFlags,
5768 (actions->parameter & kPMActionsPCIBitNumberMask));
5769 }
5770
5771 void IOPMrootDomain::handlePowerChangeDoneForPCIDevice(
5772 IOService * service,
5773 IOPMActions * actions,
5774 IOPMPowerStateIndex powerState,
5775 IOPMPowerChangeFlags changeFlags )
5776 {
5777 pmTracer->tracePCIPowerChange(
5778 PMTraceWorker::kPowerChangeCompleted,
5779 service, changeFlags,
5780 (actions->parameter & kPMActionsPCIBitNumberMask));
5781 }
5782
5783 //******************************************************************************
5784 // registerInterest
5785 //
5786 // Override IOService::registerInterest() to intercept special clients.
5787 //******************************************************************************
5788
5789 class IOPMServiceInterestNotifier: public _IOServiceInterestNotifier
5790 {
5791
5792 friend class IOPMrootDomain;
5793 OSDeclareDefaultStructors(IOPMServiceInterestNotifier)
5794
5795 protected:
5796 uint32_t ackTimeoutCnt;
5797 uint32_t msgType; // Message pending ack
5798
5799 uint64_t uuid0;
5800 uint64_t uuid1;
5801 const OSSymbol *identifier;
5802 };
5803
5804 OSDefineMetaClassAndStructors(IOPMServiceInterestNotifier, _IOServiceInterestNotifier)
5805
5806 IONotifier * IOPMrootDomain::registerInterest(
5807 const OSSymbol * typeOfInterest,
5808 IOServiceInterestHandler handler,
5809 void * target, void * ref )
5810 {
5811 IOPMServiceInterestNotifier *notifier = 0;
5812 bool isSystemCapabilityClient;
5813 bool isKernelCapabilityClient;
5814 IOReturn rc = kIOReturnError;;
5815
5816 isSystemCapabilityClient =
5817 typeOfInterest &&
5818 typeOfInterest->isEqualTo(kIOPMSystemCapabilityInterest);
5819
5820 isKernelCapabilityClient =
5821 typeOfInterest &&
5822 typeOfInterest->isEqualTo(gIOPriorityPowerStateInterest);
5823
5824 if (isSystemCapabilityClient)
5825 typeOfInterest = gIOAppPowerStateInterest;
5826
5827 notifier = new IOPMServiceInterestNotifier;
5828 if (!notifier) return NULL;
5829
5830 if (notifier->init()) {
5831 rc = super::registerInterestForNotifier(notifier, typeOfInterest, handler, target, ref);
5832 }
5833 if (rc != kIOReturnSuccess) {
5834 notifier->release();
5835 notifier = 0;
5836
5837 return NULL;
5838 }
5839 if (pmPowerStateQueue)
5840 {
5841 notifier->ackTimeoutCnt = 0;
5842 if (isSystemCapabilityClient)
5843 {
5844 notifier->retain();
5845 if (pmPowerStateQueue->submitPowerEvent(
5846 kPowerEventRegisterSystemCapabilityClient, notifier) == false)
5847 notifier->release();
5848 }
5849
5850 if (isKernelCapabilityClient)
5851 {
5852 notifier->retain();
5853 if (pmPowerStateQueue->submitPowerEvent(
5854 kPowerEventRegisterKernelCapabilityClient, notifier) == false)
5855 notifier->release();
5856 }
5857 }
5858
5859 OSData *data = NULL;
5860 uint8_t *uuid = NULL;
5861 OSKext *kext = OSKext::lookupKextWithAddress((vm_address_t)handler);
5862 if (kext) {
5863 data = kext->copyUUID();
5864 }
5865 if (data && (data->getLength() == sizeof(uuid_t))) {
5866 uuid = (uint8_t *)(data->getBytesNoCopy());
5867
5868 notifier->uuid0 = ((uint64_t)(uuid[0]) << 56) | ((uint64_t)(uuid[1]) << 48) | ((uint64_t)(uuid[2]) << 40)|
5869 ((uint64_t)(uuid[3]) << 32) | ((uint64_t)(uuid[4]) << 24) | ((uint64_t)(uuid[5]) << 16) |
5870 ((uint64_t)(uuid[6]) << 8) | (uuid[7]);
5871 notifier->uuid1 = ((uint64_t)(uuid[8]) << 56) | ((uint64_t)(uuid[9]) << 48) | ((uint64_t)(uuid[10]) << 40)|
5872 ((uint64_t)(uuid[11]) << 32) | ((uint64_t)(uuid[12]) << 24) | ((uint64_t)(uuid[13]) << 16) |
5873 ((uint64_t)(uuid[14]) << 8) | (uuid[15]);
5874
5875 notifier->identifier = kext->getIdentifier();
5876
5877 }
5878 if (kext) kext->release();
5879 if (data) data->release();
5880
5881 return notifier;
5882 }
5883
5884 //******************************************************************************
5885 // systemMessageFilter
5886 //
5887 //******************************************************************************
5888
5889 bool IOPMrootDomain::systemMessageFilter(
5890 void * object, void * arg1, void * arg2, void * arg3 )
5891 {
5892 const IOPMInterestContext * context = (const IOPMInterestContext *) arg1;
5893 bool isCapMsg = (context->messageType == kIOMessageSystemCapabilityChange);
5894 bool isCapClient = false;
5895 bool allow = false;
5896 IOPMServiceInterestNotifier *notifier;
5897
5898 notifier = OSDynamicCast(IOPMServiceInterestNotifier, (OSObject *)object);
5899 do {
5900 if ((kSystemTransitionNewCapClient == _systemTransitionType) &&
5901 (!isCapMsg || !_joinedCapabilityClients ||
5902 !_joinedCapabilityClients->containsObject((OSObject *) object)))
5903 break;
5904
5905 // Capability change message for app and kernel clients.
5906
5907 if (isCapMsg)
5908 {
5909 if ((context->notifyType == kNotifyPriority) ||
5910 (context->notifyType == kNotifyCapabilityChangePriority))
5911 isCapClient = true;
5912
5913 if ((context->notifyType == kNotifyCapabilityChangeApps) &&
5914 (object == (void *) systemCapabilityNotifier))
5915 isCapClient = true;
5916 }
5917
5918 if (isCapClient)
5919 {
5920 IOPMSystemCapabilityChangeParameters * capArgs =
5921 (IOPMSystemCapabilityChangeParameters *) arg2;
5922
5923 if (kSystemTransitionNewCapClient == _systemTransitionType)
5924 {
5925 capArgs->fromCapabilities = 0;
5926 capArgs->toCapabilities = _currentCapability;
5927 capArgs->changeFlags = 0;
5928 }
5929 else
5930 {
5931 capArgs->fromCapabilities = _currentCapability;
5932 capArgs->toCapabilities = _pendingCapability;
5933
5934 if (context->isPreChange)
5935 capArgs->changeFlags = kIOPMSystemCapabilityWillChange;
5936 else
5937 capArgs->changeFlags = kIOPMSystemCapabilityDidChange;
5938
5939 if ((object == (void *) systemCapabilityNotifier) &&
5940 context->isPreChange)
5941 {
5942 toldPowerdCapWillChange = true;
5943 }
5944 }
5945
5946 // Capability change messages only go to the PM configd plugin.
5947 // Wait for response post-change if capabilitiy is increasing.
5948 // Wait for response pre-change if capability is decreasing.
5949
5950 if ((context->notifyType == kNotifyCapabilityChangeApps) && arg3 &&
5951 ( (capabilityLoss && context->isPreChange) ||
5952 (!capabilityLoss && !context->isPreChange) ) )
5953 {
5954 // app has not replied yet, wait for it
5955 *((OSObject **) arg3) = kOSBooleanFalse;
5956
5957 }
5958
5959 allow = true;
5960 break;
5961 }
5962
5963 // Capability client will always see kIOMessageCanSystemSleep,
5964 // even for demand sleep. It will also have a chance to veto
5965 // sleep one last time after all clients have responded to
5966 // kIOMessageSystemWillSleep
5967
5968 if ((kIOMessageCanSystemSleep == context->messageType) ||
5969 (kIOMessageSystemWillNotSleep == context->messageType))
5970 {
5971 if (object == (OSObject *) systemCapabilityNotifier)
5972 {
5973 allow = true;
5974 break;
5975 }
5976
5977 // Not idle sleep, don't ask apps.
5978 if (context->changeFlags & kIOPMSkipAskPowerDown)
5979 {
5980 break;
5981 }
5982 }
5983
5984 if (kIOPMMessageLastCallBeforeSleep == context->messageType)
5985 {
5986 if ((object == (OSObject *) systemCapabilityNotifier) &&
5987 CAP_HIGHEST(kIOPMSystemCapabilityGraphics) &&
5988 (fullToDarkReason == kIOPMSleepReasonIdle)) {
5989 allow = true;
5990 }
5991 break;
5992 }
5993
5994 // Reject capability change messages for legacy clients.
5995 // Reject legacy system sleep messages for capability client.
5996
5997 if (isCapMsg || (object == (OSObject *) systemCapabilityNotifier))
5998 {
5999 break;
6000 }
6001
6002 // Filter system sleep messages.
6003
6004 if ((context->notifyType == kNotifyApps) &&
6005 (_systemMessageClientMask & kSystemMessageClientLegacyApp))
6006 {
6007 allow = true;
6008
6009 if (notifier) {
6010 if (arg3) {
6011 if (notifier->ackTimeoutCnt >= 3)
6012 *((OSObject **) arg3) = kOSBooleanFalse;
6013 else
6014 *((OSObject **) arg3) = kOSBooleanTrue;
6015 }
6016 }
6017 }
6018 else if ((context->notifyType == kNotifyPriority) &&
6019 (_systemMessageClientMask & kSystemMessageClientKernel))
6020 {
6021 allow = true;
6022 }
6023 }
6024 while (false);
6025
6026 if (allow && isCapMsg && _joinedCapabilityClients)
6027 {
6028 _joinedCapabilityClients->removeObject((OSObject *) object);
6029 if (_joinedCapabilityClients->getCount() == 0)
6030 {
6031 DLOG("destroyed capability client set %p\n",
6032 OBFUSCATE(_joinedCapabilityClients));
6033 _joinedCapabilityClients->release();
6034 _joinedCapabilityClients = 0;
6035 }
6036 }
6037 if (notifier) {
6038 notifier->msgType = context->messageType;
6039 }
6040
6041 return allow;
6042 }
6043
6044 //******************************************************************************
6045 // setMaintenanceWakeCalendar
6046 //
6047 //******************************************************************************
6048
6049 IOReturn IOPMrootDomain::setMaintenanceWakeCalendar(
6050 const IOPMCalendarStruct * calendar )
6051 {
6052 OSData * data;
6053 IOReturn ret = 0;
6054
6055 if (!calendar)
6056 return kIOReturnBadArgument;
6057
6058 data = OSData::withBytesNoCopy((void *) calendar, sizeof(*calendar));
6059 if (!data)
6060 return kIOReturnNoMemory;
6061
6062 if (kPMCalendarTypeMaintenance == calendar->selector) {
6063 ret = setPMSetting(gIOPMSettingMaintenanceWakeCalendarKey, data);
6064 if (kIOReturnSuccess == ret)
6065 OSBitOrAtomic(kIOPMAlarmBitMaintenanceWake, &_scheduledAlarms);
6066 } else
6067 if (kPMCalendarTypeSleepService == calendar->selector)
6068 {
6069 ret = setPMSetting(gIOPMSettingSleepServiceWakeCalendarKey, data);
6070 if (kIOReturnSuccess == ret)
6071 OSBitOrAtomic(kIOPMAlarmBitSleepServiceWake, &_scheduledAlarms);
6072 }
6073 DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
6074
6075 data->release();
6076 return ret;
6077 }
6078
6079 // MARK: -
6080 // MARK: Display Wrangler
6081
6082 //******************************************************************************
6083 // displayWranglerNotification
6084 //
6085 // Handle the notification when the IODisplayWrangler changes power state.
6086 //******************************************************************************
6087
6088 IOReturn IOPMrootDomain::displayWranglerNotification(
6089 void * target, void * refCon,
6090 UInt32 messageType, IOService * service,
6091 void * messageArgument, vm_size_t argSize )
6092 {
6093 #if !NO_KERNEL_HID
6094 int displayPowerState;
6095 IOPowerStateChangeNotification * params =
6096 (IOPowerStateChangeNotification *) messageArgument;
6097
6098 if ((messageType != kIOMessageDeviceWillPowerOff) &&
6099 (messageType != kIOMessageDeviceHasPoweredOn))
6100 return kIOReturnUnsupported;
6101
6102 ASSERT_GATED();
6103 if (!gRootDomain)
6104 return kIOReturnUnsupported;
6105
6106 displayPowerState = params->stateNumber;
6107 DLOG("wrangler %s ps %d\n",
6108 getIOMessageString(messageType), displayPowerState);
6109
6110 switch (messageType) {
6111 case kIOMessageDeviceWillPowerOff:
6112 // Display wrangler has dropped power due to display idle
6113 // or force system sleep.
6114 //
6115 // 4 Display ON kWranglerPowerStateMax
6116 // 3 Display Dim kWranglerPowerStateDim
6117 // 2 Display Sleep kWranglerPowerStateSleep
6118 // 1 Not visible to user
6119 // 0 Not visible to user kWranglerPowerStateMin
6120
6121 if (displayPowerState <= kWranglerPowerStateSleep)
6122 gRootDomain->evaluatePolicy( kStimulusDisplayWranglerSleep );
6123 break;
6124
6125 case kIOMessageDeviceHasPoweredOn:
6126 // Display wrangler has powered on due to user activity
6127 // or wake from sleep.
6128
6129 if (kWranglerPowerStateMax == displayPowerState)
6130 {
6131 gRootDomain->evaluatePolicy( kStimulusDisplayWranglerWake );
6132
6133 // See comment in handleUpdatePowerClientForDisplayWrangler
6134 if (service->getPowerStateForClient(gIOPMPowerClientDevice) ==
6135 kWranglerPowerStateMax)
6136 {
6137 gRootDomain->evaluatePolicy( kStimulusEnterUserActiveState );
6138 }
6139 }
6140 break;
6141 }
6142 #endif
6143 return kIOReturnUnsupported;
6144 }
6145
6146 //******************************************************************************
6147 // displayWranglerMatchPublished
6148 //
6149 // Receives a notification when the IODisplayWrangler is published.
6150 // When it's published we install a power state change handler.
6151 //******************************************************************************
6152
6153 bool IOPMrootDomain::displayWranglerMatchPublished(
6154 void * target,
6155 void * refCon,
6156 IOService * newService,
6157 IONotifier * notifier __unused)
6158 {
6159 #if !NO_KERNEL_HID
6160 // install a handler
6161 if( !newService->registerInterest( gIOGeneralInterest,
6162 &displayWranglerNotification, target, 0) )
6163 {
6164 return false;
6165 }
6166 #endif
6167 return true;
6168 }
6169
6170 //******************************************************************************
6171 // reportUserInput
6172 //
6173 //******************************************************************************
6174
6175 void IOPMrootDomain::reportUserInput( void )
6176 {
6177 #if !NO_KERNEL_HID
6178 OSIterator * iter;
6179 OSDictionary * matching;
6180
6181 if(!wrangler)
6182 {
6183 matching = serviceMatching("IODisplayWrangler");
6184 iter = getMatchingServices(matching);
6185 if (matching) matching->release();
6186 if(iter)
6187 {
6188 wrangler = OSDynamicCast(IOService, iter->getNextObject());
6189 iter->release();
6190 }
6191 }
6192
6193 if(wrangler)
6194 wrangler->activityTickle(0,0);
6195 #endif
6196 }
6197
6198 //******************************************************************************
6199 // latchDisplayWranglerTickle
6200 //******************************************************************************
6201
6202 bool IOPMrootDomain::latchDisplayWranglerTickle( bool latch )
6203 {
6204 #if !NO_KERNEL_HID
6205 if (latch)
6206 {
6207 if (!(_currentCapability & kIOPMSystemCapabilityGraphics) &&
6208 !(_pendingCapability & kIOPMSystemCapabilityGraphics) &&
6209 !checkSystemCanSustainFullWake())
6210 {
6211 // Currently in dark wake, and not transitioning to full wake.
6212 // Full wake is unsustainable, so latch the tickle to prevent
6213 // the display from lighting up momentarily.
6214 wranglerTickleLatched = true;
6215 }
6216 else
6217 {
6218 wranglerTickleLatched = false;
6219 }
6220 }
6221 else if (wranglerTickleLatched && checkSystemCanSustainFullWake())
6222 {
6223 wranglerTickleLatched = false;
6224
6225 pmPowerStateQueue->submitPowerEvent(
6226 kPowerEventPolicyStimulus,
6227 (void *) kStimulusDarkWakeActivityTickle );
6228 }
6229
6230 return wranglerTickleLatched;
6231 #else
6232 return false;
6233 #endif
6234 }
6235
6236 //******************************************************************************
6237 // setDisplayPowerOn
6238 //
6239 // For root domain user client
6240 //******************************************************************************
6241
6242 void IOPMrootDomain::setDisplayPowerOn( uint32_t options )
6243 {
6244 pmPowerStateQueue->submitPowerEvent( kPowerEventSetDisplayPowerOn,
6245 (void *) 0, options );
6246 }
6247
6248 // MARK: -
6249 // MARK: Battery
6250
6251 //******************************************************************************
6252 // batteryPublished
6253 //
6254 // Notification on battery class IOPowerSource appearance
6255 //******************************************************************************
6256
6257 bool IOPMrootDomain::batteryPublished(
6258 void * target,
6259 void * root_domain,
6260 IOService * resourceService,
6261 IONotifier * notifier __unused )
6262 {
6263 // rdar://2936060&4435589
6264 // All laptops have dimmable LCD displays
6265 // All laptops have batteries
6266 // So if this machine has a battery, publish the fact that the backlight
6267 // supports dimming.
6268 ((IOPMrootDomain *)root_domain)->publishFeature("DisplayDims");
6269
6270 return (true);
6271 }
6272
6273 // MARK: -
6274 // MARK: System PM Policy
6275
6276 //******************************************************************************
6277 // checkSystemSleepAllowed
6278 //
6279 //******************************************************************************
6280
6281 bool IOPMrootDomain::checkSystemSleepAllowed( IOOptionBits options,
6282 uint32_t sleepReason )
6283 {
6284 int err = 0;
6285
6286 // Conditions that prevent idle and demand system sleep.
6287
6288 do {
6289 if (userDisabledAllSleep)
6290 {
6291 err = 1; // 1. user-space sleep kill switch
6292 break;
6293 }
6294
6295 if (systemBooting || systemShutdown || gWillShutdown)
6296 {
6297 err = 2; // 2. restart or shutdown in progress
6298 break;
6299 }
6300
6301 if (options == 0)
6302 break;
6303
6304 // Conditions above pegs the system at full wake.
6305 // Conditions below prevent system sleep but does not prevent
6306 // dark wake, and must be called from gated context.
6307
6308 #if !CONFIG_SLEEP
6309 err = 3; // 3. config does not support sleep
6310 break;
6311 #endif
6312
6313 if (lowBatteryCondition || thermalWarningState)
6314 {
6315 break; // always sleep on low battery or when in thermal warning state
6316 }
6317
6318 if (sleepReason == kIOPMSleepReasonDarkWakeThermalEmergency)
6319 {
6320 break; // always sleep on dark wake thermal emergencies
6321 }
6322
6323 if (preventSystemSleepList->getCount() != 0)
6324 {
6325 err = 4; // 4. child prevent system sleep clamp
6326 break;
6327 }
6328
6329 if (getPMAssertionLevel( kIOPMDriverAssertionCPUBit ) ==
6330 kIOPMDriverAssertionLevelOn)
6331 {
6332 err = 5; // 5. CPU assertion
6333 break;
6334 }
6335
6336 if (pciCantSleepValid)
6337 {
6338 if (pciCantSleepFlag)
6339 err = 6; // 6. PCI card does not support PM (cached)
6340 break;
6341 }
6342 else if (sleepSupportedPEFunction &&
6343 CAP_HIGHEST(kIOPMSystemCapabilityGraphics))
6344 {
6345 IOReturn ret;
6346 OSBitAndAtomic(~kPCICantSleep, &platformSleepSupport);
6347 ret = getPlatform()->callPlatformFunction(
6348 sleepSupportedPEFunction, false,
6349 NULL, NULL, NULL, NULL);
6350 pciCantSleepValid = true;
6351 pciCantSleepFlag = false;
6352 if ((platformSleepSupport & kPCICantSleep) ||
6353 ((ret != kIOReturnSuccess) && (ret != kIOReturnUnsupported)))
6354 {
6355 err = 6; // 6. PCI card does not support PM
6356 pciCantSleepFlag = true;
6357 break;
6358 }
6359 }
6360 }
6361 while (false);
6362
6363 if (err)
6364 {
6365 DLOG("System sleep prevented by %d\n", err);
6366 return false;
6367 }
6368 return true;
6369 }
6370
6371 bool IOPMrootDomain::checkSystemSleepEnabled( void )
6372 {
6373 return checkSystemSleepAllowed(0, 0);
6374 }
6375
6376 bool IOPMrootDomain::checkSystemCanSleep( uint32_t sleepReason )
6377 {
6378 ASSERT_GATED();
6379 return checkSystemSleepAllowed(1, sleepReason);
6380 }
6381
6382 //******************************************************************************
6383 // checkSystemCanSustainFullWake
6384 //******************************************************************************
6385
6386 bool IOPMrootDomain::checkSystemCanSustainFullWake( void )
6387 {
6388 #if !NO_KERNEL_HID
6389 if (lowBatteryCondition || thermalWarningState)
6390 {
6391 // Low battery wake, or received a low battery notification
6392 // while system is awake. This condition will persist until
6393 // the following wake.
6394 return false;
6395 }
6396
6397 if (clamshellExists && clamshellClosed && !clamshellSleepDisabled)
6398 {
6399 // Graphics state is unknown and external display might not be probed.
6400 // Do not incorporate state that requires graphics to be in max power
6401 // such as desktopMode or clamshellDisabled.
6402
6403 if (!acAdaptorConnected)
6404 {
6405 DLOG("full wake check: no AC\n");
6406 return false;
6407 }
6408 }
6409 #endif
6410 return true;
6411 }
6412
6413 //******************************************************************************
6414 // mustHibernate
6415 //******************************************************************************
6416
6417 #if HIBERNATION
6418
6419 bool IOPMrootDomain::mustHibernate( void )
6420 {
6421 return (lowBatteryCondition || thermalWarningState);
6422 }
6423
6424 #endif /* HIBERNATION */
6425
6426 //******************************************************************************
6427 // adjustPowerState
6428 //
6429 // Conditions that affect our wake/sleep decision has changed.
6430 // If conditions dictate that the system must remain awake, clamp power
6431 // state to max with changePowerStateToPriv(ON). Otherwise if sleepASAP
6432 // is TRUE, then remove the power clamp and allow the power state to drop
6433 // to SLEEP_STATE.
6434 //******************************************************************************
6435
6436 void IOPMrootDomain::adjustPowerState( bool sleepASAP )
6437 {
6438 DLOG("adjustPowerState ps %u, asap %d, idleSleepEnabled %d\n",
6439 (uint32_t) getPowerState(), sleepASAP, idleSleepEnabled);
6440
6441 ASSERT_GATED();
6442
6443 if ((!idleSleepEnabled) || !checkSystemSleepEnabled())
6444 {
6445 changePowerStateToPriv(ON_STATE);
6446 }
6447 else if ( sleepASAP )
6448 {
6449 changePowerStateToPriv(SLEEP_STATE);
6450 }
6451 }
6452
6453 void IOPMrootDomain::handleDisplayPowerOn( )
6454 {
6455 if (!wrangler) return;
6456 if (displayPowerOnRequested)
6457 {
6458 if (!checkSystemCanSustainFullWake()) return;
6459
6460 // Force wrangler to max power state. If system is in dark wake
6461 // this alone won't raise the wrangler's power state.
6462
6463 wrangler->changePowerStateForRootDomain(kWranglerPowerStateMax);
6464
6465 // System in dark wake, always requesting full wake should
6466 // not have any bad side-effects, even if the request fails.
6467
6468 if (!CAP_CURRENT(kIOPMSystemCapabilityGraphics))
6469 {
6470 setProperty(kIOPMRootDomainWakeTypeKey, kIOPMRootDomainWakeTypeNotification);
6471 requestFullWake( kFullWakeReasonDisplayOn );
6472 }
6473 }
6474 else
6475 {
6476 // Relenquish desire to power up display.
6477 // Must first transition to state 1 since wrangler doesn't
6478 // power off the displays at state 0. At state 0 the root
6479 // domain is removed from the wrangler's power client list.
6480
6481 wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin + 1);
6482 wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin);
6483
6484 }
6485
6486 }
6487
6488 //******************************************************************************
6489 // dispatchPowerEvent
6490 //
6491 // IOPMPowerStateQueue callback function. Running on PM work loop thread.
6492 //******************************************************************************
6493
6494 void IOPMrootDomain::dispatchPowerEvent(
6495 uint32_t event, void * arg0, uint64_t arg1 )
6496 {
6497 ASSERT_GATED();
6498
6499 switch (event)
6500 {
6501 case kPowerEventFeatureChanged:
6502 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6503 messageClients(kIOPMMessageFeatureChange, this);
6504 break;
6505
6506 case kPowerEventReceivedPowerNotification:
6507 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6508 handlePowerNotification( (UInt32)(uintptr_t) arg0 );
6509 break;
6510
6511 case kPowerEventSystemBootCompleted:
6512 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6513 if (systemBooting)
6514 {
6515 systemBooting = false;
6516
6517 if (lowBatteryCondition)
6518 {
6519 privateSleepSystem (kIOPMSleepReasonLowPower);
6520
6521 // The rest is unnecessary since the system is expected
6522 // to sleep immediately. The following wake will update
6523 // everything.
6524 break;
6525 }
6526
6527 sleepWakeDebugMemAlloc();
6528 saveFailureData2File();
6529
6530 // If lid is closed, re-send lid closed notification
6531 // now that booting is complete.
6532 if ( clamshellClosed )
6533 {
6534 handlePowerNotification(kLocalEvalClamshellCommand);
6535 }
6536 evaluatePolicy( kStimulusAllowSystemSleepChanged );
6537
6538 }
6539 break;
6540
6541 case kPowerEventSystemShutdown:
6542 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6543 if (kOSBooleanTrue == (OSBoolean *) arg0)
6544 {
6545 /* We set systemShutdown = true during shutdown
6546 to prevent sleep at unexpected times while loginwindow is trying
6547 to shutdown apps and while the OS is trying to transition to
6548 complete power of.
6549
6550 Set to true during shutdown, as soon as loginwindow shows
6551 the "shutdown countdown dialog", through individual app
6552 termination, and through black screen kernel shutdown.
6553 */
6554 systemShutdown = true;
6555 } else {
6556 /*
6557 A shutdown was initiated, but then the shutdown
6558 was cancelled, clearing systemShutdown to false here.
6559 */
6560 systemShutdown = false;
6561 }
6562 break;
6563
6564 case kPowerEventUserDisabledSleep:
6565 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6566 userDisabledAllSleep = (kOSBooleanTrue == (OSBoolean *) arg0);
6567 break;
6568
6569 case kPowerEventRegisterSystemCapabilityClient:
6570 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6571 if (systemCapabilityNotifier)
6572 {
6573 systemCapabilityNotifier->release();
6574 systemCapabilityNotifier = 0;
6575 }
6576 if (arg0)
6577 {
6578 systemCapabilityNotifier = (IONotifier *) arg0;
6579 systemCapabilityNotifier->retain();
6580 }
6581 /* intentional fall-through */
6582 [[clang::fallthrough]];
6583
6584 case kPowerEventRegisterKernelCapabilityClient:
6585 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6586 if (!_joinedCapabilityClients)
6587 _joinedCapabilityClients = OSSet::withCapacity(8);
6588 if (arg0)
6589 {
6590 IONotifier * notify = (IONotifier *) arg0;
6591 if (_joinedCapabilityClients)
6592 {
6593 _joinedCapabilityClients->setObject(notify);
6594 synchronizePowerTree( kIOPMSyncNoChildNotify );
6595 }
6596 notify->release();
6597 }
6598 break;
6599
6600 case kPowerEventPolicyStimulus:
6601 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6602 if (arg0)
6603 {
6604 int stimulus = (uintptr_t) arg0;
6605 evaluatePolicy( stimulus, (uint32_t) arg1 );
6606 }
6607 break;
6608
6609 case kPowerEventAssertionCreate:
6610 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6611 if (pmAssertions) {
6612 pmAssertions->handleCreateAssertion((OSData *)arg0);
6613 }
6614 break;
6615
6616
6617 case kPowerEventAssertionRelease:
6618 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6619 if (pmAssertions) {
6620 pmAssertions->handleReleaseAssertion(arg1);
6621 }
6622 break;
6623
6624 case kPowerEventAssertionSetLevel:
6625 DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6626 if (pmAssertions) {
6627 pmAssertions->handleSetAssertionLevel(arg1, (IOPMDriverAssertionLevel)(uintptr_t)arg0);
6628 }
6629 break;
6630
6631 case kPowerEventQueueSleepWakeUUID:
6632 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6633 handleQueueSleepWakeUUID((OSObject *)arg0);
6634 break;
6635 case kPowerEventPublishSleepWakeUUID:
6636 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6637 handlePublishSleepWakeUUID((bool)arg0);
6638 break;
6639
6640 case kPowerEventSetDisplayPowerOn:
6641 DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
6642 if (!wrangler) break;
6643 if (arg1 != 0)
6644 {
6645 displayPowerOnRequested = true;
6646 }
6647 else
6648 {
6649 displayPowerOnRequested = false;
6650 }
6651 handleDisplayPowerOn();
6652 break;
6653 }
6654 }
6655
6656 //******************************************************************************
6657 // systemPowerEventOccurred
6658 //
6659 // The power controller is notifying us of a hardware-related power management
6660 // event that we must handle.
6661 //
6662 // systemPowerEventOccurred covers the same functionality that
6663 // receivePowerNotification does; it simply provides a richer API for conveying
6664 // more information.
6665 //******************************************************************************
6666
6667 IOReturn IOPMrootDomain::systemPowerEventOccurred(
6668 const OSSymbol *event,
6669 uint32_t intValue)
6670 {
6671 IOReturn attempt = kIOReturnSuccess;
6672 OSNumber *newNumber = NULL;
6673
6674 if (!event)
6675 return kIOReturnBadArgument;
6676
6677 newNumber = OSNumber::withNumber(intValue, 8*sizeof(intValue));
6678 if (!newNumber)
6679 return kIOReturnInternalError;
6680
6681 attempt = systemPowerEventOccurred(event, (OSObject *)newNumber);
6682
6683 newNumber->release();
6684
6685 return attempt;
6686 }
6687
6688 void IOPMrootDomain::setThermalState(OSObject *value)
6689 {
6690 OSNumber * num;
6691
6692 if (gIOPMWorkLoop->inGate() == false) {
6693 gIOPMWorkLoop->runAction(
6694 OSMemberFunctionCast(IOWorkLoop::Action, this, &IOPMrootDomain::setThermalState),
6695 (OSObject *)this,
6696 (void *)value);
6697
6698 return;
6699 }
6700 if (value && (num = OSDynamicCast(OSNumber, value))) {
6701 thermalWarningState = ((num->unsigned32BitValue() == kIOPMThermalLevelWarning) ||
6702 (num->unsigned32BitValue() == kIOPMThermalLevelTrap)) ? 1 : 0;
6703 }
6704 }
6705
6706 IOReturn IOPMrootDomain::systemPowerEventOccurred(
6707 const OSSymbol *event,
6708 OSObject *value)
6709 {
6710 OSDictionary *thermalsDict = NULL;
6711 bool shouldUpdate = true;
6712
6713 if (!event || !value)
6714 return kIOReturnBadArgument;
6715
6716 // LOCK
6717 // We reuse featuresDict Lock because it already exists and guards
6718 // the very infrequently used publish/remove feature mechanism; so there's zero rsk
6719 // of stepping on that lock.
6720 if (featuresDictLock) IOLockLock(featuresDictLock);
6721
6722 thermalsDict = (OSDictionary *)getProperty(kIOPMRootDomainPowerStatusKey);
6723
6724 if (thermalsDict && OSDynamicCast(OSDictionary, thermalsDict)) {
6725 thermalsDict = OSDictionary::withDictionary(thermalsDict);
6726 } else {
6727 thermalsDict = OSDictionary::withCapacity(1);
6728 }
6729
6730 if (!thermalsDict) {
6731 shouldUpdate = false;
6732 goto exit;
6733 }
6734
6735 thermalsDict->setObject (event, value);
6736
6737 setProperty (kIOPMRootDomainPowerStatusKey, thermalsDict);
6738
6739 thermalsDict->release();
6740
6741 exit:
6742 // UNLOCK
6743 if (featuresDictLock) IOLockUnlock(featuresDictLock);
6744
6745 if (shouldUpdate) {
6746 if (event &&
6747 event->isEqualTo(kIOPMThermalLevelWarningKey)) {
6748 setThermalState(value);
6749 }
6750 messageClients (kIOPMMessageSystemPowerEventOccurred, (void *)NULL);
6751 }
6752
6753 return kIOReturnSuccess;
6754 }
6755
6756 //******************************************************************************
6757 // receivePowerNotification
6758 //
6759 // The power controller is notifying us of a hardware-related power management
6760 // event that we must handle. This may be a result of an 'environment' interrupt
6761 // from the power mgt micro.
6762 //******************************************************************************
6763
6764 IOReturn IOPMrootDomain::receivePowerNotification( UInt32 msg )
6765 {
6766 pmPowerStateQueue->submitPowerEvent(
6767 kPowerEventReceivedPowerNotification, (void *)(uintptr_t) msg );
6768 return kIOReturnSuccess;
6769 }
6770
6771 void IOPMrootDomain::handlePowerNotification( UInt32 msg )
6772 {
6773 bool eval_clamshell = false;
6774
6775 ASSERT_GATED();
6776
6777 /*
6778 * Local (IOPMrootDomain only) eval clamshell command
6779 */
6780 if (msg & kLocalEvalClamshellCommand)
6781 {
6782 eval_clamshell = true;
6783 }
6784
6785 /*
6786 * Overtemp
6787 */
6788 if (msg & kIOPMOverTemp)
6789 {
6790 MSG("PowerManagement emergency overtemp signal. Going to sleep!");
6791 privateSleepSystem (kIOPMSleepReasonThermalEmergency);
6792 }
6793
6794 /*
6795 * Forward DW thermal notification to client, if system is not going to sleep
6796 */
6797 if ((msg & kIOPMDWOverTemp) && (_systemTransitionType != kSystemTransitionSleep))
6798 {
6799 DLOG("DarkWake thermal limits message received!\n");
6800
6801 messageClients(kIOPMMessageDarkWakeThermalEmergency);
6802 }
6803
6804 /*
6805 * Sleep Now!
6806 */
6807 if (msg & kIOPMSleepNow)
6808 {
6809 privateSleepSystem (kIOPMSleepReasonSoftware);
6810 }
6811
6812 /*
6813 * Power Emergency
6814 */
6815 if (msg & kIOPMPowerEmergency)
6816 {
6817 lowBatteryCondition = true;
6818 privateSleepSystem (kIOPMSleepReasonLowPower);
6819 }
6820
6821 /*
6822 * Clamshell OPEN
6823 */
6824 if (msg & kIOPMClamshellOpened)
6825 {
6826 DLOG("Clamshell opened\n");
6827 // Received clamshel open message from clamshell controlling driver
6828 // Update our internal state and tell general interest clients
6829 clamshellClosed = false;
6830 clamshellExists = true;
6831
6832 // Don't issue a hid tickle when lid is open and polled on wake
6833 if (msg & kIOPMSetValue)
6834 {
6835 setProperty(kIOPMRootDomainWakeTypeKey, "Lid Open");
6836 reportUserInput();
6837 }
6838
6839 // Tell PMCPU
6840 informCPUStateChange(kInformLid, 0);
6841
6842 // Tell general interest clients
6843 sendClientClamshellNotification();
6844
6845 bool aborting = ((lastSleepReason == kIOPMSleepReasonClamshell)
6846 || (lastSleepReason == kIOPMSleepReasonIdle)
6847 || (lastSleepReason == kIOPMSleepReasonMaintenance));
6848 if (aborting) userActivityCount++;
6849 DLOG("clamshell tickled %d lastSleepReason %d\n", userActivityCount, lastSleepReason);
6850 }
6851
6852 /*
6853 * Clamshell CLOSED
6854 * Send the clamshell interest notification since the lid is closing.
6855 */
6856 if (msg & kIOPMClamshellClosed)
6857 {
6858 if (clamshellClosed && clamshellExists) {
6859 DLOG("Ignoring redundant Clamshell close event\n");
6860 }
6861 else {
6862 DLOG("Clamshell closed\n");
6863 // Received clamshel open message from clamshell controlling driver
6864 // Update our internal state and tell general interest clients
6865 clamshellClosed = true;
6866 clamshellExists = true;
6867
6868 // Tell PMCPU
6869 informCPUStateChange(kInformLid, 1);
6870
6871 // Tell general interest clients
6872 sendClientClamshellNotification();
6873
6874 // And set eval_clamshell = so we can attempt
6875 eval_clamshell = true;
6876 }
6877 }
6878
6879 /*
6880 * Set Desktop mode (sent from graphics)
6881 *
6882 * -> reevaluate lid state
6883 */
6884 if (msg & kIOPMSetDesktopMode)
6885 {
6886 DLOG("Desktop mode\n");
6887 desktopMode = (0 != (msg & kIOPMSetValue));
6888 msg &= ~(kIOPMSetDesktopMode | kIOPMSetValue);
6889
6890 sendClientClamshellNotification();
6891
6892 // Re-evaluate the lid state
6893 eval_clamshell = true;
6894 }
6895
6896 /*
6897 * AC Adaptor connected
6898 *
6899 * -> reevaluate lid state
6900 */
6901 if (msg & kIOPMSetACAdaptorConnected)
6902 {
6903 acAdaptorConnected = (0 != (msg & kIOPMSetValue));
6904 msg &= ~(kIOPMSetACAdaptorConnected | kIOPMSetValue);
6905
6906 // Tell CPU PM
6907 informCPUStateChange(kInformAC, !acAdaptorConnected);
6908
6909 // Tell BSD if AC is connected
6910 // 0 == external power source; 1 == on battery
6911 post_sys_powersource(acAdaptorConnected ? 0:1);
6912
6913 sendClientClamshellNotification();
6914
6915 // Re-evaluate the lid state
6916 eval_clamshell = true;
6917
6918 // Lack of AC may have latched a display wrangler tickle.
6919 // This mirrors the hardware's USB wake event latch, where a latched
6920 // USB wake event followed by an AC attach will trigger a full wake.
6921 latchDisplayWranglerTickle( false );
6922
6923 #if HIBERNATION
6924 // AC presence will reset the standy timer delay adjustment.
6925 _standbyTimerResetSeconds = 0;
6926 #endif
6927 if (!userIsActive) {
6928 // Reset userActivityTime when power supply is changed(rdr 13789330)
6929 clock_get_uptime(&userActivityTime);
6930 }
6931 }
6932
6933 /*
6934 * Enable Clamshell (external display disappear)
6935 *
6936 * -> reevaluate lid state
6937 */
6938 if (msg & kIOPMEnableClamshell)
6939 {
6940 DLOG("Clamshell enabled\n");
6941 // Re-evaluate the lid state
6942 // System should sleep on external display disappearance
6943 // in lid closed operation.
6944 if (true == clamshellDisabled)
6945 {
6946 eval_clamshell = true;
6947 }
6948
6949 clamshellDisabled = false;
6950 sendClientClamshellNotification();
6951 }
6952
6953 /*
6954 * Disable Clamshell (external display appeared)
6955 * We don't bother re-evaluating clamshell state. If the system is awake,
6956 * the lid is probably open.
6957 */
6958 if (msg & kIOPMDisableClamshell)
6959 {
6960 DLOG("Clamshell disabled\n");
6961 clamshellDisabled = true;
6962 sendClientClamshellNotification();
6963 }
6964
6965 /*
6966 * Evaluate clamshell and SLEEP if appropiate
6967 */
6968 if (eval_clamshell && clamshellClosed)
6969 {
6970 if (shouldSleepOnClamshellClosed())
6971 privateSleepSystem (kIOPMSleepReasonClamshell);
6972 else
6973 evaluatePolicy( kStimulusDarkWakeEvaluate );
6974 }
6975
6976 /*
6977 * Power Button
6978 */
6979 if (msg & kIOPMPowerButton)
6980 {
6981 DLOG("Powerbutton press\n");
6982 if (!wranglerAsleep)
6983 {
6984 OSString *pbs = OSString::withCString("DisablePowerButtonSleep");
6985 // Check that power button sleep is enabled
6986 if( pbs ) {
6987 if( kOSBooleanTrue != getProperty(pbs))
6988 privateSleepSystem (kIOPMSleepReasonPowerButton);
6989 }
6990 }
6991 else
6992 reportUserInput();
6993 }
6994 }
6995
6996 //******************************************************************************
6997 // evaluatePolicy
6998 //
6999 // Evaluate root-domain policy in response to external changes.
7000 //******************************************************************************
7001
7002 void IOPMrootDomain::evaluatePolicy( int stimulus, uint32_t arg )
7003 {
7004 union {
7005 struct {
7006 int idleSleepEnabled : 1;
7007 int idleSleepDisabled : 1;
7008 int displaySleep : 1;
7009 int sleepDelayChanged : 1;
7010 int evaluateDarkWake : 1;
7011 int adjustPowerState : 1;
7012 int userBecameInactive : 1;
7013 } bit;
7014 uint32_t u32;
7015 } flags;
7016
7017
7018 ASSERT_GATED();
7019 flags.u32 = 0;
7020
7021 switch (stimulus)
7022 {
7023 case kStimulusDisplayWranglerSleep:
7024 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7025 if (!wranglerAsleep)
7026 {
7027 // first transition to wrangler sleep or lower
7028 flags.bit.displaySleep = true;
7029 }
7030 break;
7031
7032 case kStimulusDisplayWranglerWake:
7033 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7034 displayIdleForDemandSleep = false;
7035 wranglerAsleep = false;
7036 break;
7037
7038 case kStimulusEnterUserActiveState:
7039 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7040 if (_preventUserActive)
7041 {
7042 DLOG("user active dropped\n");
7043 break;
7044 }
7045 if (!userIsActive)
7046 {
7047 userIsActive = true;
7048 userWasActive = true;
7049 clock_get_uptime(&gUserActiveAbsTime);
7050
7051 // Stay awake after dropping demand for display power on
7052 if (kFullWakeReasonDisplayOn == fullWakeReason) {
7053 fullWakeReason = fFullWakeReasonDisplayOnAndLocalUser;
7054 DLOG("User activity while in notification wake\n");
7055 changePowerStateWithOverrideTo( ON_STATE, 0);
7056 }
7057
7058 kdebugTrace(kPMLogUserActiveState, 0, 1, 0);
7059 setProperty(gIOPMUserIsActiveKey, kOSBooleanTrue);
7060 messageClients(kIOPMMessageUserIsActiveChanged);
7061 }
7062 flags.bit.idleSleepDisabled = true;
7063 break;
7064
7065 case kStimulusLeaveUserActiveState:
7066 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7067 if (userIsActive)
7068 {
7069 clock_get_uptime(&gUserInactiveAbsTime);
7070 userIsActive = false;
7071 clock_get_uptime(&userBecameInactiveTime);
7072 flags.bit.userBecameInactive = true;
7073
7074 kdebugTrace(kPMLogUserActiveState, 0, 0, 0);
7075 setProperty(gIOPMUserIsActiveKey, kOSBooleanFalse);
7076 messageClients(kIOPMMessageUserIsActiveChanged);
7077 }
7078 break;
7079
7080 case kStimulusAggressivenessChanged:
7081 {
7082 DMSG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7083 unsigned long minutesToIdleSleep = 0;
7084 unsigned long minutesToDisplayDim = 0;
7085 unsigned long minutesDelta = 0;
7086
7087 // Fetch latest display and system sleep slider values.
7088 getAggressiveness(kPMMinutesToSleep, &minutesToIdleSleep);
7089 getAggressiveness(kPMMinutesToDim, &minutesToDisplayDim);
7090 DLOG("aggressiveness changed: system %u->%u, display %u\n",
7091 (uint32_t) sleepSlider,
7092 (uint32_t) minutesToIdleSleep,
7093 (uint32_t) minutesToDisplayDim);
7094
7095 DLOG("idle time -> %ld secs (ena %d)\n",
7096 idleSeconds, (minutesToIdleSleep != 0));
7097
7098
7099 // How long to wait before sleeping the system once
7100 // the displays turns off is indicated by 'extraSleepDelay'.
7101
7102 if ( minutesToIdleSleep > minutesToDisplayDim )
7103 minutesDelta = minutesToIdleSleep - minutesToDisplayDim;
7104 else if ( minutesToIdleSleep == minutesToDisplayDim )
7105 minutesDelta = 1;
7106
7107 if ((!idleSleepEnabled) && (minutesToIdleSleep != 0))
7108 idleSleepEnabled = flags.bit.idleSleepEnabled = true;
7109
7110 if ((idleSleepEnabled) && (minutesToIdleSleep == 0)) {
7111 flags.bit.idleSleepDisabled = true;
7112 idleSleepEnabled = false;
7113 }
7114 if (0x7fffffff == minutesToIdleSleep)
7115 minutesToIdleSleep = idleSeconds;
7116
7117 if (((minutesDelta != extraSleepDelay) ||
7118 (userActivityTime != userActivityTime_prev)) &&
7119 !flags.bit.idleSleepEnabled && !flags.bit.idleSleepDisabled)
7120 flags.bit.sleepDelayChanged = true;
7121
7122 if (systemDarkWake && !darkWakeToSleepASAP &&
7123 (flags.bit.idleSleepEnabled || flags.bit.idleSleepDisabled))
7124 {
7125 // Reconsider decision to remain in dark wake
7126 flags.bit.evaluateDarkWake = true;
7127 }
7128
7129 sleepSlider = minutesToIdleSleep;
7130 extraSleepDelay = minutesDelta;
7131 userActivityTime_prev = userActivityTime;
7132 } break;
7133
7134 case kStimulusDemandSystemSleep:
7135 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7136 displayIdleForDemandSleep = true;
7137 if (wrangler && wranglerIdleSettings)
7138 {
7139 // Request wrangler idle only when demand sleep is triggered
7140 // from full wake.
7141 if(CAP_CURRENT(kIOPMSystemCapabilityGraphics))
7142 {
7143 wrangler->setProperties(wranglerIdleSettings);
7144 DLOG("Requested wrangler idle\n");
7145 }
7146 }
7147 // arg = sleepReason
7148 changePowerStateWithOverrideTo( SLEEP_STATE, arg );
7149 break;
7150
7151 case kStimulusAllowSystemSleepChanged:
7152 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7153 flags.bit.adjustPowerState = true;
7154 break;
7155
7156 case kStimulusDarkWakeActivityTickle:
7157 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7158 // arg == true implies real and not self generated wrangler tickle.
7159 // Update wake type on PM work loop instead of the tickle thread to
7160 // eliminate the possibility of an early tickle clobbering the wake
7161 // type set by the platform driver.
7162 if (arg == true)
7163 setProperty(kIOPMRootDomainWakeTypeKey, kIOPMRootDomainWakeTypeHIDActivity);
7164
7165 if (false == wranglerTickled)
7166 {
7167 if (latchDisplayWranglerTickle(true))
7168 {
7169 DLOG("latched tickle\n");
7170 break;
7171 }
7172
7173 wranglerTickled = true;
7174 DLOG("Requesting full wake after dark wake activity tickle\n");
7175 requestFullWake( kFullWakeReasonLocalUser );
7176 }
7177 break;
7178
7179 case kStimulusDarkWakeEntry:
7180 case kStimulusDarkWakeReentry:
7181 DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7182 // Any system transitions since the last dark wake transition
7183 // will invalid the stimulus.
7184
7185 if (arg == _systemStateGeneration)
7186 {
7187 DLOG("dark wake entry\n");
7188 systemDarkWake = true;
7189
7190 // Keep wranglerAsleep an invariant when wrangler is absent
7191 if (wrangler)
7192 wranglerAsleep = true;
7193
7194 if (kStimulusDarkWakeEntry == stimulus)
7195 {
7196 clock_get_uptime(&userBecameInactiveTime);
7197 flags.bit.evaluateDarkWake = true;
7198 if (activitySinceSleep()) {
7199 DLOG("User activity recorded while going to darkwake\n");
7200 reportUserInput();
7201 }
7202 }
7203
7204 // Always accelerate disk spindown while in dark wake,
7205 // even if system does not support/allow sleep.
7206
7207 cancelIdleSleepTimer();
7208 setQuickSpinDownTimeout();
7209 }
7210 break;
7211
7212 case kStimulusDarkWakeEvaluate:
7213 DMSG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7214 if (systemDarkWake)
7215 {
7216 flags.bit.evaluateDarkWake = true;
7217 }
7218 break;
7219
7220 case kStimulusNoIdleSleepPreventers:
7221 DMSG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
7222 flags.bit.adjustPowerState = true;
7223 break;
7224
7225 } /* switch(stimulus) */
7226
7227 if (flags.bit.evaluateDarkWake && (kFullWakeReasonNone == fullWakeReason))
7228 {
7229 if (darkWakeToSleepASAP ||
7230 (clamshellClosed && !(desktopMode && acAdaptorConnected)))
7231 {
7232 uint32_t newSleepReason;
7233
7234 if (CAP_HIGHEST(kIOPMSystemCapabilityGraphics))
7235 {
7236 // System was previously in full wake. Sleep reason from
7237 // full to dark already recorded in fullToDarkReason.
7238
7239 if (lowBatteryCondition)
7240 newSleepReason = kIOPMSleepReasonLowPower;
7241 else
7242 newSleepReason = fullToDarkReason;
7243 }
7244 else
7245 {
7246 // In dark wake from system sleep.
7247
7248 if (darkWakeSleepService)
7249 newSleepReason = kIOPMSleepReasonSleepServiceExit;
7250 else
7251 newSleepReason = kIOPMSleepReasonMaintenance;
7252 }
7253
7254 if (checkSystemCanSleep(newSleepReason))
7255 {
7256 privateSleepSystem(newSleepReason);
7257 }
7258 }
7259 else // non-maintenance (network) dark wake
7260 {
7261 if (checkSystemCanSleep(kIOPMSleepReasonIdle))
7262 {
7263 // Release power clamp, and wait for children idle.
7264 adjustPowerState(true);
7265 }
7266 else
7267 {
7268 changePowerStateToPriv(ON_STATE);
7269 }
7270 }
7271 }
7272
7273 if (systemDarkWake)
7274 {
7275 // The rest are irrelevant while system is in dark wake.
7276 flags.u32 = 0;
7277 }
7278
7279 if ((flags.bit.displaySleep) &&
7280 (kFullWakeReasonDisplayOn == fullWakeReason))
7281 {
7282 // kIOPMSleepReasonMaintenance?
7283 DLOG("Display sleep while in notification wake\n");
7284 changePowerStateWithOverrideTo( SLEEP_STATE, kIOPMSleepReasonMaintenance );
7285 }
7286
7287 if (flags.bit.userBecameInactive || flags.bit.sleepDelayChanged)
7288 {
7289 bool cancelQuickSpindown = false;
7290
7291 if (flags.bit.sleepDelayChanged)
7292 {
7293 // Cancel existing idle sleep timer and quick disk spindown.
7294 // New settings will be applied by the idleSleepEnabled flag
7295 // handler below if idle sleep is enabled.
7296
7297 DLOG("extra sleep timer changed\n");
7298 cancelIdleSleepTimer();
7299 cancelQuickSpindown = true;
7300 }
7301 else
7302 {
7303 DLOG("user inactive\n");
7304 }
7305
7306 if (!userIsActive && idleSleepEnabled)
7307 {
7308 startIdleSleepTimer(getTimeToIdleSleep());
7309 }
7310
7311 if (cancelQuickSpindown)
7312 restoreUserSpinDownTimeout();
7313 }
7314
7315 if (flags.bit.idleSleepEnabled)
7316 {
7317 DLOG("idle sleep timer enabled\n");
7318 if (!wrangler)
7319 {
7320 changePowerStateToPriv(ON_STATE);
7321 startIdleSleepTimer( idleSeconds );
7322 }
7323 else
7324 {
7325 // Start idle timer if prefs now allow system sleep
7326 // and user is already inactive. Disk spindown is
7327 // accelerated upon timer expiration.
7328
7329 if (!userIsActive)
7330 {
7331 startIdleSleepTimer(getTimeToIdleSleep());
7332 }
7333 }
7334 }
7335
7336 if (flags.bit.idleSleepDisabled)
7337 {
7338 DLOG("idle sleep timer disabled\n");
7339 cancelIdleSleepTimer();
7340 restoreUserSpinDownTimeout();
7341 adjustPowerState();
7342 }
7343
7344 if (flags.bit.adjustPowerState)
7345 {
7346 bool sleepASAP = false;
7347
7348 if (!systemBooting && (preventIdleSleepList->getCount() == 0))
7349 {
7350 if (!wrangler)
7351 {
7352 changePowerStateToPriv(ON_STATE);
7353 if (idleSleepEnabled)
7354 {
7355 // stay awake for at least idleSeconds
7356 startIdleSleepTimer(idleSeconds);
7357 }
7358 }
7359 else if (!extraSleepDelay && !idleSleepTimerPending && !systemDarkWake)
7360 {
7361 sleepASAP = true;
7362 }
7363 }
7364
7365 adjustPowerState(sleepASAP);
7366 }
7367 }
7368
7369 //******************************************************************************
7370 // requestFullWake
7371 //
7372 // Request transition from dark wake to full wake
7373 //******************************************************************************
7374
7375 void IOPMrootDomain::requestFullWake( FullWakeReason reason )
7376 {
7377 uint32_t options = 0;
7378 IOService * pciRoot = 0;
7379 bool promotion = false;
7380
7381 // System must be in dark wake and a valid reason for entering full wake
7382 if ((kFullWakeReasonNone == reason) ||
7383 (kFullWakeReasonNone != fullWakeReason) ||
7384 (CAP_CURRENT(kIOPMSystemCapabilityGraphics)))
7385 {
7386 return;
7387 }
7388
7389 // Will clear reason upon exit from full wake
7390 fullWakeReason = reason;
7391
7392 _desiredCapability |= (kIOPMSystemCapabilityGraphics |
7393 kIOPMSystemCapabilityAudio);
7394
7395 if ((kSystemTransitionWake == _systemTransitionType) &&
7396 !(_pendingCapability & kIOPMSystemCapabilityGraphics) &&
7397 !graphicsSuppressed)
7398 {
7399 // Promote to full wake while waking up to dark wake due to tickle.
7400 // PM will hold off notifying the graphics subsystem about system wake
7401 // as late as possible, so if a HID tickle does arrive, graphics can
7402 // power up on this same wake cycle. The latency to power up graphics
7403 // on the next cycle can be huge on some systems. However, once any
7404 // graphics suppression has taken effect, it is too late. All other
7405 // graphics devices must be similarly suppressed. But the delay till
7406 // the following cycle should be short.
7407
7408 _pendingCapability |= (kIOPMSystemCapabilityGraphics |
7409 kIOPMSystemCapabilityAudio);
7410
7411 // Immediately bring up audio and graphics
7412 pciRoot = pciHostBridgeDriver;
7413 willEnterFullWake();
7414 promotion = true;
7415 }
7416
7417 // Unsafe to cancel once graphics was powered.
7418 // If system woke from dark wake, the return to sleep can
7419 // be cancelled. "awake -> dark -> sleep" transition
7420 // can be canceled also, during the "dark --> sleep" phase
7421 // *prior* to driver power down.
7422 if (!CAP_HIGHEST(kIOPMSystemCapabilityGraphics) ||
7423 _pendingCapability == 0) {
7424 options |= kIOPMSyncCancelPowerDown;
7425 }
7426
7427 synchronizePowerTree(options, pciRoot);
7428 if (kFullWakeReasonLocalUser == fullWakeReason)
7429 {
7430 // IOGraphics doesn't light the display even though graphics is
7431 // enabled in kIOMessageSystemCapabilityChange message(radar 9502104)
7432 // So, do an explicit activity tickle
7433 if (wrangler)
7434 wrangler->activityTickle(0,0);
7435 }
7436
7437 // Log a timestamp for the initial full wake request.
7438 // System may not always honor this full wake request.
7439 if (!CAP_HIGHEST(kIOPMSystemCapabilityGraphics))
7440 {
7441 AbsoluteTime now;
7442 uint64_t nsec;
7443
7444 clock_get_uptime(&now);
7445 SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
7446 absolutetime_to_nanoseconds(now, &nsec);
7447 MSG("full wake %s (reason %u) %u ms\n",
7448 promotion ? "promotion" : "request",
7449 fullWakeReason, ((int)((nsec) / NSEC_PER_MSEC)));
7450 }
7451 }
7452
7453 //******************************************************************************
7454 // willEnterFullWake
7455 //
7456 // System will enter full wake from sleep, from dark wake, or from dark
7457 // wake promotion. This function aggregate things that are in common to
7458 // all three full wake transitions.
7459 //
7460 // Assumptions: fullWakeReason was updated
7461 //******************************************************************************
7462
7463 void IOPMrootDomain::willEnterFullWake( void )
7464 {
7465 hibernateRetry = false;
7466 sleepToStandby = false;
7467 standbyNixed = false;
7468 resetTimers = false;
7469 sleepTimerMaintenance = false;
7470
7471 _systemMessageClientMask = kSystemMessageClientPowerd |
7472 kSystemMessageClientLegacyApp;
7473
7474 if ((_highestCapability & kIOPMSystemCapabilityGraphics) == 0)
7475 {
7476 // Initial graphics full power
7477 _systemMessageClientMask |= kSystemMessageClientKernel;
7478
7479 // Set kIOPMUserTriggeredFullWakeKey before full wake for IOGraphics
7480 setProperty(gIOPMUserTriggeredFullWakeKey,
7481 (kFullWakeReasonLocalUser == fullWakeReason) ?
7482 kOSBooleanTrue : kOSBooleanFalse);
7483 }
7484 #if HIBERNATION
7485 IOHibernateSetWakeCapabilities(_pendingCapability);
7486 #endif
7487
7488 IOService::setAdvisoryTickleEnable( true );
7489 tellClients(kIOMessageSystemWillPowerOn);
7490 preventTransitionToUserActive(false);
7491 }
7492
7493 //******************************************************************************
7494 // fullWakeDelayedWork
7495 //
7496 // System has already entered full wake. Invoked by a delayed thread call.
7497 //******************************************************************************
7498
7499 void IOPMrootDomain::fullWakeDelayedWork( void )
7500 {
7501 #if DARK_TO_FULL_EVALUATE_CLAMSHELL
7502 // Not gated, don't modify state
7503 if ((kSystemTransitionNone == _systemTransitionType) &&
7504 CAP_CURRENT(kIOPMSystemCapabilityGraphics))
7505 {
7506 receivePowerNotification( kLocalEvalClamshellCommand );
7507 }
7508 #endif
7509 }
7510
7511 //******************************************************************************
7512 // evaluateAssertions
7513 //
7514 //******************************************************************************
7515 void IOPMrootDomain::evaluateAssertions(IOPMDriverAssertionType newAssertions, IOPMDriverAssertionType oldAssertions)
7516 {
7517 IOPMDriverAssertionType changedBits = newAssertions ^ oldAssertions;
7518
7519 messageClients(kIOPMMessageDriverAssertionsChanged);
7520
7521 if (changedBits & kIOPMDriverAssertionPreventDisplaySleepBit) {
7522
7523 if (wrangler) {
7524 bool value = (newAssertions & kIOPMDriverAssertionPreventDisplaySleepBit) ? true : false;
7525
7526 DLOG("wrangler->setIgnoreIdleTimer\(%d)\n", value);
7527 wrangler->setIgnoreIdleTimer( value );
7528 }
7529 }
7530
7531 if (changedBits & kIOPMDriverAssertionCPUBit) {
7532 evaluatePolicy(kStimulusDarkWakeEvaluate);
7533 if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
7534 AbsoluteTime now;
7535 clock_usec_t microsecs;
7536 clock_get_uptime(&now);
7537 SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
7538 absolutetime_to_microtime(now, &assertOnWakeSecs, &microsecs);
7539 if (assertOnWakeReport) {
7540 HISTREPORT_TALLYVALUE(assertOnWakeReport, (int64_t)assertOnWakeSecs);
7541 DLOG("Updated assertOnWake %lu\n", (unsigned long)assertOnWakeSecs);
7542 }
7543 }
7544 }
7545
7546 if (changedBits & kIOPMDriverAssertionReservedBit7) {
7547 bool value = (newAssertions & kIOPMDriverAssertionReservedBit7) ? true : false;
7548 if (value) {
7549 DLOG("Driver assertion ReservedBit7 raised. Legacy IO preventing sleep\n");
7550 updatePreventIdleSleepList(this, true);
7551 }
7552 else {
7553 DLOG("Driver assertion ReservedBit7 dropped\n");
7554 updatePreventIdleSleepList(this, false);
7555 }
7556 }
7557 }
7558
7559 // MARK: -
7560 // MARK: Statistics
7561
7562 //******************************************************************************
7563 // pmStats
7564 //
7565 //******************************************************************************
7566
7567 void IOPMrootDomain::pmStatsRecordEvent(
7568 int eventIndex,
7569 AbsoluteTime timestamp)
7570 {
7571 bool starting = eventIndex & kIOPMStatsEventStartFlag ? true:false;
7572 bool stopping = eventIndex & kIOPMStatsEventStopFlag ? true:false;
7573 uint64_t delta;
7574 uint64_t nsec;
7575 OSData *publishPMStats = NULL;
7576
7577 eventIndex &= ~(kIOPMStatsEventStartFlag | kIOPMStatsEventStopFlag);
7578
7579 absolutetime_to_nanoseconds(timestamp, &nsec);
7580
7581 switch (eventIndex) {
7582 case kIOPMStatsHibernateImageWrite:
7583 if (starting)
7584 gPMStats.hibWrite.start = nsec;
7585 else if (stopping)
7586 gPMStats.hibWrite.stop = nsec;
7587
7588 if (stopping) {
7589 delta = gPMStats.hibWrite.stop - gPMStats.hibWrite.start;
7590 IOLog("PMStats: Hibernate write took %qd ms\n", delta/NSEC_PER_MSEC);
7591 }
7592 break;
7593 case kIOPMStatsHibernateImageRead:
7594 if (starting)
7595 gPMStats.hibRead.start = nsec;
7596 else if (stopping)
7597 gPMStats.hibRead.stop = nsec;
7598
7599 if (stopping) {
7600 delta = gPMStats.hibRead.stop - gPMStats.hibRead.start;
7601 IOLog("PMStats: Hibernate read took %qd ms\n", delta/NSEC_PER_MSEC);
7602
7603 publishPMStats = OSData::withBytes(&gPMStats, sizeof(gPMStats));
7604 setProperty(kIOPMSleepStatisticsKey, publishPMStats);
7605 publishPMStats->release();
7606 bzero(&gPMStats, sizeof(gPMStats));
7607 }
7608 break;
7609 }
7610 }
7611
7612 /*
7613 * Appends a record of the application response to
7614 * IOPMrootDomain::pmStatsAppResponses
7615 */
7616 void IOPMrootDomain::pmStatsRecordApplicationResponse(
7617 const OSSymbol *response,
7618 const char *name,
7619 int messageType,
7620 uint32_t delay_ms,
7621 uint64_t id,
7622 OSObject *object,
7623 IOPMPowerStateIndex powerState)
7624 {
7625 OSDictionary *responseDescription = NULL;
7626 OSNumber *delayNum = NULL;
7627 OSNumber *powerCaps = NULL;
7628 OSNumber *pidNum = NULL;
7629 OSNumber *msgNum = NULL;
7630 const OSSymbol *appname;
7631 const OSSymbol *sleep = NULL, *wake = NULL;
7632 IOPMServiceInterestNotifier *notify = 0;
7633
7634 if (object && (notify = OSDynamicCast(IOPMServiceInterestNotifier, object)))
7635 {
7636 if (response->isEqualTo(gIOPMStatsResponseTimedOut))
7637 notify->ackTimeoutCnt++;
7638 else
7639 notify->ackTimeoutCnt = 0;
7640
7641 }
7642
7643 if (response->isEqualTo(gIOPMStatsResponsePrompt) ||
7644 (_systemTransitionType == kSystemTransitionNone) || (_systemTransitionType == kSystemTransitionNewCapClient))
7645 return;
7646
7647
7648 if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow)) {
7649 kdebugTrace(kPMLogDrvPSChangeDelay, id, messageType, delay_ms);
7650 }
7651 else if (notify) {
7652 // User space app or kernel capability client
7653 if (id) {
7654 kdebugTrace(kPMLogAppResponseDelay, id, notify->msgType, delay_ms);
7655 }
7656 else {
7657 kdebugTrace(kPMLogDrvResponseDelay, notify->uuid0, messageType, delay_ms);
7658 }
7659 notify->msgType = 0;
7660 }
7661
7662 responseDescription = OSDictionary::withCapacity(5);
7663 if (responseDescription)
7664 {
7665 if (response) {
7666 responseDescription->setObject(_statsResponseTypeKey, response);
7667 }
7668
7669 msgNum = OSNumber::withNumber(messageType, 32);
7670 if (msgNum) {
7671 responseDescription->setObject(_statsMessageTypeKey, msgNum);
7672 msgNum->release();
7673 }
7674
7675 if (!name && notify && notify->identifier) {
7676 name = notify->identifier->getCStringNoCopy();
7677 }
7678
7679 if (name && (strlen(name) > 0))
7680 {
7681 appname = OSSymbol::withCString(name);
7682 if (appname) {
7683 responseDescription->setObject(_statsNameKey, appname);
7684 appname->release();
7685 }
7686 }
7687
7688 if (!id && notify) {
7689 id = notify->uuid0;
7690 }
7691 if (id != 0) {
7692 pidNum = OSNumber::withNumber(id, 64);
7693 if (pidNum) {
7694 responseDescription->setObject(_statsPIDKey, pidNum);
7695 pidNum->release();
7696 }
7697 }
7698
7699 delayNum = OSNumber::withNumber(delay_ms, 32);
7700 if (delayNum) {
7701 responseDescription->setObject(_statsTimeMSKey, delayNum);
7702 delayNum->release();
7703 }
7704
7705 if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow)) {
7706 powerCaps = OSNumber::withNumber(powerState, 32);
7707
7708 #if !defined(__i386__) && !defined(__x86_64__) && (DEVELOPMENT || DEBUG)
7709 IOLog("%s::powerStateChange type(%d) to(%lu) async took %d ms\n",
7710 name, messageType,
7711 powerState, delay_ms);
7712 #endif
7713
7714 }
7715 else {
7716 powerCaps = OSNumber::withNumber(_pendingCapability, 32);
7717 }
7718 if (powerCaps) {
7719 responseDescription->setObject(_statsPowerCapsKey, powerCaps);
7720 powerCaps->release();
7721 }
7722
7723 sleep = OSSymbol::withCString("Sleep");
7724 wake = OSSymbol::withCString("Wake");
7725 if (_systemTransitionType == kSystemTransitionSleep) {
7726 responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep);
7727 }
7728 else if (_systemTransitionType == kSystemTransitionWake) {
7729 responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake);
7730 }
7731 else if (_systemTransitionType == kSystemTransitionCapability) {
7732 if (CAP_LOSS(kIOPMSystemCapabilityGraphics))
7733 responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep);
7734 else if (CAP_GAIN(kIOPMSystemCapabilityGraphics))
7735 responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake);
7736 }
7737 if (sleep) sleep->release();
7738 if (wake) wake->release();
7739
7740
7741
7742 IOLockLock(pmStatsLock);
7743 if (pmStatsAppResponses && pmStatsAppResponses->getCount() < 50) {
7744 pmStatsAppResponses->setObject(responseDescription);
7745 }
7746 IOLockUnlock(pmStatsLock);
7747
7748 responseDescription->release();
7749 }
7750
7751 return;
7752 }
7753
7754 // MARK: -
7755 // MARK: PMTraceWorker
7756
7757 //******************************************************************************
7758 // TracePoint support
7759 //
7760 //******************************************************************************
7761
7762 #define kIOPMRegisterNVRAMTracePointHandlerKey \
7763 "IOPMRegisterNVRAMTracePointHandler"
7764
7765 IOReturn IOPMrootDomain::callPlatformFunction(
7766 const OSSymbol * functionName,
7767 bool waitForFunction,
7768 void * param1, void * param2,
7769 void * param3, void * param4 )
7770 {
7771 uint32_t bootFailureCode = 0xffffffff;
7772 if (pmTracer && functionName &&
7773 functionName->isEqualTo(kIOPMRegisterNVRAMTracePointHandlerKey) &&
7774 !pmTracer->tracePointHandler && !pmTracer->tracePointTarget)
7775 {
7776 uint32_t tracePointPhases, tracePointPCI;
7777 uint64_t statusCode;
7778
7779 pmTracer->tracePointHandler = (IOPMTracePointHandler) param1;
7780 pmTracer->tracePointTarget = (void *) param2;
7781 tracePointPCI = (uint32_t)(uintptr_t) param3;
7782 tracePointPhases = (uint32_t)(uintptr_t) param4;
7783 if ((tracePointPhases & 0xff) == kIOPMTracePointSystemSleep) {
7784
7785 IORegistryEntry *node = IORegistryEntry::fromPath( "/chosen", gIODTPlane );
7786 if ( node ) {
7787 OSData *data = OSDynamicCast( OSData, node->getProperty(kIOEFIBootRomFailureKey) );
7788 if ( data && data->getLength() == sizeof(bootFailureCode) ) {
7789 memcpy(&bootFailureCode, data->getBytesNoCopy(), sizeof(bootFailureCode));
7790 }
7791 node->release();
7792 }
7793 // Failure code from EFI/BootRom is a four byte structure
7794 tracePointPCI = OSSwapBigToHostInt32(bootFailureCode);
7795 }
7796 statusCode = (((uint64_t)tracePointPCI) << 32) | tracePointPhases;
7797 if ((tracePointPhases & 0xff) != kIOPMTracePointSystemUp) {
7798 MSG("Sleep failure code 0x%08x 0x%08x\n",
7799 tracePointPCI, tracePointPhases);
7800 }
7801 setProperty(kIOPMSleepWakeFailureCodeKey, statusCode, 64);
7802 pmTracer->tracePointHandler( pmTracer->tracePointTarget, 0, 0 );
7803
7804 return kIOReturnSuccess;
7805 }
7806 #if HIBERNATION
7807 else if (functionName &&
7808 functionName->isEqualTo(kIOPMInstallSystemSleepPolicyHandlerKey))
7809 {
7810 if (gSleepPolicyHandler)
7811 return kIOReturnExclusiveAccess;
7812 if (!param1)
7813 return kIOReturnBadArgument;
7814 gSleepPolicyHandler = (IOPMSystemSleepPolicyHandler) param1;
7815 gSleepPolicyTarget = (void *) param2;
7816 setProperty("IOPMSystemSleepPolicyHandler", kOSBooleanTrue);
7817 return kIOReturnSuccess;
7818 }
7819 #endif
7820
7821 return super::callPlatformFunction(
7822 functionName, waitForFunction, param1, param2, param3, param4);
7823 }
7824
7825 void IOPMrootDomain::kdebugTrace(uint32_t event, uint64_t id,
7826 uintptr_t param1, uintptr_t param2, uintptr_t param3)
7827 {
7828 uint32_t code = IODBG_POWER(event);
7829 uint64_t regId = id;
7830 if (regId == 0) {
7831 regId = getRegistryEntryID();
7832 }
7833 IOTimeStampConstant(code, (uintptr_t) regId, param1, param2, param3);
7834 }
7835
7836
7837 void IOPMrootDomain::tracePoint( uint8_t point )
7838 {
7839 if (systemBooting) return;
7840
7841 if (kIOPMTracePointWakeCapabilityClients == point)
7842 acceptSystemWakeEvents(false);
7843
7844 kdebugTrace(kPMLogSleepWakeTracePoint, 0, point, 0);
7845 pmTracer->tracePoint(point);
7846 }
7847
7848 void IOPMrootDomain::traceDetail(OSObject *object, bool start)
7849 {
7850 IOPMServiceInterestNotifier *notifier;
7851
7852 if (systemBooting) {
7853 return;
7854 }
7855
7856 notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
7857 if (!notifier) {
7858 return;
7859 }
7860
7861 if (start) {
7862 pmTracer->traceDetail( notifier->uuid0 >> 32 );
7863 kdebugTrace(kPMLogSleepWakeMessage, pmTracer->getTracePhase(), notifier->msgType, notifier->uuid0, notifier->uuid1);
7864 if (notifier->identifier) {
7865 DLOG("trace point 0x%02x msg 0x%x to %s\n", pmTracer->getTracePhase(), notifier->msgType,
7866 notifier->identifier->getCStringNoCopy());
7867 }
7868 else {
7869 DLOG("trace point 0x%02x msg 0x%x\n", pmTracer->getTracePhase(), notifier->msgType);
7870 }
7871 notifierThread = current_thread();
7872 notifierObject = notifier;
7873 notifier->retain();
7874 }
7875 else {
7876 notifierThread = NULL;
7877 notifierObject = NULL;
7878 notifier->release();
7879 }
7880 }
7881
7882
7883 void IOPMrootDomain::traceAckDelay(OSObject *object, uint32_t response, uint32_t delay_ms)
7884 {
7885 IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
7886 if (!notifier) {
7887 DLOG("Unknown notifier\n");
7888 return;
7889 }
7890
7891 if (!systemBooting) {
7892 kdebugTrace(kPMLogDrvResponseDelay, notifier->uuid0, notifier->uuid1, response, delay_ms);
7893 if (notifier->identifier) {
7894 DLOG("Response from %s took %d ms(response:%d)\n",
7895 notifier->identifier->getCStringNoCopy(), delay_ms, response);
7896 }
7897 else {
7898 DLOG("Response from kext UUID %llx-%llx took %d ms(response:%d)\n",
7899 notifier->uuid0, notifier->uuid1, delay_ms, response);
7900 }
7901 }
7902 }
7903
7904 void IOPMrootDomain::traceDetail(uint32_t msgType, uint32_t msgIndex, uint32_t delay)
7905 {
7906 if (!systemBooting) {
7907 uint32_t detail = ((msgType & 0xffff) << 16) | (delay & 0xffff);
7908 pmTracer->traceDetail( detail );
7909 kdebugTrace(kPMLogSleepWakeTracePoint, pmTracer->getTracePhase(), msgType, delay);
7910 DLOG("trace point 0x%02x msgType 0x%x detail 0x%08x\n", pmTracer->getTracePhase(), msgType, delay);
7911 }
7912 }
7913
7914
7915 void IOPMrootDomain::configureReportGated(uint64_t channel_id, uint64_t action, void *result)
7916 {
7917 size_t reportSize;
7918 void **report = NULL;
7919 uint32_t bktCnt;
7920 uint32_t bktSize;
7921 uint32_t *clientCnt;
7922
7923 ASSERT_GATED();
7924
7925 report = NULL;
7926 if (channel_id == kAssertDelayChID) {
7927 report = &assertOnWakeReport;
7928 bktCnt = kAssertDelayBcktCnt;
7929 bktSize = kAssertDelayBcktSize;
7930 clientCnt = &assertOnWakeClientCnt;
7931 }
7932 else if (channel_id == kSleepDelaysChID) {
7933 report = &sleepDelaysReport;
7934 bktCnt = kSleepDelaysBcktCnt;
7935 bktSize = kSleepDelaysBcktSize;
7936 clientCnt = &sleepDelaysClientCnt;
7937 }
7938
7939 switch (action)
7940 {
7941 case kIOReportEnable:
7942
7943 if (*report) {
7944 (*clientCnt)++;
7945 break;
7946 }
7947
7948 reportSize = HISTREPORT_BUFSIZE(bktCnt);
7949 *report = IOMalloc(reportSize);
7950 if (*report == NULL) {
7951 break;
7952 }
7953 bzero(*report, reportSize);
7954 HISTREPORT_INIT(bktCnt, bktSize, *report, reportSize,
7955 getRegistryEntryID(), channel_id, kIOReportCategoryPower);
7956
7957 if (channel_id == kAssertDelayChID)
7958 assertOnWakeSecs = 0;
7959
7960 break;
7961
7962 case kIOReportDisable:
7963 if (*clientCnt == 0) {
7964 break;
7965 }
7966 if (*clientCnt == 1)
7967 {
7968 IOFree(*report, HISTREPORT_BUFSIZE(bktCnt));
7969 *report = NULL;
7970 }
7971 (*clientCnt)--;
7972
7973 if (channel_id == kAssertDelayChID)
7974 assertOnWakeSecs = -1; // Invalid value to prevent updates
7975
7976 break;
7977
7978 case kIOReportGetDimensions:
7979 if (*report) {
7980 HISTREPORT_UPDATERES(*report, kIOReportGetDimensions, result);
7981 }
7982 break;
7983 }
7984
7985 return;
7986 }
7987
7988 IOReturn IOPMrootDomain::configureReport(IOReportChannelList *channelList,
7989 IOReportConfigureAction action,
7990 void *result,
7991 void *destination)
7992 {
7993 unsigned cnt;
7994 uint64_t configAction = (uint64_t)action;
7995
7996 for (cnt = 0; cnt < channelList->nchannels; cnt++) {
7997 if ( (channelList->channels[cnt].channel_id == kSleepCntChID) ||
7998 (channelList->channels[cnt].channel_id == kDarkWkCntChID) ||
7999 (channelList->channels[cnt].channel_id == kUserWkCntChID) ) {
8000 if (action != kIOReportGetDimensions) continue;
8001 SIMPLEREPORT_UPDATERES(kIOReportGetDimensions, result);
8002 }
8003 else if ((channelList->channels[cnt].channel_id == kAssertDelayChID) ||
8004 (channelList->channels[cnt].channel_id == kSleepDelaysChID)) {
8005 gIOPMWorkLoop->runAction(
8006 OSMemberFunctionCast(IOWorkLoop::Action, this, &IOPMrootDomain::configureReportGated),
8007 (OSObject *)this, (void *)channelList->channels[cnt].channel_id,
8008 (void *)configAction, (void *)result);
8009 }
8010 }
8011
8012 return super::configureReport(channelList, action, result, destination);
8013 }
8014
8015 IOReturn IOPMrootDomain::updateReportGated(uint64_t ch_id, void *result, IOBufferMemoryDescriptor *dest)
8016 {
8017
8018 uint32_t size2cpy;
8019 void *data2cpy;
8020 void **report;
8021
8022 ASSERT_GATED();
8023
8024 report = NULL;
8025 if (ch_id == kAssertDelayChID) {
8026 report = &assertOnWakeReport;
8027 }
8028 else if (ch_id == kSleepDelaysChID) {
8029 report = &sleepDelaysReport;
8030 }
8031
8032 if (*report == NULL) {
8033 return kIOReturnNotOpen;
8034 }
8035
8036 HISTREPORT_UPDATEPREP(*report, data2cpy, size2cpy);
8037 if (size2cpy > (dest->getCapacity() - dest->getLength()) ) {
8038 return kIOReturnOverrun;
8039 }
8040
8041 HISTREPORT_UPDATERES(*report, kIOReportCopyChannelData, result);
8042 dest->appendBytes(data2cpy, size2cpy);
8043
8044 return kIOReturnSuccess;
8045 }
8046
8047 IOReturn IOPMrootDomain::updateReport(IOReportChannelList *channelList,
8048 IOReportUpdateAction action,
8049 void *result,
8050 void *destination)
8051 {
8052 uint32_t size2cpy;
8053 void *data2cpy;
8054 uint8_t buf[SIMPLEREPORT_BUFSIZE];
8055 IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
8056 unsigned cnt;
8057 uint64_t ch_id;
8058
8059 if (action != kIOReportCopyChannelData) goto exit;
8060
8061 for (cnt = 0; cnt < channelList->nchannels; cnt++) {
8062 ch_id = channelList->channels[cnt].channel_id ;
8063
8064 if ((ch_id == kAssertDelayChID) || (ch_id == kSleepDelaysChID)) {
8065 gIOPMWorkLoop->runAction(
8066 OSMemberFunctionCast(IOWorkLoop::Action, this, &IOPMrootDomain::updateReportGated),
8067 (OSObject *)this, (void *)ch_id,
8068 (void *)result, (void *)dest);
8069 continue;
8070
8071 }
8072 else if ((ch_id == kSleepCntChID) ||
8073 (ch_id == kDarkWkCntChID) || (ch_id == kUserWkCntChID)) {
8074 SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), ch_id, kIOReportCategoryPower);
8075 }
8076 else continue;
8077
8078 if (ch_id == kSleepCntChID)
8079 SIMPLEREPORT_SETVALUE(buf, sleepCnt);
8080 else if (ch_id == kDarkWkCntChID)
8081 SIMPLEREPORT_SETVALUE(buf, darkWakeCnt);
8082 else if (ch_id == kUserWkCntChID)
8083 SIMPLEREPORT_SETVALUE(buf, displayWakeCnt);
8084
8085 SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy);
8086 SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);
8087 dest->appendBytes(data2cpy, size2cpy);
8088 }
8089
8090 exit:
8091 return super::updateReport(channelList, action, result, destination);
8092 }
8093
8094
8095 //******************************************************************************
8096 // PMTraceWorker Class
8097 //
8098 //******************************************************************************
8099
8100 #undef super
8101 #define super OSObject
8102 OSDefineMetaClassAndStructors(PMTraceWorker, OSObject)
8103
8104 #define kPMBestGuessPCIDevicesCount 25
8105 #define kPMMaxRTCBitfieldSize 32
8106
8107 PMTraceWorker *PMTraceWorker::tracer(IOPMrootDomain *owner)
8108 {
8109 PMTraceWorker *me;
8110
8111 me = OSTypeAlloc( PMTraceWorker );
8112 if (!me || !me->init())
8113 {
8114 return NULL;
8115 }
8116
8117 DLOG("PMTraceWorker %p\n", OBFUSCATE(me));
8118
8119 // Note that we cannot instantiate the PCI device -> bit mappings here, since
8120 // the IODeviceTree has not yet been created by IOPlatformExpert. We create
8121 // this dictionary lazily.
8122 me->owner = owner;
8123 me->pciDeviceBitMappings = NULL;
8124 me->pmTraceWorkerLock = IOLockAlloc();
8125 me->tracePhase = kIOPMTracePointSystemUp;
8126 me->traceData32 = 0;
8127 me->loginWindowData = 0;
8128 me->coreDisplayData = 0;
8129 me->coreGraphicsData = 0;
8130 return me;
8131 }
8132
8133 void PMTraceWorker::RTC_TRACE(void)
8134 {
8135 if (tracePointHandler && tracePointTarget)
8136 {
8137 uint32_t wordA;
8138
8139 IOLockLock(pmTraceWorkerLock);
8140 wordA = (loginWindowData << 24) | (coreDisplayData << 16) |
8141 (coreGraphicsData << 8) | tracePhase;
8142 IOLockUnlock(pmTraceWorkerLock);
8143
8144 tracePointHandler( tracePointTarget, traceData32, wordA );
8145 _LOG("RTC_TRACE wrote 0x%08x 0x%08x\n", traceData32, wordA);
8146 }
8147 }
8148
8149 int PMTraceWorker::recordTopLevelPCIDevice(IOService * pciDevice)
8150 {
8151 const OSSymbol * deviceName;
8152 int index = -1;
8153
8154 IOLockLock(pmTraceWorkerLock);
8155
8156 if (!pciDeviceBitMappings)
8157 {
8158 pciDeviceBitMappings = OSArray::withCapacity(kPMBestGuessPCIDevicesCount);
8159 if (!pciDeviceBitMappings)
8160 goto exit;
8161 }
8162
8163 // Check for bitmask overflow.
8164 if (pciDeviceBitMappings->getCount() >= kPMMaxRTCBitfieldSize)
8165 goto exit;
8166
8167 if ((deviceName = pciDevice->copyName()) &&
8168 (pciDeviceBitMappings->getNextIndexOfObject(deviceName, 0) == (unsigned int)-1) &&
8169 pciDeviceBitMappings->setObject(deviceName))
8170 {
8171 index = pciDeviceBitMappings->getCount() - 1;
8172 _LOG("PMTrace PCI array: set object %s => %d\n",
8173 deviceName->getCStringNoCopy(), index);
8174 }
8175 if (deviceName)
8176 deviceName->release();
8177 if (!addedToRegistry && (index >= 0))
8178 addedToRegistry = owner->setProperty("PCITopLevel", this);
8179
8180 exit:
8181 IOLockUnlock(pmTraceWorkerLock);
8182 return index;
8183 }
8184
8185 bool PMTraceWorker::serialize(OSSerialize *s) const
8186 {
8187 bool ok = false;
8188 if (pciDeviceBitMappings)
8189 {
8190 IOLockLock(pmTraceWorkerLock);
8191 ok = pciDeviceBitMappings->serialize(s);
8192 IOLockUnlock(pmTraceWorkerLock);
8193 }
8194 return ok;
8195 }
8196
8197 void PMTraceWorker::tracePoint(uint8_t phase)
8198 {
8199 // clear trace detail when phase begins
8200 if (tracePhase != phase)
8201 traceData32 = 0;
8202
8203 tracePhase = phase;
8204
8205 DLOG("trace point 0x%02x\n", tracePhase);
8206 RTC_TRACE();
8207 }
8208
8209 void PMTraceWorker::traceDetail(uint32_t detail)
8210 {
8211 if (detail == traceData32) {
8212 return;
8213 }
8214 traceData32 = detail;
8215 RTC_TRACE();
8216 }
8217
8218 void PMTraceWorker::traceComponentWakeProgress(uint32_t component, uint32_t data)
8219 {
8220 switch (component) {
8221 case kIOPMLoginWindowProgress:
8222 loginWindowData = data & kIOPMLoginWindowProgressMask;
8223 break;
8224 case kIOPMCoreDisplayProgress:
8225 coreDisplayData = data & kIOPMCoreDisplayProgressMask;
8226 break;
8227 case kIOPMCoreGraphicsProgress:
8228 coreGraphicsData = data & kIOPMCoreGraphicsProgressMask;
8229 break;
8230 default:
8231 return;
8232 }
8233
8234 DLOG("component trace point 0x%02x data 0x%08x\n", component, data);
8235 RTC_TRACE();
8236 }
8237
8238 void PMTraceWorker::tracePCIPowerChange(
8239 change_t type, IOService *service, uint32_t changeFlags, uint32_t bitNum)
8240 {
8241 uint32_t bitMask;
8242 uint32_t expectedFlag;
8243
8244 // Ignore PCI changes outside of system sleep/wake.
8245 if ((kIOPMTracePointSleepPowerPlaneDrivers != tracePhase) &&
8246 (kIOPMTracePointWakePowerPlaneDrivers != tracePhase))
8247 return;
8248
8249 // Only record the WillChange transition when going to sleep,
8250 // and the DidChange on the way up.
8251 changeFlags &= (kIOPMDomainWillChange | kIOPMDomainDidChange);
8252 expectedFlag = (kIOPMTracePointSleepPowerPlaneDrivers == tracePhase) ?
8253 kIOPMDomainWillChange : kIOPMDomainDidChange;
8254 if (changeFlags != expectedFlag)
8255 return;
8256
8257 // Mark this device off in our bitfield
8258 if (bitNum < kPMMaxRTCBitfieldSize)
8259 {
8260 bitMask = (1 << bitNum);
8261
8262 if (kPowerChangeStart == type)
8263 {
8264 traceData32 |= bitMask;
8265 _LOG("PMTrace: Device %s started - bit %2d mask 0x%08x => 0x%08x\n",
8266 service->getName(), bitNum, bitMask, traceData32);
8267 owner->kdebugTrace(kPMLogPCIDevChangeStart, service->getRegistryEntryID(), traceData32, 0);
8268 }
8269 else
8270 {
8271 traceData32 &= ~bitMask;
8272 _LOG("PMTrace: Device %s finished - bit %2d mask 0x%08x => 0x%08x\n",
8273 service->getName(), bitNum, bitMask, traceData32);
8274 owner->kdebugTrace(kPMLogPCIDevChangeDone, service->getRegistryEntryID(), traceData32, 0);
8275 }
8276
8277 DLOG("trace point 0x%02x detail 0x%08x\n", tracePhase, traceData32);
8278 RTC_TRACE();
8279 }
8280 }
8281
8282 uint64_t PMTraceWorker::getPMStatusCode( )
8283 {
8284 return (((uint64_t)traceData32 << 32) | ((uint64_t)tracePhase));
8285
8286 }
8287
8288 uint8_t PMTraceWorker::getTracePhase()
8289 {
8290 return tracePhase;
8291 }
8292
8293 uint32_t PMTraceWorker::getTraceData()
8294 {
8295 return traceData32;
8296 }
8297
8298 // MARK: -
8299 // MARK: PMHaltWorker
8300
8301 //******************************************************************************
8302 // PMHaltWorker Class
8303 //
8304 //******************************************************************************
8305
8306 PMHaltWorker * PMHaltWorker::worker( void )
8307 {
8308 PMHaltWorker * me;
8309 IOThread thread;
8310
8311 do {
8312 me = OSTypeAlloc( PMHaltWorker );
8313 if (!me || !me->init())
8314 break;
8315
8316 me->lock = IOLockAlloc();
8317 if (!me->lock)
8318 break;
8319
8320 DLOG("PMHaltWorker %p\n", OBFUSCATE(me));
8321 me->retain(); // thread holds extra retain
8322 if (KERN_SUCCESS != kernel_thread_start(&PMHaltWorker::main, (void *) me, &thread))
8323 {
8324 me->release();
8325 break;
8326 }
8327 thread_deallocate(thread);
8328 return me;
8329
8330 } while (false);
8331
8332 if (me) me->release();
8333 return 0;
8334 }
8335
8336 void PMHaltWorker::free( void )
8337 {
8338 DLOG("PMHaltWorker free %p\n", OBFUSCATE(this));
8339 if (lock)
8340 {
8341 IOLockFree(lock);
8342 lock = 0;
8343 }
8344 return OSObject::free();
8345 }
8346
8347 void PMHaltWorker::main( void * arg, wait_result_t waitResult )
8348 {
8349 PMHaltWorker * me = (PMHaltWorker *) arg;
8350
8351 IOLockLock( gPMHaltLock );
8352 gPMHaltBusyCount++;
8353 me->depth = gPMHaltDepth;
8354 IOLockUnlock( gPMHaltLock );
8355
8356 while (me->depth >= 0)
8357 {
8358 PMHaltWorker::work( me );
8359
8360 IOLockLock( gPMHaltLock );
8361 if (++gPMHaltIdleCount >= gPMHaltBusyCount)
8362 {
8363 // This is the last thread to finish work on this level,
8364 // inform everyone to start working on next lower level.
8365 gPMHaltDepth--;
8366 me->depth = gPMHaltDepth;
8367 gPMHaltIdleCount = 0;
8368 thread_wakeup((event_t) &gPMHaltIdleCount);
8369 }
8370 else
8371 {
8372 // One or more threads are still working on this level,
8373 // this thread must wait.
8374 me->depth = gPMHaltDepth - 1;
8375 do {
8376 IOLockSleep(gPMHaltLock, &gPMHaltIdleCount, THREAD_UNINT);
8377 } while (me->depth != gPMHaltDepth);
8378 }
8379 IOLockUnlock( gPMHaltLock );
8380 }
8381
8382 // No more work to do, terminate thread
8383 DLOG("All done for worker: %p (visits = %u)\n", OBFUSCATE(me), me->visits);
8384 thread_wakeup( &gPMHaltDepth );
8385 me->release();
8386 }
8387
8388 void PMHaltWorker::work( PMHaltWorker * me )
8389 {
8390 IOService * service;
8391 OSSet * inner;
8392 AbsoluteTime startTime, elapsedTime;
8393 UInt32 deltaTime;
8394 bool timeout;
8395
8396 while (true)
8397 {
8398 service = 0;
8399 timeout = false;
8400
8401 // Claim an unit of work from the shared pool
8402 IOLockLock( gPMHaltLock );
8403 inner = (OSSet *)gPMHaltArray->getObject(me->depth);
8404 if (inner)
8405 {
8406 service = OSDynamicCast(IOService, inner->getAnyObject());
8407 if (service)
8408 {
8409 service->retain();
8410 inner->removeObject(service);
8411 }
8412 }
8413 IOLockUnlock( gPMHaltLock );
8414 if (!service)
8415 break; // no more work at this depth
8416
8417 clock_get_uptime(&startTime);
8418
8419 if (!service->isInactive() &&
8420 service->setProperty(gPMHaltClientAcknowledgeKey, me))
8421 {
8422 IOLockLock(me->lock);
8423 me->startTime = startTime;
8424 me->service = service;
8425 me->timeout = false;
8426 IOLockUnlock(me->lock);
8427
8428 service->systemWillShutdown( gPMHaltMessageType );
8429
8430 // Wait for driver acknowledgement
8431 IOLockLock(me->lock);
8432 while (service->getProperty(gPMHaltClientAcknowledgeKey))
8433 {
8434 IOLockSleep(me->lock, me, THREAD_UNINT);
8435 }
8436 me->service = 0;
8437 timeout = me->timeout;
8438 IOLockUnlock(me->lock);
8439 }
8440
8441 deltaTime = computeDeltaTimeMS(&startTime, &elapsedTime);
8442 if ((deltaTime > kPMHaltTimeoutMS) || timeout)
8443 {
8444 LOG("%s driver %s (0x%llx) took %u ms\n",
8445 (gPMHaltMessageType == kIOMessageSystemWillPowerOff) ?
8446 "PowerOff" : "Restart",
8447 service->getName(), service->getRegistryEntryID(),
8448 (uint32_t) deltaTime );
8449 halt_log_enter("PowerOff/Restart handler completed",
8450 OSMemberFunctionCast(const void *, service, &IOService::systemWillShutdown),
8451 elapsedTime);
8452 }
8453
8454 service->release();
8455 me->visits++;
8456 }
8457 }
8458
8459 void PMHaltWorker::checkTimeout( PMHaltWorker * me, AbsoluteTime * now )
8460 {
8461 UInt64 nano;
8462 AbsoluteTime startTime;
8463 AbsoluteTime endTime;
8464
8465 endTime = *now;
8466
8467 IOLockLock(me->lock);
8468 if (me->service && !me->timeout)
8469 {
8470 startTime = me->startTime;
8471 nano = 0;
8472 if (CMP_ABSOLUTETIME(&endTime, &startTime) > 0)
8473 {
8474 SUB_ABSOLUTETIME(&endTime, &startTime);
8475 absolutetime_to_nanoseconds(endTime, &nano);
8476 }
8477 if (nano > 3000000000ULL)
8478 {
8479 me->timeout = true;
8480
8481 halt_log_enter("PowerOff/Restart still waiting on handler",
8482 OSMemberFunctionCast(const void *, me->service, &IOService::systemWillShutdown),
8483 endTime);
8484 MSG("%s still waiting on %s\n",
8485 (gPMHaltMessageType == kIOMessageSystemWillPowerOff) ? "PowerOff" : "Restart",
8486 me->service->getName());
8487 }
8488 }
8489 IOLockUnlock(me->lock);
8490 }
8491
8492 //******************************************************************************
8493 // acknowledgeSystemWillShutdown
8494 //
8495 // Acknowledgement from drivers that they have prepared for shutdown/restart.
8496 //******************************************************************************
8497
8498 void IOPMrootDomain::acknowledgeSystemWillShutdown( IOService * from )
8499 {
8500 PMHaltWorker * worker;
8501 OSObject * prop;
8502
8503 if (!from)
8504 return;
8505
8506 //DLOG("%s acknowledged\n", from->getName());
8507 prop = from->copyProperty( gPMHaltClientAcknowledgeKey );
8508 if (prop)
8509 {
8510 worker = (PMHaltWorker *) prop;
8511 IOLockLock(worker->lock);
8512 from->removeProperty( gPMHaltClientAcknowledgeKey );
8513 thread_wakeup((event_t) worker);
8514 IOLockUnlock(worker->lock);
8515 worker->release();
8516 }
8517 else
8518 {
8519 DLOG("%s acknowledged without worker property\n",
8520 from->getName());
8521 }
8522 }
8523
8524
8525 //******************************************************************************
8526 // notifySystemShutdown
8527 //
8528 // Notify all objects in PM tree that system will shutdown or restart
8529 //******************************************************************************
8530
8531 static void
8532 notifySystemShutdown( IOService * root, uint32_t messageType )
8533 {
8534 #define PLACEHOLDER ((OSSet *)gPMHaltArray)
8535 IORegistryIterator * iter;
8536 IORegistryEntry * entry;
8537 IOService * node;
8538 OSSet * inner;
8539 PMHaltWorker * workers[kPMHaltMaxWorkers];
8540 AbsoluteTime deadline;
8541 unsigned int totalNodes = 0;
8542 unsigned int depth;
8543 unsigned int rootDepth;
8544 unsigned int numWorkers;
8545 unsigned int count;
8546 int waitResult;
8547 void * baseFunc;
8548 bool ok;
8549
8550 DLOG("%s msgType = 0x%x\n", __FUNCTION__, messageType);
8551
8552 baseFunc = OSMemberFunctionCast(void *, root, &IOService::systemWillShutdown);
8553
8554 // Iterate the entire PM tree starting from root
8555
8556 rootDepth = root->getDepth( gIOPowerPlane );
8557 if (!rootDepth) goto done;
8558
8559 // debug - for repeated test runs
8560 while (PMHaltWorker::metaClass->getInstanceCount())
8561 IOSleep(1);
8562
8563 if (!gPMHaltArray)
8564 {
8565 gPMHaltArray = OSArray::withCapacity(40);
8566 if (!gPMHaltArray) goto done;
8567 }
8568 else // debug
8569 gPMHaltArray->flushCollection();
8570
8571 if (!gPMHaltLock)
8572 {
8573 gPMHaltLock = IOLockAlloc();
8574 if (!gPMHaltLock) goto done;
8575 }
8576
8577 if (!gPMHaltClientAcknowledgeKey)
8578 {
8579 gPMHaltClientAcknowledgeKey =
8580 OSSymbol::withCStringNoCopy("PMShutdown");
8581 if (!gPMHaltClientAcknowledgeKey) goto done;
8582 }
8583
8584 gPMHaltMessageType = messageType;
8585
8586 // Depth-first walk of PM plane
8587
8588 iter = IORegistryIterator::iterateOver(
8589 root, gIOPowerPlane, kIORegistryIterateRecursively);
8590
8591 if (iter)
8592 {
8593 while ((entry = iter->getNextObject()))
8594 {
8595 node = OSDynamicCast(IOService, entry);
8596 if (!node)
8597 continue;
8598
8599 if (baseFunc ==
8600 OSMemberFunctionCast(void *, node, &IOService::systemWillShutdown))
8601 continue;
8602
8603 depth = node->getDepth( gIOPowerPlane );
8604 if (depth <= rootDepth)
8605 continue;
8606
8607 ok = false;
8608
8609 // adjust to zero based depth
8610 depth -= (rootDepth + 1);
8611
8612 // gPMHaltArray is an array of containers, each container
8613 // refers to nodes with the same depth.
8614
8615 count = gPMHaltArray->getCount();
8616 while (depth >= count)
8617 {
8618 // expand array and insert placeholders
8619 gPMHaltArray->setObject(PLACEHOLDER);
8620 count++;
8621 }
8622 count = gPMHaltArray->getCount();
8623 if (depth < count)
8624 {
8625 inner = (OSSet *)gPMHaltArray->getObject(depth);
8626 if (inner == PLACEHOLDER)
8627 {
8628 inner = OSSet::withCapacity(40);
8629 if (inner)
8630 {
8631 gPMHaltArray->replaceObject(depth, inner);
8632 inner->release();
8633 }
8634 }
8635
8636 // PM nodes that appear more than once in the tree will have
8637 // the same depth, OSSet will refuse to add the node twice.
8638 if (inner)
8639 ok = inner->setObject(node);
8640 }
8641 if (!ok)
8642 DLOG("Skipped PM node %s\n", node->getName());
8643 }
8644 iter->release();
8645 }
8646
8647 // debug only
8648 for (int i = 0; (inner = (OSSet *)gPMHaltArray->getObject(i)); i++)
8649 {
8650 count = 0;
8651 if (inner != PLACEHOLDER)
8652 count = inner->getCount();
8653 DLOG("Nodes at depth %u = %u\n", i, count);
8654 }
8655
8656 // strip placeholders (not all depths are populated)
8657 numWorkers = 0;
8658 for (int i = 0; (inner = (OSSet *)gPMHaltArray->getObject(i)); )
8659 {
8660 if (inner == PLACEHOLDER)
8661 {
8662 gPMHaltArray->removeObject(i);
8663 continue;
8664 }
8665 count = inner->getCount();
8666 if (count > numWorkers)
8667 numWorkers = count;
8668 totalNodes += count;
8669 i++;
8670 }
8671
8672 if (gPMHaltArray->getCount() == 0 || !numWorkers)
8673 goto done;
8674
8675 gPMHaltBusyCount = 0;
8676 gPMHaltIdleCount = 0;
8677 gPMHaltDepth = gPMHaltArray->getCount() - 1;
8678
8679 // Create multiple workers (and threads)
8680
8681 if (numWorkers > kPMHaltMaxWorkers)
8682 numWorkers = kPMHaltMaxWorkers;
8683
8684 DLOG("PM nodes %u, maxDepth %u, workers %u\n",
8685 totalNodes, gPMHaltArray->getCount(), numWorkers);
8686
8687 for (unsigned int i = 0; i < numWorkers; i++)
8688 workers[i] = PMHaltWorker::worker();
8689
8690 // Wait for workers to exhaust all available work
8691
8692 IOLockLock(gPMHaltLock);
8693 while (gPMHaltDepth >= 0)
8694 {
8695 clock_interval_to_deadline(1000, kMillisecondScale, &deadline);
8696
8697 waitResult = IOLockSleepDeadline(
8698 gPMHaltLock, &gPMHaltDepth, deadline, THREAD_UNINT);
8699 if (THREAD_TIMED_OUT == waitResult)
8700 {
8701 AbsoluteTime now;
8702 clock_get_uptime(&now);
8703
8704 IOLockUnlock(gPMHaltLock);
8705 for (unsigned int i = 0 ; i < numWorkers; i++)
8706 {
8707 if (workers[i])
8708 PMHaltWorker::checkTimeout(workers[i], &now);
8709 }
8710 IOLockLock(gPMHaltLock);
8711 }
8712 }
8713 IOLockUnlock(gPMHaltLock);
8714
8715 // Release all workers
8716
8717 for (unsigned int i = 0; i < numWorkers; i++)
8718 {
8719 if (workers[i])
8720 workers[i]->release();
8721 // worker also retained by it's own thread
8722 }
8723
8724 done:
8725 DLOG("%s done\n", __FUNCTION__);
8726 return;
8727 }
8728
8729 // MARK: -
8730 // MARK: Kernel Assertion
8731
8732 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
8733
8734 IOPMDriverAssertionID IOPMrootDomain::createPMAssertion(
8735 IOPMDriverAssertionType whichAssertionBits,
8736 IOPMDriverAssertionLevel assertionLevel,
8737 IOService *ownerService,
8738 const char *ownerDescription)
8739 {
8740 IOReturn ret;
8741 IOPMDriverAssertionID newAssertion;
8742
8743 if (!pmAssertions)
8744 return 0;
8745
8746 ret = pmAssertions->createAssertion(whichAssertionBits, assertionLevel, ownerService, ownerDescription, &newAssertion);
8747
8748 if (kIOReturnSuccess == ret)
8749 return newAssertion;
8750 else
8751 return 0;
8752 }
8753
8754 IOReturn IOPMrootDomain::releasePMAssertion(IOPMDriverAssertionID releaseAssertion)
8755 {
8756 if (!pmAssertions)
8757 return kIOReturnInternalError;
8758
8759 return pmAssertions->releaseAssertion(releaseAssertion);
8760 }
8761
8762
8763 IOReturn IOPMrootDomain::setPMAssertionLevel(
8764 IOPMDriverAssertionID assertionID,
8765 IOPMDriverAssertionLevel assertionLevel)
8766 {
8767 return pmAssertions->setAssertionLevel(assertionID, assertionLevel);
8768 }
8769
8770 IOPMDriverAssertionLevel IOPMrootDomain::getPMAssertionLevel(IOPMDriverAssertionType whichAssertion)
8771 {
8772 IOPMDriverAssertionType sysLevels;
8773
8774 if (!pmAssertions || whichAssertion == 0)
8775 return kIOPMDriverAssertionLevelOff;
8776
8777 sysLevels = pmAssertions->getActivatedAssertions();
8778
8779 // Check that every bit set in argument 'whichAssertion' is asserted
8780 // in the aggregate bits.
8781 if ((sysLevels & whichAssertion) == whichAssertion)
8782 return kIOPMDriverAssertionLevelOn;
8783 else
8784 return kIOPMDriverAssertionLevelOff;
8785 }
8786
8787 IOReturn IOPMrootDomain::setPMAssertionUserLevels(IOPMDriverAssertionType inLevels)
8788 {
8789 if (!pmAssertions)
8790 return kIOReturnNotFound;
8791
8792 return pmAssertions->setUserAssertionLevels(inLevels);
8793 }
8794
8795 bool IOPMrootDomain::serializeProperties( OSSerialize * s ) const
8796 {
8797 if (pmAssertions)
8798 {
8799 pmAssertions->publishProperties();
8800 }
8801 return( IOService::serializeProperties(s) );
8802 }
8803
8804 OSObject * IOPMrootDomain::copyProperty( const char * aKey) const
8805 {
8806 OSObject *obj = NULL;
8807 obj = IOService::copyProperty(aKey);
8808
8809 if (obj) return obj;
8810
8811 if (!strncmp(aKey, kIOPMSleepWakeWdogRebootKey,
8812 sizeof(kIOPMSleepWakeWdogRebootKey))) {
8813 if (swd_flags & SWD_BOOT_BY_SW_WDOG)
8814 return kOSBooleanTrue;
8815 else
8816 return kOSBooleanFalse;
8817
8818 }
8819
8820 if (!strncmp(aKey, kIOPMSleepWakeWdogLogsValidKey,
8821 sizeof(kIOPMSleepWakeWdogLogsValidKey))) {
8822 if (swd_flags & SWD_VALID_LOGS)
8823 return kOSBooleanTrue;
8824 else
8825 return kOSBooleanFalse;
8826
8827 }
8828
8829 /*
8830 * XXX: We should get rid of "DesktopMode" property when 'kAppleClamshellCausesSleepKey'
8831 * is set properly in darwake from sleep. For that, kIOPMEnableClamshell msg has to be
8832 * issued by DisplayWrangler on darkwake.
8833 */
8834 if (!strcmp(aKey, "DesktopMode")) {
8835 if (desktopMode)
8836 return kOSBooleanTrue;
8837 else
8838 return kOSBooleanFalse;
8839 }
8840 if (!strcmp(aKey, "DisplayIdleForDemandSleep")) {
8841 if (displayIdleForDemandSleep) {
8842 return kOSBooleanTrue;
8843 }
8844 else {
8845 return kOSBooleanFalse;
8846 }
8847 }
8848
8849 if (!strcmp(aKey, kIOPMDriverWakeEventsKey))
8850 {
8851 OSArray * array = 0;
8852 WAKEEVENT_LOCK();
8853 if (_systemWakeEventsArray && _systemWakeEventsArray->getCount()) {
8854 OSCollection *collection = _systemWakeEventsArray->copyCollection();
8855 if (collection && !(array = OSDynamicCast(OSArray, collection))) {
8856 collection->release();
8857 }
8858 }
8859 WAKEEVENT_UNLOCK();
8860 return array;
8861 }
8862
8863 if (!strcmp(aKey, kIOPMSleepStatisticsAppsKey))
8864 {
8865 OSArray * array = 0;
8866 IOLockLock(pmStatsLock);
8867 if (pmStatsAppResponses && pmStatsAppResponses->getCount()) {
8868 OSCollection *collection = pmStatsAppResponses->copyCollection();
8869 if (collection && !(array = OSDynamicCast(OSArray, collection))) {
8870 collection->release();
8871 }
8872 pmStatsAppResponses->flushCollection();
8873 }
8874 IOLockUnlock(pmStatsLock);
8875 return array;
8876 }
8877
8878 if (!strcmp(aKey, kIOPMIdleSleepPreventersKey))
8879 {
8880 OSArray *idleSleepList = NULL;
8881 gRootDomain->copySleepPreventersList(&idleSleepList, NULL);
8882 return idleSleepList;
8883 }
8884
8885 if (!strcmp(aKey, kIOPMSystemSleepPreventersKey))
8886 {
8887 OSArray *systemSleepList = NULL;
8888 gRootDomain->copySleepPreventersList(NULL, &systemSleepList);
8889 return systemSleepList;
8890 }
8891
8892 return NULL;
8893 }
8894
8895 // MARK: -
8896 // MARK: Wake Event Reporting
8897
8898 void IOPMrootDomain::copyWakeReasonString( char * outBuf, size_t bufSize )
8899 {
8900 WAKEEVENT_LOCK();
8901 strlcpy(outBuf, gWakeReasonString, bufSize);
8902 WAKEEVENT_UNLOCK();
8903 }
8904
8905 //******************************************************************************
8906 // acceptSystemWakeEvents
8907 //
8908 // Private control for the acceptance of driver wake event claims.
8909 //******************************************************************************
8910
8911 void IOPMrootDomain::acceptSystemWakeEvents( bool accept )
8912 {
8913 bool logWakeReason = false;
8914
8915 WAKEEVENT_LOCK();
8916 if (accept)
8917 {
8918 gWakeReasonString[0] = '\0';
8919 if (!_systemWakeEventsArray)
8920 _systemWakeEventsArray = OSArray::withCapacity(4);
8921 if ((_acceptSystemWakeEvents = (_systemWakeEventsArray != 0)))
8922 _systemWakeEventsArray->flushCollection();
8923 }
8924 else
8925 {
8926 _acceptSystemWakeEvents = false;
8927 #if CONFIG_EMBEDDED
8928 logWakeReason = gWakeReasonSysctlRegistered;
8929 #if DEVELOPMENT
8930 static int panic_allowed = -1;
8931
8932 if ((panic_allowed == -1) &&
8933 (PE_parse_boot_argn("swd_wakereason_panic", &panic_allowed, sizeof(panic_allowed)) == false)) {
8934 panic_allowed = 1;
8935 }
8936
8937 if (panic_allowed) {
8938 size_t i = 0;
8939 // Panic if wake reason is null or empty
8940 for (i = 0; (i < strlen(gWakeReasonString)); i++) {
8941 if ((gWakeReasonString[i] != ' ') && (gWakeReasonString[i] != '\t'))
8942 break;
8943 }
8944 if (i >= strlen(gWakeReasonString)) {
8945 panic("Wake reason is empty\n");
8946 }
8947 }
8948 #endif
8949 #endif
8950 }
8951 WAKEEVENT_UNLOCK();
8952
8953 if (logWakeReason)
8954 MSG("system wake events:%s\n", gWakeReasonString);
8955 }
8956
8957 //******************************************************************************
8958 // claimSystemWakeEvent
8959 //
8960 // For a driver to claim a device is the source/conduit of a system wake event.
8961 //******************************************************************************
8962
8963 void IOPMrootDomain::claimSystemWakeEvent(
8964 IOService * device,
8965 IOOptionBits flags,
8966 const char * reason,
8967 OSObject * details )
8968 {
8969 const OSSymbol * deviceName = 0;
8970 OSNumber * deviceRegId = 0;
8971 OSNumber * claimTime = 0;
8972 OSData * flagsData = 0;
8973 OSString * reasonString = 0;
8974 OSDictionary * d = 0;
8975 uint64_t timestamp;
8976 bool ok = false;
8977
8978 pmEventTimeStamp(&timestamp);
8979
8980 if (!device || !reason) return;
8981
8982 deviceName = device->copyName(gIOServicePlane);
8983 deviceRegId = OSNumber::withNumber(device->getRegistryEntryID(), 64);
8984 claimTime = OSNumber::withNumber(timestamp, 64);
8985 flagsData = OSData::withBytes(&flags, sizeof(flags));
8986 reasonString = OSString::withCString(reason);
8987 d = OSDictionary::withCapacity(5 + (details ? 1 : 0));
8988 if (!deviceName || !deviceRegId || !claimTime || !flagsData || !reasonString)
8989 goto done;
8990
8991 d->setObject(gIONameKey, deviceName);
8992 d->setObject(gIORegistryEntryIDKey, deviceRegId);
8993 d->setObject(kIOPMWakeEventTimeKey, claimTime);
8994 d->setObject(kIOPMWakeEventFlagsKey, flagsData);
8995 d->setObject(kIOPMWakeEventReasonKey, reasonString);
8996 if (details)
8997 d->setObject(kIOPMWakeEventDetailsKey, details);
8998
8999 WAKEEVENT_LOCK();
9000 if (!gWakeReasonSysctlRegistered)
9001 {
9002 // Lazy registration until the platform driver stops registering
9003 // the same name.
9004 gWakeReasonSysctlRegistered = true;
9005 #if CONFIG_EMBEDDED
9006 sysctl_register_oid(&sysctl__kern_wakereason);
9007 #endif
9008 }
9009 if (_acceptSystemWakeEvents)
9010 {
9011 ok = _systemWakeEventsArray->setObject(d);
9012 if (gWakeReasonString[0] != '\0')
9013 strlcat(gWakeReasonString, " ", sizeof(gWakeReasonString));
9014 strlcat(gWakeReasonString, reason, sizeof(gWakeReasonString));
9015 }
9016 WAKEEVENT_UNLOCK();
9017
9018 done:
9019 if (deviceName) deviceName->release();
9020 if (deviceRegId) deviceRegId->release();
9021 if (claimTime) claimTime->release();
9022 if (flagsData) flagsData->release();
9023 if (reasonString) reasonString->release();
9024 if (d) d->release();
9025 }
9026
9027 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
9028
9029 // MARK: -
9030 // MARK: PMSettingHandle
9031
9032 OSDefineMetaClassAndStructors( PMSettingHandle, OSObject )
9033
9034 void PMSettingHandle::free( void )
9035 {
9036 if (pmso)
9037 {
9038 pmso->clientHandleFreed();
9039 pmso->release();
9040 pmso = 0;
9041 }
9042
9043 OSObject::free();
9044 }
9045
9046 // MARK: -
9047 // MARK: PMSettingObject
9048
9049 #undef super
9050 #define super OSObject
9051 OSDefineMetaClassAndFinalStructors( PMSettingObject, OSObject )
9052
9053 /*
9054 * Static constructor/initializer for PMSettingObject
9055 */
9056 PMSettingObject *PMSettingObject::pmSettingObject(
9057 IOPMrootDomain *parent_arg,
9058 IOPMSettingControllerCallback handler_arg,
9059 OSObject *target_arg,
9060 uintptr_t refcon_arg,
9061 uint32_t supportedPowerSources,
9062 const OSSymbol * settings[],
9063 OSObject **handle_obj)
9064 {
9065 uint32_t settingCount = 0;
9066 PMSettingObject *pmso = 0;
9067 PMSettingHandle *pmsh = 0;
9068
9069 if ( !parent_arg || !handler_arg || !settings || !handle_obj )
9070 return NULL;
9071
9072 // count OSSymbol entries in NULL terminated settings array
9073 while (settings[settingCount]) {
9074 settingCount++;
9075 }
9076 if (0 == settingCount)
9077 return NULL;
9078
9079 pmso = new PMSettingObject;
9080 if (!pmso || !pmso->init())
9081 goto fail;
9082
9083 pmsh = new PMSettingHandle;
9084 if (!pmsh || !pmsh->init())
9085 goto fail;
9086
9087 queue_init(&pmso->calloutQueue);
9088 pmso->parent = parent_arg;
9089 pmso->func = handler_arg;
9090 pmso->target = target_arg;
9091 pmso->refcon = refcon_arg;
9092 pmso->settingCount = settingCount;
9093
9094 pmso->retain(); // handle holds a retain on pmso
9095 pmsh->pmso = pmso;
9096 pmso->pmsh = pmsh;
9097
9098 pmso->publishedFeatureID = (uint32_t *)IOMalloc(sizeof(uint32_t)*settingCount);
9099 if (pmso->publishedFeatureID) {
9100 for (unsigned int i=0; i<settingCount; i++) {
9101 // Since there is now at least one listener to this setting, publish
9102 // PM root domain support for it.
9103 parent_arg->publishPMSetting( settings[i],
9104 supportedPowerSources, &pmso->publishedFeatureID[i] );
9105 }
9106 }
9107
9108 *handle_obj = pmsh;
9109 return pmso;
9110
9111 fail:
9112 if (pmso) pmso->release();
9113 if (pmsh) pmsh->release();
9114 return NULL;
9115 }
9116
9117 void PMSettingObject::free( void )
9118 {
9119 if (publishedFeatureID) {
9120 for (uint32_t i=0; i<settingCount; i++) {
9121 if (publishedFeatureID[i]) {
9122 parent->removePublishedFeature( publishedFeatureID[i] );
9123 }
9124 }
9125
9126 IOFree(publishedFeatureID, sizeof(uint32_t) * settingCount);
9127 }
9128
9129 super::free();
9130 }
9131
9132 void PMSettingObject::dispatchPMSetting( const OSSymbol * type, OSObject * object )
9133 {
9134 (*func)(target, type, object, refcon);
9135 }
9136
9137 void PMSettingObject::clientHandleFreed( void )
9138 {
9139 parent->deregisterPMSettingObject(this);
9140 }
9141
9142 // MARK: -
9143 // MARK: PMAssertionsTracker
9144
9145 //*********************************************************************************
9146 //*********************************************************************************
9147 //*********************************************************************************
9148 // class PMAssertionsTracker Implementation
9149
9150 #define kAssertUniqueIDStart 500
9151
9152 PMAssertionsTracker *PMAssertionsTracker::pmAssertionsTracker( IOPMrootDomain *rootDomain )
9153 {
9154 PMAssertionsTracker *myself;
9155
9156 myself = new PMAssertionsTracker;
9157
9158 if (myself) {
9159 myself->init();
9160 myself->owner = rootDomain;
9161 myself->issuingUniqueID = kAssertUniqueIDStart;
9162 myself->assertionsArray = OSArray::withCapacity(5);
9163 myself->assertionsKernel = 0;
9164 myself->assertionsUser = 0;
9165 myself->assertionsCombined = 0;
9166 myself->assertionsArrayLock = IOLockAlloc();
9167 myself->tabulateProducerCount = myself->tabulateConsumerCount = 0;
9168
9169 if (!myself->assertionsArray || !myself->assertionsArrayLock)
9170 myself = NULL;
9171 }
9172
9173 return myself;
9174 }
9175
9176 /* tabulate
9177 * - Update assertionsKernel to reflect the state of all
9178 * assertions in the kernel.
9179 * - Update assertionsCombined to reflect both kernel & user space.
9180 */
9181 void PMAssertionsTracker::tabulate(void)
9182 {
9183 int i;
9184 int count;
9185 PMAssertStruct *_a = NULL;
9186 OSData *_d = NULL;
9187
9188 IOPMDriverAssertionType oldKernel = assertionsKernel;
9189 IOPMDriverAssertionType oldCombined = assertionsCombined;
9190
9191 ASSERT_GATED();
9192
9193 assertionsKernel = 0;
9194 assertionsCombined = 0;
9195
9196 if (!assertionsArray)
9197 return;
9198
9199 if ((count = assertionsArray->getCount()))
9200 {
9201 for (i=0; i<count; i++)
9202 {
9203 _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
9204 if (_d)
9205 {
9206 _a = (PMAssertStruct *)_d->getBytesNoCopy();
9207 if (_a && (kIOPMDriverAssertionLevelOn == _a->level))
9208 assertionsKernel |= _a->assertionBits;
9209 }
9210 }
9211 }
9212
9213 tabulateProducerCount++;
9214 assertionsCombined = assertionsKernel | assertionsUser;
9215
9216 if ((assertionsKernel != oldKernel) ||
9217 (assertionsCombined != oldCombined))
9218 {
9219 owner->evaluateAssertions(assertionsCombined, oldCombined);
9220 }
9221 }
9222
9223 void PMAssertionsTracker::publishProperties( void )
9224 {
9225 OSArray *assertionsSummary = NULL;
9226
9227 if (tabulateConsumerCount != tabulateProducerCount)
9228 {
9229 IOLockLock(assertionsArrayLock);
9230
9231 tabulateConsumerCount = tabulateProducerCount;
9232
9233 /* Publish the IOPMrootDomain property "DriverPMAssertionsDetailed"
9234 */
9235 assertionsSummary = copyAssertionsArray();
9236 if (assertionsSummary)
9237 {
9238 owner->setProperty(kIOPMAssertionsDriverDetailedKey, assertionsSummary);
9239 assertionsSummary->release();
9240 }
9241 else
9242 {
9243 owner->removeProperty(kIOPMAssertionsDriverDetailedKey);
9244 }
9245
9246 /* Publish the IOPMrootDomain property "DriverPMAssertions"
9247 */
9248 owner->setProperty(kIOPMAssertionsDriverKey, assertionsKernel, 64);
9249
9250 IOLockUnlock(assertionsArrayLock);
9251 }
9252 }
9253
9254 PMAssertionsTracker::PMAssertStruct *PMAssertionsTracker::detailsForID(IOPMDriverAssertionID _id, int *index)
9255 {
9256 PMAssertStruct *_a = NULL;
9257 OSData *_d = NULL;
9258 int found = -1;
9259 int count = 0;
9260 int i = 0;
9261
9262 if (assertionsArray
9263 && (count = assertionsArray->getCount()))
9264 {
9265 for (i=0; i<count; i++)
9266 {
9267 _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
9268 if (_d)
9269 {
9270 _a = (PMAssertStruct *)_d->getBytesNoCopy();
9271 if (_a && (_id == _a->id)) {
9272 found = i;
9273 break;
9274 }
9275 }
9276 }
9277 }
9278
9279 if (-1 == found) {
9280 return NULL;
9281 } else {
9282 if (index)
9283 *index = found;
9284 return _a;
9285 }
9286 }
9287
9288 /* PMAssertionsTracker::handleCreateAssertion
9289 * Perform assertion work on the PM workloop. Do not call directly.
9290 */
9291 IOReturn PMAssertionsTracker::handleCreateAssertion(OSData *newAssertion)
9292 {
9293 ASSERT_GATED();
9294
9295 if (newAssertion)
9296 {
9297 IOLockLock(assertionsArrayLock);
9298 assertionsArray->setObject(newAssertion);
9299 IOLockUnlock(assertionsArrayLock);
9300 newAssertion->release();
9301
9302 tabulate();
9303 }
9304 return kIOReturnSuccess;
9305 }
9306
9307 /* PMAssertionsTracker::createAssertion
9308 * createAssertion allocates memory for a new PM assertion, and affects system behavior, if
9309 * appropiate.
9310 */
9311 IOReturn PMAssertionsTracker::createAssertion(
9312 IOPMDriverAssertionType which,
9313 IOPMDriverAssertionLevel level,
9314 IOService *serviceID,
9315 const char *whoItIs,
9316 IOPMDriverAssertionID *outID)
9317 {
9318 OSData *dataStore = NULL;
9319 PMAssertStruct track;
9320
9321 // Warning: trillions and trillions of created assertions may overflow the unique ID.
9322 track.id = OSIncrementAtomic64((SInt64*) &issuingUniqueID);
9323 track.level = level;
9324 track.assertionBits = which;
9325 track.ownerString = whoItIs ? OSSymbol::withCString(whoItIs):0;
9326 track.ownerService = serviceID;
9327 track.registryEntryID = serviceID ? serviceID->getRegistryEntryID():0;
9328 track.modifiedTime = 0;
9329 pmEventTimeStamp(&track.createdTime);
9330
9331 dataStore = OSData::withBytes(&track, sizeof(PMAssertStruct));
9332 if (!dataStore)
9333 {
9334 if (track.ownerString)
9335 track.ownerString->release();
9336 return kIOReturnNoMemory;
9337 }
9338
9339 *outID = track.id;
9340
9341 if (owner && owner->pmPowerStateQueue) {
9342 owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionCreate, (void *)dataStore);
9343 }
9344
9345 return kIOReturnSuccess;
9346 }
9347
9348 /* PMAssertionsTracker::handleReleaseAssertion
9349 * Runs in PM workloop. Do not call directly.
9350 */
9351 IOReturn PMAssertionsTracker::handleReleaseAssertion(
9352 IOPMDriverAssertionID _id)
9353 {
9354 ASSERT_GATED();
9355
9356 int index;
9357 PMAssertStruct *assertStruct = detailsForID(_id, &index);
9358
9359 if (!assertStruct)
9360 return kIOReturnNotFound;
9361
9362 IOLockLock(assertionsArrayLock);
9363 if (assertStruct->ownerString)
9364 assertStruct->ownerString->release();
9365
9366 assertionsArray->removeObject(index);
9367 IOLockUnlock(assertionsArrayLock);
9368
9369 tabulate();
9370 return kIOReturnSuccess;
9371 }
9372
9373 /* PMAssertionsTracker::releaseAssertion
9374 * Releases an assertion and affects system behavior if appropiate.
9375 * Actual work happens on PM workloop.
9376 */
9377 IOReturn PMAssertionsTracker::releaseAssertion(
9378 IOPMDriverAssertionID _id)
9379 {
9380 if (owner && owner->pmPowerStateQueue) {
9381 owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionRelease, 0, _id);
9382 }
9383 return kIOReturnSuccess;
9384 }
9385
9386 /* PMAssertionsTracker::handleSetAssertionLevel
9387 * Runs in PM workloop. Do not call directly.
9388 */
9389 IOReturn PMAssertionsTracker::handleSetAssertionLevel(
9390 IOPMDriverAssertionID _id,
9391 IOPMDriverAssertionLevel _level)
9392 {
9393 PMAssertStruct *assertStruct = detailsForID(_id, NULL);
9394
9395 ASSERT_GATED();
9396
9397 if (!assertStruct) {
9398 return kIOReturnNotFound;
9399 }
9400
9401 IOLockLock(assertionsArrayLock);
9402 pmEventTimeStamp(&assertStruct->modifiedTime);
9403 assertStruct->level = _level;
9404 IOLockUnlock(assertionsArrayLock);
9405
9406 tabulate();
9407 return kIOReturnSuccess;
9408 }
9409
9410 /* PMAssertionsTracker::setAssertionLevel
9411 */
9412 IOReturn PMAssertionsTracker::setAssertionLevel(
9413 IOPMDriverAssertionID _id,
9414 IOPMDriverAssertionLevel _level)
9415 {
9416 if (owner && owner->pmPowerStateQueue) {
9417 owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionSetLevel,
9418 (void *)(uintptr_t)_level, _id);
9419 }
9420
9421 return kIOReturnSuccess;
9422 }
9423
9424 IOReturn PMAssertionsTracker::handleSetUserAssertionLevels(void * arg0)
9425 {
9426 IOPMDriverAssertionType new_user_levels = *(IOPMDriverAssertionType *) arg0;
9427
9428 ASSERT_GATED();
9429
9430 if (new_user_levels != assertionsUser)
9431 {
9432 assertionsUser = new_user_levels;
9433 DLOG("assertionsUser 0x%llx\n", assertionsUser);
9434 }
9435
9436 tabulate();
9437 return kIOReturnSuccess;
9438 }
9439
9440 IOReturn PMAssertionsTracker::setUserAssertionLevels(
9441 IOPMDriverAssertionType new_user_levels)
9442 {
9443 if (gIOPMWorkLoop) {
9444 gIOPMWorkLoop->runAction(
9445 OSMemberFunctionCast(
9446 IOWorkLoop::Action,
9447 this,
9448 &PMAssertionsTracker::handleSetUserAssertionLevels),
9449 this,
9450 (void *) &new_user_levels, 0, 0, 0);
9451 }
9452
9453 return kIOReturnSuccess;
9454 }
9455
9456
9457 OSArray *PMAssertionsTracker::copyAssertionsArray(void)
9458 {
9459 int count;
9460 int i;
9461 OSArray *outArray = NULL;
9462
9463 if (!assertionsArray ||
9464 (0 == (count = assertionsArray->getCount())) ||
9465 (NULL == (outArray = OSArray::withCapacity(count))))
9466 {
9467 goto exit;
9468 }
9469
9470 for (i=0; i<count; i++)
9471 {
9472 PMAssertStruct *_a = NULL;
9473 OSData *_d = NULL;
9474 OSDictionary *details = NULL;
9475
9476 _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
9477 if (_d && (_a = (PMAssertStruct *)_d->getBytesNoCopy()))
9478 {
9479 OSNumber *_n = NULL;
9480
9481 details = OSDictionary::withCapacity(7);
9482 if (!details)
9483 continue;
9484
9485 outArray->setObject(details);
9486 details->release();
9487
9488 _n = OSNumber::withNumber(_a->id, 64);
9489 if (_n) {
9490 details->setObject(kIOPMDriverAssertionIDKey, _n);
9491 _n->release();
9492 }
9493 _n = OSNumber::withNumber(_a->createdTime, 64);
9494 if (_n) {
9495 details->setObject(kIOPMDriverAssertionCreatedTimeKey, _n);
9496 _n->release();
9497 }
9498 _n = OSNumber::withNumber(_a->modifiedTime, 64);
9499 if (_n) {
9500 details->setObject(kIOPMDriverAssertionModifiedTimeKey, _n);
9501 _n->release();
9502 }
9503 _n = OSNumber::withNumber((uintptr_t)_a->registryEntryID, 64);
9504 if (_n) {
9505 details->setObject(kIOPMDriverAssertionRegistryEntryIDKey, _n);
9506 _n->release();
9507 }
9508 _n = OSNumber::withNumber(_a->level, 64);
9509 if (_n) {
9510 details->setObject(kIOPMDriverAssertionLevelKey, _n);
9511 _n->release();
9512 }
9513 _n = OSNumber::withNumber(_a->assertionBits, 64);
9514 if (_n) {
9515 details->setObject(kIOPMDriverAssertionAssertedKey, _n);
9516 _n->release();
9517 }
9518
9519 if (_a->ownerString) {
9520 details->setObject(kIOPMDriverAssertionOwnerStringKey, _a->ownerString);
9521 }
9522 }
9523 }
9524
9525 exit:
9526 return outArray;
9527 }
9528
9529 IOPMDriverAssertionType PMAssertionsTracker::getActivatedAssertions(void)
9530 {
9531 return assertionsCombined;
9532 }
9533
9534 IOPMDriverAssertionLevel PMAssertionsTracker::getAssertionLevel(
9535 IOPMDriverAssertionType type)
9536 {
9537 if (type && ((type & assertionsKernel) == assertionsKernel))
9538 {
9539 return kIOPMDriverAssertionLevelOn;
9540 } else {
9541 return kIOPMDriverAssertionLevelOff;
9542 }
9543 }
9544
9545 //*********************************************************************************
9546 //*********************************************************************************
9547 //*********************************************************************************
9548
9549
9550 static void pmEventTimeStamp(uint64_t *recordTS)
9551 {
9552 clock_sec_t tsec;
9553 clock_usec_t tusec;
9554
9555 if (!recordTS)
9556 return;
9557
9558 // We assume tsec fits into 32 bits; 32 bits holds enough
9559 // seconds for 136 years since the epoch in 1970.
9560 clock_get_calendar_microtime(&tsec, &tusec);
9561
9562
9563 // Pack the sec & microsec calendar time into a uint64_t, for fun.
9564 *recordTS = 0;
9565 *recordTS |= (uint32_t)tusec;
9566 *recordTS |= ((uint64_t)tsec << 32);
9567
9568 return;
9569 }
9570
9571 // MARK: -
9572 // MARK: IORootParent
9573
9574 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
9575
9576 OSDefineMetaClassAndFinalStructors(IORootParent, IOService)
9577
9578 // The reason that root domain needs a root parent is to facilitate demand
9579 // sleep, since a power change from the root parent cannot be vetoed.
9580 //
9581 // The above statement is no longer true since root domain now performs
9582 // demand sleep using overrides. But root parent remains to avoid changing
9583 // the power tree stacking. Root parent is parked at the max power state.
9584
9585
9586 static IOPMPowerState patriarchPowerStates[2] =
9587 {
9588 {1,0,ON_POWER,0,0,0,0,0,0,0,0,0},
9589 {1,0,ON_POWER,0,0,0,0,0,0,0,0,0},
9590 };
9591
9592 void IORootParent::initialize( void )
9593 {
9594 }
9595
9596 bool IORootParent::start( IOService * nub )
9597 {
9598 IOService::start(nub);
9599 attachToParent( getRegistryRoot(), gIOPowerPlane );
9600 PMinit();
9601 registerPowerDriver(this, patriarchPowerStates, 2);
9602 makeUsable();
9603 return true;
9604 }
9605
9606 void IORootParent::shutDownSystem( void )
9607 {
9608 }
9609
9610 void IORootParent::restartSystem( void )
9611 {
9612 }
9613
9614 void IORootParent::sleepSystem( void )
9615 {
9616 }
9617
9618 void IORootParent::dozeSystem( void )
9619 {
9620 }
9621
9622 void IORootParent::sleepToDoze( void )
9623 {
9624 }
9625
9626 void IORootParent::wakeSystem( void )
9627 {
9628 }
9629
9630 OSObject * IORootParent::copyProperty( const char * aKey) const
9631 {
9632 return (IOService::copyProperty(aKey));
9633 }
9634
9635 uint32_t IOPMrootDomain::getWatchdogTimeout()
9636 {
9637 if (gSwdSleepWakeTimeout) {
9638 gSwdSleepTimeout = gSwdWakeTimeout = gSwdSleepWakeTimeout;
9639 }
9640 if ((pmTracer->getTracePhase() < kIOPMTracePointSystemSleep) ||
9641 (pmTracer->getTracePhase() == kIOPMTracePointDarkWakeEntry)) {
9642 return gSwdSleepTimeout ? gSwdSleepTimeout : WATCHDOG_SLEEP_TIMEOUT;
9643 }
9644 else {
9645 return gSwdWakeTimeout ? gSwdWakeTimeout : WATCHDOG_WAKE_TIMEOUT;
9646 }
9647 }
9648
9649
9650 #if defined(__i386__) || defined(__x86_64__)
9651 IOReturn IOPMrootDomain::restartWithStackshot()
9652 {
9653 takeStackshot(true, true, false);
9654
9655 return kIOReturnSuccess;
9656 }
9657
9658 void IOPMrootDomain::sleepWakeDebugTrig(bool wdogTrigger)
9659 {
9660 takeStackshot(wdogTrigger, false, false);
9661 }
9662
9663 void IOPMrootDomain::tracePhase2String(uint32_t tracePhase, const char **phaseString, const char **description)
9664 {
9665 switch (tracePhase) {
9666
9667 case kIOPMTracePointSleepStarted:
9668 *phaseString = "kIOPMTracePointSleepStarted";
9669 *description = "starting sleep";
9670 break;
9671
9672 case kIOPMTracePointSleepApplications:
9673 *phaseString = "kIOPMTracePointSleepApplications";
9674 *description = "notifying applications";
9675 break;
9676
9677 case kIOPMTracePointSleepPriorityClients:
9678 *phaseString = "kIOPMTracePointSleepPriorityClients";
9679 *description = "notifying clients about upcoming system capability changes";
9680 break;
9681
9682 case kIOPMTracePointSleepWillChangeInterests:
9683 *phaseString = "kIOPMTracePointSleepWillChangeInterests";
9684 *description = "creating hibernation file or while calling rootDomain's clients about upcoming rootDomain's state changes";
9685 break;
9686
9687 case kIOPMTracePointSleepPowerPlaneDrivers:
9688 *phaseString = "kIOPMTracePointSleepPowerPlaneDrivers";
9689 *description = "calling power state change callbacks";
9690 break;
9691
9692 case kIOPMTracePointSleepDidChangeInterests:
9693 *phaseString = "kIOPMTracePointSleepDidChangeInterests";
9694 *description = "calling rootDomain's clients about rootDomain's state changes";
9695 break;
9696
9697 case kIOPMTracePointSleepCapabilityClients:
9698 *phaseString = "kIOPMTracePointSleepCapabilityClients";
9699 *description = "notifying clients about current system capabilities";
9700 break;
9701
9702 case kIOPMTracePointSleepPlatformActions:
9703 *phaseString = "kIOPMTracePointSleepPlatformActions";
9704 *description = "calling Quiesce/Sleep action callbacks";
9705 break;
9706
9707 case kIOPMTracePointSleepCPUs:
9708 *phaseString = "kIOPMTracePointSleepCPUs";
9709 *description = "halting all non-boot CPUs";
9710 break;
9711
9712 case kIOPMTracePointSleepPlatformDriver:
9713 *phaseString = "kIOPMTracePointSleepPlatformDriver";
9714 *description = "executing platform specific code";
9715 break;
9716
9717 case kIOPMTracePointHibernate:
9718 *phaseString = "kIOPMTracePointHibernate";
9719 *description = "writing the hibernation image";
9720 break;
9721
9722 case kIOPMTracePointSystemSleep:
9723 *phaseString = "kIOPMTracePointSystemSleep";
9724 *description = "in EFI/Bootrom after last point of entry to sleep";
9725 break;
9726
9727 case kIOPMTracePointWakePlatformDriver:
9728 *phaseString = "kIOPMTracePointWakePlatformDriver";
9729 *description = "executing platform specific code";
9730 break;
9731
9732
9733 case kIOPMTracePointWakePlatformActions:
9734 *phaseString = "kIOPMTracePointWakePlatformActions";
9735 *description = "calling Wake action callbacks";
9736 break;
9737
9738 case kIOPMTracePointWakeCPUs:
9739 *phaseString = "kIOPMTracePointWakeCPUs";
9740 *description = "starting non-boot CPUs";
9741 break;
9742
9743 case kIOPMTracePointWakeWillPowerOnClients:
9744 *phaseString = "kIOPMTracePointWakeWillPowerOnClients";
9745 *description = "sending kIOMessageSystemWillPowerOn message to kernel and userspace clients";
9746 break;
9747
9748 case kIOPMTracePointWakeWillChangeInterests:
9749 *phaseString = "kIOPMTracePointWakeWillChangeInterests";
9750 *description = "calling rootDomain's clients about upcoming rootDomain's state changes";
9751 break;
9752
9753 case kIOPMTracePointWakeDidChangeInterests:
9754 *phaseString = "kIOPMTracePointWakeDidChangeInterests";
9755 *description = "calling rootDomain's clients about completed rootDomain's state changes";
9756 break;
9757
9758 case kIOPMTracePointWakePowerPlaneDrivers:
9759 *phaseString = "kIOPMTracePointWakePowerPlaneDrivers";
9760 *description = "calling power state change callbacks";
9761 break;
9762
9763 case kIOPMTracePointWakeCapabilityClients:
9764 *phaseString = "kIOPMTracePointWakeCapabilityClients";
9765 *description = "informing clients about current system capabilities";
9766 break;
9767
9768 case kIOPMTracePointWakeApplications:
9769 *phaseString = "kIOPMTracePointWakeApplications";
9770 *description = "sending asynchronous kIOMessageSystemHasPoweredOn message to userspace clients";
9771 break;
9772
9773 case kIOPMTracePointDarkWakeEntry:
9774 *phaseString = "kIOPMTracePointDarkWakeEntry";
9775 *description = "entering darkwake on way to sleep";
9776 break;
9777
9778 case kIOPMTracePointDarkWakeExit:
9779 *phaseString = "kIOPMTracePointDarkWakeExit";
9780 *description = "entering fullwake from darkwake";
9781 break;
9782
9783 default:
9784 *phaseString = NULL;
9785 *description = NULL;
9786 }
9787
9788 }
9789
9790 void IOPMrootDomain::saveFailureData2File( )
9791 {
9792 unsigned int len = 0;
9793 char failureStr[512];
9794 errno_t error;
9795 char *outbuf;
9796 bool oswatchdog = false;
9797
9798 if (!PEReadNVRAMProperty(kIOSleepWakeFailureString, NULL, &len) &&
9799 !PEReadNVRAMProperty(kIOOSWatchdogFailureString, NULL, &len) ) {
9800 DLOG("No SleepWake failure or OSWatchdog failure string to read\n");
9801 return;
9802 }
9803
9804 if (len == 0) {
9805 DLOG("Ignoring zero byte SleepWake failure string\n");
9806 goto exit;
9807 }
9808
9809 if (len > sizeof(failureStr)) {
9810 len = sizeof(failureStr);
9811 }
9812 failureStr[0] = 0;
9813 if (PEReadNVRAMProperty(kIOSleepWakeFailureString, failureStr, &len) == false) {
9814 if (PEReadNVRAMProperty(kIOOSWatchdogFailureString, failureStr, &len)) {
9815 oswatchdog = true;
9816 }
9817 }
9818 if (failureStr[0] != 0) {
9819 error = sleepWakeDebugSaveFile(oswatchdog ? kOSWatchdogFailureStringFile : kSleepWakeFailureStringFile,
9820 failureStr, len);
9821 if (error) {
9822 DLOG("Failed to save SleepWake failure string to file. error:%d\n", error);
9823 }
9824 else {
9825 DLOG("Saved SleepWake failure string to file.\n");
9826 }
9827 if (!oswatchdog) {
9828 swd_flags |= SWD_BOOT_BY_SW_WDOG;
9829 }
9830 }
9831
9832 if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock))
9833 goto exit;
9834
9835 if (swd_buffer) {
9836 unsigned int len = 0;
9837 errno_t error;
9838 char nvram_var_name_buffer[20];
9839 unsigned int concat_len = 0;
9840 swd_hdr *hdr = NULL;
9841
9842
9843 hdr = (swd_hdr *)swd_buffer;
9844 outbuf = (char *)hdr + hdr->spindump_offset;
9845
9846 for (int i=0; i < 8; i++) {
9847 snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, i+1);
9848 if (!PEReadNVRAMProperty(nvram_var_name_buffer, NULL, &len)) {
9849 LOG("No SleepWake blob to read beyond chunk %d\n", i);
9850 break;
9851 }
9852 if (PEReadNVRAMProperty(nvram_var_name_buffer, outbuf+concat_len, &len) == FALSE) {
9853 PERemoveNVRAMProperty(nvram_var_name_buffer);
9854 LOG("Could not read the property :-(\n");
9855 break;
9856 }
9857 PERemoveNVRAMProperty(nvram_var_name_buffer);
9858 concat_len += len;
9859 }
9860 LOG("Concatenated length for the SWD blob %d\n", concat_len);
9861
9862 if (concat_len) {
9863 error = sleepWakeDebugSaveFile(oswatchdog ? kOSWatchdogStacksFilename : kSleepWakeStacksFilename,
9864 outbuf, concat_len);
9865 if (error) {
9866 LOG("Failed to save SleepWake zipped data to file. error:%d\n", error);
9867 } else {
9868 LOG("Saved SleepWake zipped data to file.\n");
9869 }
9870 }
9871
9872 }
9873 else {
9874 LOG("No buffer allocated to save failure stackshot\n");
9875 }
9876
9877
9878 gRootDomain->swd_lock = 0;
9879 exit:
9880 PERemoveNVRAMProperty(oswatchdog ? kIOOSWatchdogFailureString : kIOSleepWakeFailureString);
9881 return;
9882 }
9883
9884
9885 void IOPMrootDomain::getFailureData(thread_t *thread, char *failureStr, size_t strLen)
9886 {
9887 IORegistryIterator * iter;
9888 IORegistryEntry * entry;
9889 IOService * node;
9890 bool nodeFound = false;
9891
9892 const void * callMethod = NULL;
9893 const char * objectName = NULL;
9894 uint32_t timeout = getWatchdogTimeout();
9895 const char * phaseString = NULL;
9896 const char * phaseDescription = NULL;
9897
9898 IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, notifierObject);
9899 uint32_t tracePhase = pmTracer->getTracePhase();
9900
9901 *thread = NULL;
9902 if ((tracePhase < kIOPMTracePointSystemSleep) || (tracePhase == kIOPMTracePointDarkWakeEntry)) {
9903 snprintf(failureStr, strLen, "%sSleep transition timed out after %d seconds", failureStr, timeout);
9904 }
9905 else {
9906 snprintf(failureStr, strLen, "%sWake transition timed out after %d seconds", failureStr,timeout);
9907 }
9908 tracePhase2String(tracePhase, &phaseString, &phaseDescription);
9909
9910 if (notifierThread) {
9911 if (notifier && (notifier->identifier)) {
9912 objectName = notifier->identifier->getCStringNoCopy();
9913 }
9914 *thread = notifierThread;
9915 }
9916 else {
9917
9918 iter = IORegistryIterator::iterateOver(
9919 getPMRootDomain(), gIOPowerPlane, kIORegistryIterateRecursively);
9920
9921 if (iter)
9922 {
9923 while ((entry = iter->getNextObject()))
9924 {
9925 node = OSDynamicCast(IOService, entry);
9926 if (!node)
9927 continue;
9928 if (OSDynamicCast(IOPowerConnection, node)) {
9929 continue;
9930 }
9931
9932 if(node->getBlockingDriverCall(thread, &callMethod)) {
9933 nodeFound = true;
9934 break;
9935 }
9936 }
9937 iter->release();
9938 }
9939 if (nodeFound) {
9940 OSKext *kext = OSKext::lookupKextWithAddress((vm_address_t)callMethod);
9941 if (kext) {
9942 objectName = kext->getIdentifierCString();
9943 }
9944 }
9945 }
9946 if (phaseDescription) {
9947 snprintf(failureStr, strLen, "%s while %s.", failureStr, phaseDescription);
9948 }
9949 if (objectName) {
9950 snprintf(failureStr, strLen, "%s Suspected bundle: %s.", failureStr, objectName);
9951 }
9952 if (*thread) {
9953 snprintf(failureStr, strLen, "%s Thread 0x%llx.", failureStr, thread_tid(*thread));
9954 }
9955
9956 DLOG("%s\n", failureStr);
9957 }
9958
9959 struct swd_stackshot_compressed_data
9960 {
9961 z_output_func zoutput;
9962 size_t zipped;
9963 uint64_t totalbytes;
9964 uint64_t lastpercent;
9965 IOReturn error;
9966 unsigned outremain;
9967 unsigned outlen;
9968 unsigned writes;
9969 Bytef * outbuf;
9970 };
9971 struct swd_stackshot_compressed_data swd_zip_var = { };
9972
9973 static void *swd_zs_alloc(void *__unused ref, u_int items, u_int size)
9974 {
9975 void *result;
9976 LOG("Alloc in zipping %d items of size %d\n", items, size);
9977
9978 result = (void *)(swd_zs_zmem + swd_zs_zoffset);
9979 swd_zs_zoffset += ~31L & (31 + (items * size)); // 32b align for vector crc
9980 LOG("Offset %zu\n", swd_zs_zoffset);
9981 return (result);
9982 }
9983
9984 static int swd_zinput(z_streamp strm, Bytef *buf, unsigned size)
9985 {
9986 unsigned len;
9987
9988 len = strm->avail_in;
9989
9990 if (len > size)
9991 len = size;
9992 if (len == 0)
9993 return 0;
9994
9995 if (strm->next_in != (Bytef *) strm)
9996 memcpy(buf, strm->next_in, len);
9997 else
9998 bzero(buf, len);
9999
10000 strm->adler = z_crc32(strm->adler, buf, len);
10001
10002 strm->avail_in -= len;
10003 strm->next_in += len;
10004 strm->total_in += len;
10005
10006 return (int)len;
10007 }
10008
10009 static int swd_zoutput(z_streamp strm, Bytef *buf, unsigned len)
10010 {
10011 unsigned int i = 0;
10012 // if outlen > max size don't add to the buffer
10013 if (strm && buf) {
10014 if (swd_zip_var.outlen + len > SWD_COMPRESSED_BUFSIZE) {
10015 LOG("No space to GZIP... not writing to NVRAM\n");
10016 return (len);
10017 }
10018 }
10019 for (i = 0; i < len; i++) {
10020 *(swd_zip_var.outbuf + swd_zip_var.outlen + i) = *(buf +i);
10021 }
10022 swd_zip_var.outlen += len;
10023 return (len);
10024 }
10025 static void swd_zs_free(void * __unused ref, void * __unused ptr) {}
10026
10027 static int swd_compress(char *inPtr, char *outPtr, size_t numBytes)
10028 {
10029 int wbits = 12;
10030 int memlevel = 3;
10031
10032 if (!swd_zs.zalloc) {
10033 swd_zs.zalloc = swd_zs_alloc;
10034 swd_zs.zfree = swd_zs_free;
10035 if (deflateInit2(&swd_zs, Z_BEST_SPEED, Z_DEFLATED, wbits + 16, memlevel, Z_DEFAULT_STRATEGY)) {
10036 // allocation failed
10037 bzero(&swd_zs, sizeof(swd_zs));
10038 // swd_zs_zoffset = 0;
10039 } else {
10040 LOG("PMRD inited the zlib allocation routines\n");
10041 }
10042 }
10043
10044
10045
10046 swd_zip_var.zipped = 0;
10047 swd_zip_var.totalbytes = 0; // should this be the max that we have?
10048 swd_zip_var.lastpercent = 0;
10049 swd_zip_var.error = kIOReturnSuccess;
10050 swd_zip_var.outremain = 0;
10051 swd_zip_var.outlen = 0;
10052 swd_zip_var.writes = 0;
10053 swd_zip_var.outbuf = (Bytef *)outPtr;
10054
10055 swd_zip_var.totalbytes = numBytes;
10056
10057 swd_zs.avail_in = 0;
10058 swd_zs.next_in = NULL;
10059 swd_zs.avail_out = 0;
10060 swd_zs.next_out = NULL;
10061
10062 deflateResetWithIO(&swd_zs, swd_zinput, swd_zoutput);
10063
10064 z_stream *zs;
10065 int zr;
10066 zs = &swd_zs;
10067
10068 zr = Z_OK;
10069
10070 while (swd_zip_var.error >= 0) {
10071 if (!zs->avail_in) {
10072 zs->next_in = (unsigned char *)inPtr ? (Bytef *)inPtr : (Bytef *)zs; /* zero marker? */
10073 zs->avail_in = numBytes;
10074 }
10075 if (!zs->avail_out) {
10076 zs->next_out = (Bytef *)zs;
10077 zs->avail_out = UINT32_MAX;
10078 }
10079 zr = deflate(zs, Z_NO_FLUSH);
10080 if (Z_STREAM_END == zr)
10081 break;
10082 if (zr != Z_OK) {
10083 LOG("ZERR %d\n", zr);
10084 swd_zip_var.error = zr;
10085 } else {
10086 if (zs->total_in == numBytes) {
10087 break;
10088 }
10089 }
10090 }
10091 zr = Z_OK;
10092 //now flush the stream
10093 while (swd_zip_var.error >= 0) {
10094 if (!zs->avail_out) {
10095 zs->next_out = (Bytef *)zs;
10096 zs->avail_out = UINT32_MAX;
10097 }
10098 zr = deflate(zs, Z_FINISH);
10099 if (Z_STREAM_END == zr) {
10100 break;
10101 }
10102 if (zr != Z_OK) {
10103 LOG("ZERR %d\n", zr);
10104 swd_zip_var.error = zr;
10105 } else {
10106 if (zs->total_in == numBytes) {
10107 LOG("Total output size %d\n", swd_zip_var.outlen);
10108 break;
10109 }
10110 }
10111 }
10112
10113 return swd_zip_var.outlen;
10114 }
10115
10116 void IOPMrootDomain::takeStackshot(bool wdogTrigger, bool isOSXWatchdog, bool isSpinDump)
10117 {
10118 swd_hdr * hdr = NULL;
10119 int wdog_panic = -1;
10120 int cnt = 0;
10121 pid_t pid = 0;
10122 kern_return_t kr = KERN_SUCCESS;
10123 uint32_t flags;
10124
10125 char * dstAddr;
10126 uint32_t size;
10127 uint32_t bytesRemaining;
10128 unsigned bytesWritten = 0;
10129 unsigned totalBytes = 0;
10130 OSString * UUIDstring = NULL;
10131
10132 char failureStr[512];
10133 thread_t thread = NULL;
10134 const char * uuid;
10135
10136
10137 uint32_t bufSize;
10138 uint32_t initialStackSize;
10139
10140
10141
10142 failureStr[0] = 0;
10143 if (isSpinDump) {
10144 if (_systemTransitionType != kSystemTransitionSleep &&
10145 _systemTransitionType != kSystemTransitionWake)
10146 return;
10147
10148 if (gSpinDumpBufferFull)
10149 return;
10150 if (swd_spindump_buffer == NULL) {
10151 sleepWakeDebugSpinDumpMemAlloc();
10152 if (swd_spindump_buffer == NULL) return;
10153 }
10154
10155 bufSize = SWD_SPINDUMP_SIZE;
10156 initialStackSize = SWD_INITIAL_SPINDUMP_SIZE;
10157 hdr = (swd_hdr *)swd_spindump_buffer;
10158
10159 } else {
10160 if ( (kIOSleepWakeWdogOff & gIOKitDebug) || systemBooting || systemShutdown || gWillShutdown)
10161 return;
10162
10163 if (isOSXWatchdog) {
10164 snprintf(failureStr, sizeof(failureStr), "Stackshot Reason: ");
10165 snprintf(failureStr, sizeof(failureStr), "%smacOS watchdog triggered failure\n", failureStr);
10166 }
10167 else if (wdogTrigger) {
10168 if ((UUIDstring = OSDynamicCast(OSString, getProperty(kIOPMSleepWakeUUIDKey))) != NULL ) {
10169 uuid = UUIDstring->getCStringNoCopy();
10170 snprintf(failureStr, sizeof(failureStr), "UUID: %s\n", uuid);
10171 }
10172
10173 snprintf(failureStr, sizeof(failureStr), "%sStackshot Reason: ", failureStr);
10174 getFailureData(&thread, failureStr, sizeof(failureStr));
10175 if (PEGetCoprocessorVersion() >= kCoprocessorVersion2) {
10176 goto skip_stackshot;
10177 }
10178
10179 }
10180 else {
10181 snprintf(failureStr, sizeof(failureStr), "%sStackshot triggered for debugging stackshot collection.\n", failureStr);
10182 }
10183 // Take only one stackshot in this case.
10184 cnt = SWD_MAX_STACKSHOTS-1;
10185
10186 if (swd_buffer == NULL) {
10187 sleepWakeDebugMemAlloc();
10188 if (swd_buffer == NULL) return;
10189 }
10190 hdr = (swd_hdr *)swd_buffer;
10191
10192 bufSize = hdr->alloc_size;;
10193 initialStackSize = bufSize;
10194
10195 }
10196
10197
10198 if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock))
10199 return;
10200
10201
10202 dstAddr = (char*)hdr + hdr->spindump_offset;
10203 bytesRemaining = bufSize - hdr->spindump_offset;
10204
10205 DLOG("Taking snapshot. bytesRemaining: %d\n", bytesRemaining);
10206
10207 flags = STACKSHOT_KCDATA_FORMAT|STACKSHOT_NO_IO_STATS|STACKSHOT_SAVE_KEXT_LOADINFO|STACKSHOT_ACTIVE_KERNEL_THREADS_ONLY|STACKSHOT_THREAD_WAITINFO;
10208 while (kr == KERN_SUCCESS) {
10209
10210 if (cnt == 0) {
10211 /*
10212 * Take stackshot of all process on first sample. Size is restricted
10213 * to SWD_INITIAL_STACK_SIZE
10214 */
10215 pid = -1;
10216 size = (bytesRemaining > initialStackSize) ? initialStackSize : bytesRemaining;
10217 }
10218 else {
10219 /* Take sample of kernel threads only */
10220 pid = 0;
10221 size = bytesRemaining;
10222 }
10223
10224 kr = stack_snapshot_from_kernel(pid, dstAddr, size, flags, 0, &bytesWritten);
10225 DLOG("stack_snapshot_from_kernel returned 0x%x. pid: %d bufsize:0x%x flags:0x%x bytesWritten: %d\n",
10226 kr, pid, size, flags, bytesWritten);
10227 if (kr == KERN_INSUFFICIENT_BUFFER_SIZE) {
10228 if (pid == -1) {
10229 // Insufficient buffer when trying to take stackshot of user & kernel space threads.
10230 // Continue to take stackshot of just kernel threads
10231 ++cnt;
10232 kr = KERN_SUCCESS;
10233 continue;
10234 }
10235 else if (totalBytes == 0) {
10236 MSG("Failed to get stackshot(0x%x) bufsize:0x%x flags:0x%x\n", kr, size, flags);
10237 }
10238 }
10239
10240 dstAddr += bytesWritten;
10241 totalBytes += bytesWritten;
10242 bytesRemaining -= bytesWritten;
10243
10244 if (++cnt == SWD_MAX_STACKSHOTS) {
10245 break;
10246 }
10247 IOSleep(10); // 10 ms
10248 }
10249
10250 hdr->spindump_size = (bufSize - bytesRemaining - hdr->spindump_offset);
10251
10252 memset(hdr->reason, 0x20, sizeof(hdr->reason));
10253 if (isSpinDump) {
10254 snprintf(hdr->reason, sizeof(hdr->reason), "\nStackshot reason: Power State Change Delay\n\n");
10255 gRootDomain->swd_lock = 0;
10256 gSpinDumpBufferFull = true;
10257 return;
10258 }
10259
10260 // Compress stackshot and save to NVRAM
10261 {
10262 char *outbuf = (char *)swd_compressed_buffer;
10263 int outlen = 0;
10264 int num_chunks = 0;
10265 int max_chunks = 0;
10266 int leftover = 0;
10267 char nvram_var_name_buffer[20];
10268
10269 outlen = swd_compress((char*)hdr + hdr->spindump_offset, outbuf, bytesWritten);
10270
10271 if (outlen) {
10272 max_chunks = outlen / (2096 - 200);
10273 leftover = outlen % (2096 - 200);
10274
10275 if (max_chunks < 8) {
10276 for (num_chunks = 0; num_chunks < max_chunks; num_chunks++) {
10277 snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks+1);
10278 if (PEWriteNVRAMProperty(nvram_var_name_buffer, (outbuf + (num_chunks * (2096-200))), (2096 - 200)) == FALSE) {
10279 LOG("Failed to update NVRAM %d\n", num_chunks);
10280 break;
10281 }
10282 }
10283 if (leftover) {
10284 snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks+1);
10285 if (PEWriteNVRAMProperty(nvram_var_name_buffer, (outbuf + (num_chunks * (2096-200))), leftover) == FALSE) {
10286 LOG("Failed to update NVRAM with leftovers\n");
10287 }
10288 }
10289 }
10290 else {
10291 LOG("Compressed failure stackshot is too large. size=%d bytes\n", outlen);
10292 }
10293 }
10294 }
10295
10296 if (failureStr[0]) {
10297
10298 if (!isOSXWatchdog) {
10299 // append sleep-wake failure code
10300 snprintf(failureStr, sizeof(failureStr), "%s\nFailure code:: 0x%08x %08x\n",
10301 failureStr, pmTracer->getTraceData(), pmTracer->getTracePhase());
10302 if (PEWriteNVRAMProperty(kIOSleepWakeFailureString, failureStr, strlen(failureStr)) == false) {
10303 DLOG("Failed to write SleepWake failure string\n");
10304 }
10305 }
10306 else {
10307 if (PEWriteNVRAMProperty(kIOOSWatchdogFailureString, failureStr, strlen(failureStr)) == false) {
10308 DLOG("Failed to write OSWatchdog failure string\n");
10309 }
10310 }
10311 }
10312 gRootDomain->swd_lock = 0;
10313
10314 skip_stackshot:
10315 if (wdogTrigger) {
10316 PE_parse_boot_argn("swd_panic", &wdog_panic, sizeof(wdog_panic));
10317
10318 if ((wdog_panic == 1) || (PEGetCoprocessorVersion() >= kCoprocessorVersion2)) {
10319 if (thread) {
10320 panic_with_thread_context(0, NULL, DEBUGGER_OPTION_ATTEMPTCOREDUMPANDREBOOT, thread, "%s", failureStr);
10321 }
10322 else {
10323 panic_with_options(0, NULL, DEBUGGER_OPTION_ATTEMPTCOREDUMPANDREBOOT, "%s", failureStr);
10324 }
10325 return;
10326 }
10327 else if (swd_flags & SWD_BOOT_BY_SW_WDOG) {
10328 // If current boot is due to this watch dog trigger restart in previous boot,
10329 // then don't trigger again until at least 1 successful sleep & wake.
10330 if (!(sleepCnt && (displayWakeCnt || darkWakeCnt))) {
10331 LOG("Shutting down due to repeated Sleep/Wake failures\n");
10332 if (!tasksSuspended) {
10333 tasksSuspended = TRUE;
10334 tasks_system_suspend(true);
10335 }
10336 PEHaltRestart(kPEHaltCPU);
10337 return;
10338 }
10339 }
10340 }
10341
10342
10343 if (wdogTrigger) {
10344 LOG("Restarting to collect Sleep wake debug logs\n");
10345 if (!tasksSuspended) {
10346 tasksSuspended = TRUE;
10347 tasks_system_suspend(true);
10348 }
10349
10350 PEHaltRestart(kPERestartCPU);
10351 }
10352 else {
10353 saveFailureData2File();
10354 }
10355 }
10356
10357 void IOPMrootDomain::sleepWakeDebugMemAlloc( )
10358 {
10359 vm_size_t size = SWD_STACKSHOT_SIZE + SWD_COMPRESSED_BUFSIZE + SWD_ZLIB_BUFSIZE;
10360
10361 swd_hdr *hdr = NULL;
10362 void *bufPtr = NULL;
10363
10364 IOBufferMemoryDescriptor *memDesc = NULL;
10365
10366
10367 if ( kIOSleepWakeWdogOff & gIOKitDebug )
10368 return;
10369
10370 if (PEGetCoprocessorVersion() >= kCoprocessorVersion2)
10371 return;
10372
10373 if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock))
10374 return;
10375
10376 memDesc = IOBufferMemoryDescriptor::inTaskWithOptions(
10377 kernel_task, kIODirectionIn|kIOMemoryMapperNone,
10378 size);
10379 if (memDesc == NULL)
10380 {
10381 DLOG("Failed to allocate Memory descriptor for sleepWake debug\n");
10382 goto exit;
10383 }
10384
10385 bufPtr = memDesc->getBytesNoCopy();
10386
10387 // Carve out memory for zlib routines
10388 swd_zs_zmem = (vm_offset_t)bufPtr;
10389 bufPtr = (char *)bufPtr + SWD_ZLIB_BUFSIZE;
10390
10391 // Carve out memory for compressed stackshots
10392 swd_compressed_buffer = bufPtr;
10393 bufPtr = (char *)bufPtr + SWD_COMPRESSED_BUFSIZE;
10394
10395 // Remaining is used for holding stackshot
10396 hdr = (swd_hdr *)bufPtr;
10397 memset(hdr, 0, sizeof(swd_hdr));
10398
10399 hdr->signature = SWD_HDR_SIGNATURE;
10400 hdr->alloc_size = SWD_STACKSHOT_SIZE;
10401
10402 hdr->spindump_offset = sizeof(swd_hdr);
10403 swd_buffer = (void *)hdr;
10404 swd_memDesc = memDesc;
10405 DLOG("SleepWake debug buffer size:0x%x spindump offset:0x%x\n", hdr->alloc_size, hdr->spindump_offset);
10406
10407 exit:
10408 gRootDomain->swd_lock = 0;
10409 }
10410
10411 void IOPMrootDomain::sleepWakeDebugSpinDumpMemAlloc( )
10412 {
10413 vm_size_t size = SWD_SPINDUMP_SIZE;
10414
10415 swd_hdr *hdr = NULL;
10416
10417 IOBufferMemoryDescriptor *memDesc = NULL;
10418
10419 if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock))
10420 return;
10421
10422 memDesc = IOBufferMemoryDescriptor::inTaskWithOptions(
10423 kernel_task, kIODirectionIn|kIOMemoryMapperNone,
10424 SWD_SPINDUMP_SIZE);
10425
10426 if (memDesc == NULL)
10427 {
10428 DLOG("Failed to allocate Memory descriptor for sleepWake debug spindump\n");
10429 goto exit;
10430 }
10431
10432
10433 hdr = (swd_hdr *)memDesc->getBytesNoCopy();
10434 memset(hdr, 0, sizeof(swd_hdr));
10435
10436 hdr->signature = SWD_HDR_SIGNATURE;
10437 hdr->alloc_size = size;
10438
10439 hdr->spindump_offset = sizeof(swd_hdr);
10440 swd_spindump_buffer = (void *)hdr;
10441
10442 exit:
10443 gRootDomain->swd_lock = 0;
10444 }
10445
10446 void IOPMrootDomain::sleepWakeDebugEnableWdog()
10447 {
10448 }
10449
10450 bool IOPMrootDomain::sleepWakeDebugIsWdogEnabled()
10451 {
10452 return (!systemBooting && !systemShutdown && !gWillShutdown);
10453 }
10454
10455 void IOPMrootDomain::sleepWakeDebugSaveSpinDumpFile()
10456 {
10457 swd_hdr *hdr = NULL;
10458 errno_t error = EIO;
10459
10460 if (swd_spindump_buffer && gSpinDumpBufferFull) {
10461 hdr = (swd_hdr *)swd_spindump_buffer;
10462
10463 error = sleepWakeDebugSaveFile("/var/tmp/SleepWakeDelayStacks.dump",
10464 (char*)hdr+hdr->spindump_offset, hdr->spindump_size);
10465
10466 if (error) return;
10467
10468 sleepWakeDebugSaveFile("/var/tmp/SleepWakeDelayLog.dump",
10469 (char*)hdr+offsetof(swd_hdr, UUID),
10470 sizeof(swd_hdr)-offsetof(swd_hdr, UUID));
10471
10472 gSpinDumpBufferFull = false;
10473 }
10474 }
10475
10476 errno_t IOPMrootDomain::sleepWakeDebugSaveFile(const char *name, char *buf, int len)
10477 {
10478 struct vnode *vp = NULL;
10479 vfs_context_t ctx = vfs_context_create(vfs_context_current());
10480 kauth_cred_t cred = vfs_context_ucred(ctx);
10481 struct vnode_attr va;
10482 errno_t error = EIO;
10483
10484 if (vnode_open(name, (O_CREAT | FWRITE | O_NOFOLLOW),
10485 S_IRUSR|S_IRGRP|S_IROTH, VNODE_LOOKUP_NOFOLLOW, &vp, ctx) != 0)
10486 {
10487 LOG("Failed to open the file %s\n", name);
10488 swd_flags |= SWD_FILEOP_ERROR;
10489 goto exit;
10490 }
10491 VATTR_INIT(&va);
10492 VATTR_WANTED(&va, va_nlink);
10493 /* Don't dump to non-regular files or files with links. */
10494 if (vp->v_type != VREG ||
10495 vnode_getattr(vp, &va, ctx) || va.va_nlink != 1) {
10496 LOG("Bailing as this is not a regular file\n");
10497 swd_flags |= SWD_FILEOP_ERROR;
10498 goto exit;
10499 }
10500 VATTR_INIT(&va);
10501 VATTR_SET(&va, va_data_size, 0);
10502 vnode_setattr(vp, &va, ctx);
10503
10504
10505 if (buf != NULL) {
10506 error = vn_rdwr(UIO_WRITE, vp, buf, len, 0,
10507 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, vfs_context_proc(ctx));
10508 if (error != 0) {
10509 LOG("Failed to save sleep wake log. err 0x%x\n", error);
10510 swd_flags |= SWD_FILEOP_ERROR;
10511 }
10512 else {
10513 DLOG("Saved %d bytes to file %s\n",len, name);
10514 }
10515 }
10516
10517 exit:
10518 if (vp) vnode_close(vp, FWRITE, ctx);
10519 if (ctx) vfs_context_rele(ctx);
10520
10521 return error;
10522
10523 }
10524
10525
10526 #else
10527
10528 void IOPMrootDomain::sleepWakeDebugTrig(bool restart)
10529 {
10530 uint32_t wdog_panic = 1;
10531
10532 if (restart) {
10533 if (PE_parse_boot_argn("swd_panic", &wdog_panic, sizeof(wdog_panic)) &&
10534 (wdog_panic == 0)) {
10535 return;
10536 }
10537 panic("Sleep/Wake hang detected");
10538 return;
10539 }
10540 }
10541
10542 void IOPMrootDomain::takeStackshot(bool restart, bool isOSXWatchdog, bool isSpinDump)
10543 {
10544 #pragma unused(restart)
10545 #pragma unused(isOSXWatchdog)
10546 }
10547
10548 void IOPMrootDomain::sleepWakeDebugMemAlloc( )
10549 {
10550 }
10551 void IOPMrootDomain::saveFailureData2File( )
10552 {
10553 }
10554
10555 void IOPMrootDomain::sleepWakeDebugEnableWdog()
10556 {
10557 }
10558
10559 bool IOPMrootDomain::sleepWakeDebugIsWdogEnabled()
10560 {
10561 return false;
10562 }
10563
10564 errno_t IOPMrootDomain::sleepWakeDebugSaveFile(const char *name, char *buf, int len)
10565 {
10566 return 0;
10567 }
10568
10569 #endif
10570
mirror of XNU