Loading...
--- xnu/xnu-12377.121.6/iokit/Kernel/IOPMrootDomain.cpp
+++ xnu/xnu-6153.41.3/iokit/Kernel/IOPMrootDomain.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998-2021 Apple Inc. All rights reserved.
+ * Copyright (c) 1998-2019 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
@@ -25,10 +25,6 @@
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
-
-#define IOKIT_ENABLE_SHARED_PTR
-
-#include <libkern/c++/OSAllocation.h>
#include <libkern/c++/OSKext.h>
#include <libkern/c++/OSMetaClass.h>
#include <libkern/OSAtomic.h>
@@ -38,7 +34,6 @@
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOCPU.h>
-#include <IOKit/IOPlatformActions.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOTimeStamp.h>
#include <IOKit/pwr_mgt/IOPMlog.h>
@@ -54,14 +49,11 @@
#include <IOKit/IOCatalogue.h>
#include <IOKit/IOReportMacros.h>
#include <IOKit/IOLib.h>
-#include <IOKit/IOKitKeysPrivate.h>
-#include <IOKit/IOUserServer.h>
-#include <IOKit/IOBSD.h>
+#include <IOKit/IOKitKeys.h>
#include "IOKitKernelInternal.h"
#if HIBERNATION
#include <IOKit/IOHibernatePrivate.h>
-#endif /* HIBERNATION */
-#include <machine/machine_routines.h>
+#endif
#include <console/video_console.h>
#include <sys/syslog.h>
#include <sys/sysctl.h>
@@ -69,8 +61,6 @@
#include <sys/vnode_internal.h>
#include <sys/fcntl.h>
#include <os/log.h>
-#include <os/log_private.h>
-#include <pexpert/device_tree.h>
#include <pexpert/protos.h>
#include <AssertMacros.h>
@@ -79,18 +69,10 @@
#include "IOServicePMPrivate.h"
#include <libkern/zlib.h>
-#include <os/cpp_util.h>
-#include <os/atomic_private.h>
-#include <libkern/c++/OSBoundedArrayRef.h>
-
-#if DEVELOPMENT || DEBUG
-#include <os/system_event_log.h>
-#endif /* DEVELOPMENT || DEBUG */
__BEGIN_DECLS
#include <mach/shared_region.h>
#include <kern/clock.h>
-#include <vm/vm_pageout_xnu.h>
__END_DECLS
#if defined(__i386__) || defined(__x86_64__)
@@ -99,8 +81,6 @@
const char *processor_to_datastring(const char *prefix, processor_t target_processor);
__END_DECLS
#endif
-
-#define ARRAY_LEN(x) (sizeof (x) / sizeof (x[0]))
#define kIOPMrootDomainClass "IOPMrootDomain"
#define LOG_PREFIX "PMRD: "
@@ -124,7 +104,7 @@
#define DLOG(x...) do { \
if (kIOLogPMRootDomain & gIOKitDebug) \
- IOLog(LOG_PREFIX x); \
+ kprintf(LOG_PREFIX x); \
else \
os_log(OS_LOG_DEFAULT, LOG_PREFIX x); \
} while (false)
@@ -168,69 +148,43 @@
#define CAP_HIGHEST(c) \
((_highestCapability & (c)) != 0)
-#define CAP_PENDING(c) \
- ((_pendingCapability & (c)) != 0)
-
-// rdar://problem/9157444
#if defined(__i386__) || defined(__x86_64__)
-#define DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY 20
+#define DARK_TO_FULL_EVALUATE_CLAMSHELL 1
#endif
// Event types for IOPMPowerStateQueue::submitPowerEvent()
enum {
- kPowerEventFeatureChanged = 1, // 1
- kPowerEventReceivedPowerNotification, // 2
- kPowerEventSystemBootCompleted, // 3
- kPowerEventSystemShutdown, // 4
- kPowerEventUserDisabledSleep, // 5
+ kPowerEventFeatureChanged = 1, // 1
+ kPowerEventReceivedPowerNotification, // 2
+ kPowerEventSystemBootCompleted, // 3
+ kPowerEventSystemShutdown, // 4
+ kPowerEventUserDisabledSleep, // 5
kPowerEventRegisterSystemCapabilityClient, // 6
kPowerEventRegisterKernelCapabilityClient, // 7
- kPowerEventPolicyStimulus, // 8
- kPowerEventAssertionCreate, // 9
- kPowerEventAssertionRelease, // 10
- kPowerEventAssertionSetLevel, // 11
- kPowerEventQueueSleepWakeUUID, // 12
- kPowerEventPublishSleepWakeUUID, // 13
- kPowerEventSetDisplayPowerOn, // 14
- kPowerEventPublishWakeType, // 15
- kPowerEventAOTEvaluate, // 16
- kPowerEventRunModeRequest // 17
+ kPowerEventPolicyStimulus, // 8
+ kPowerEventAssertionCreate, // 9
+ kPowerEventAssertionRelease, // 10
+ kPowerEventAssertionSetLevel, // 11
+ kPowerEventQueueSleepWakeUUID, // 12
+ kPowerEventPublishSleepWakeUUID, // 13
+ kPowerEventSetDisplayPowerOn // 14
};
// For evaluatePolicy()
// List of stimuli that affects the root domain policy.
enum {
- kStimulusDisplayWranglerSleep, // 0
- kStimulusDisplayWranglerWake, // 1
- kStimulusAggressivenessChanged, // 2
- kStimulusDemandSystemSleep, // 3
- kStimulusAllowSystemSleepChanged, // 4
- kStimulusDarkWakeActivityTickle, // 5
- kStimulusDarkWakeEntry, // 6
- kStimulusDarkWakeReentry, // 7
- kStimulusDarkWakeEvaluate, // 8
- kStimulusNoIdleSleepPreventers, // 9
- kStimulusEnterUserActiveState, // 10
- kStimulusLeaveUserActiveState // 11
-};
-
-// Internal power state change reasons
-// Must be less than kIOPMSleepReasonClamshell=101
-enum {
- kCPSReasonNone = 0, // 0
- kCPSReasonInit, // 1
- kCPSReasonWake, // 2
- kCPSReasonIdleSleepPrevent, // 3
- kCPSReasonIdleSleepAllow, // 4
- kCPSReasonPowerOverride, // 5
- kCPSReasonPowerDownCancel, // 6
- kCPSReasonAOTExit, // 7
- kCPSReasonAdjustPowerState, // 8
- kCPSReasonDarkWakeCannotSleep, // 9
- kCPSReasonIdleSleepEnabled, // 10
- kCPSReasonEvaluatePolicy, // 11
- kCPSReasonSustainFullWake, // 12
- kCPSReasonPMInternals = (kIOPMSleepReasonClamshell - 1)
+ kStimulusDisplayWranglerSleep, // 0
+ kStimulusDisplayWranglerWake, // 1
+ kStimulusAggressivenessChanged, // 2
+ kStimulusDemandSystemSleep, // 3
+ kStimulusAllowSystemSleepChanged, // 4
+ kStimulusDarkWakeActivityTickle, // 5
+ kStimulusDarkWakeEntry, // 6
+ kStimulusDarkWakeReentry, // 7
+ kStimulusDarkWakeEvaluate, // 8
+ kStimulusNoIdleSleepPreventers, // 9
+ kStimulusEnterUserActiveState, // 10
+ kStimulusLeaveUserActiveState // 11
};
extern "C" {
@@ -246,66 +200,63 @@
static void pmEventTimeStamp(uint64_t *recordTS);
static void powerButtonUpCallout( thread_call_param_t, thread_call_param_t );
static void powerButtonDownCallout( thread_call_param_t, thread_call_param_t );
-static OSPtr<const OSSymbol> copyKextIdentifierWithAddress(vm_address_t address);
-
-static int IOPMConvertSecondsToCalendar(clock_sec_t secs, IOPMCalendarStruct * dt);
-static clock_sec_t IOPMConvertCalendarToSeconds(const IOPMCalendarStruct * dt);
+
+static int IOPMConvertSecondsToCalendar(long secs, IOPMCalendarStruct * dt);
+static long IOPMConvertCalendarToSeconds(const IOPMCalendarStruct * dt);
#define YMDTF "%04d/%02d/%d %02d:%02d:%02d"
#define YMDT(cal) ((int)(cal)->year), (cal)->month, (cal)->day, (cal)->hour, (cal)->minute, (cal)->second
// "IOPMSetSleepSupported" callPlatformFunction name
-static OSSharedPtr<const OSSymbol> sleepSupportedPEFunction;
-static OSSharedPtr<const OSSymbol> sleepMessagePEFunction;
-static OSSharedPtr<const OSSymbol> gIOPMWakeTypeUserKey;
-
-static OSSharedPtr<const OSSymbol> gIOPMPSExternalConnectedKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSExternalChargeCapableKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSBatteryInstalledKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSIsChargingKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAtWarnLevelKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAtCriticalLevelKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSCurrentCapacityKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSMaxCapacityKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSDesignCapacityKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSTimeRemainingKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAmperageKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSVoltageKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSCycleCountKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSMaxErrKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterInfoKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSLocationKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSErrorConditionKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSManufacturerKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSManufactureDateKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSModelKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSSerialKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSLegacyBatteryInfoKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSBatteryHealthKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSHealthConfidenceKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSCapacityEstimatedKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSBatteryChargeStatusKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSBatteryTemperatureKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSChargerConfigurationKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsIDKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsWattsKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsRevisionKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsSerialNumberKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsFamilyKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsAmperageKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsDescriptionKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsPMUConfigurationKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsSourceIDKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsErrorFlagsKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsSharedSourceKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSAdapterDetailsCloakedKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSInvalidWakeSecondsKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSPostChargeWaitSecondsKey;
-static OSSharedPtr<const OSSymbol> gIOPMPSPostDishargeWaitSecondsKey;
+static const OSSymbol *sleepSupportedPEFunction = NULL;
+static const OSSymbol *sleepMessagePEFunction = NULL;
+
+static const OSSymbol * gIOPMPSExternalConnectedKey;
+static const OSSymbol * gIOPMPSExternalChargeCapableKey;
+static const OSSymbol * gIOPMPSBatteryInstalledKey;
+static const OSSymbol * gIOPMPSIsChargingKey;
+static const OSSymbol * gIOPMPSAtWarnLevelKey;
+static const OSSymbol * gIOPMPSAtCriticalLevelKey;
+static const OSSymbol * gIOPMPSCurrentCapacityKey;
+static const OSSymbol * gIOPMPSMaxCapacityKey;
+static const OSSymbol * gIOPMPSDesignCapacityKey;
+static const OSSymbol * gIOPMPSTimeRemainingKey;
+static const OSSymbol * gIOPMPSAmperageKey;
+static const OSSymbol * gIOPMPSVoltageKey;
+static const OSSymbol * gIOPMPSCycleCountKey;
+static const OSSymbol * gIOPMPSMaxErrKey;
+static const OSSymbol * gIOPMPSAdapterInfoKey;
+static const OSSymbol * gIOPMPSLocationKey;
+static const OSSymbol * gIOPMPSErrorConditionKey;
+static const OSSymbol * gIOPMPSManufacturerKey;
+static const OSSymbol * gIOPMPSManufactureDateKey;
+static const OSSymbol * gIOPMPSModelKey;
+static const OSSymbol * gIOPMPSSerialKey;
+static const OSSymbol * gIOPMPSLegacyBatteryInfoKey;
+static const OSSymbol * gIOPMPSBatteryHealthKey;
+static const OSSymbol * gIOPMPSHealthConfidenceKey;
+static const OSSymbol * gIOPMPSCapacityEstimatedKey;
+static const OSSymbol * gIOPMPSBatteryChargeStatusKey;
+static const OSSymbol * gIOPMPSBatteryTemperatureKey;
+static const OSSymbol * gIOPMPSAdapterDetailsKey;
+static const OSSymbol * gIOPMPSChargerConfigurationKey;
+static const OSSymbol * gIOPMPSAdapterDetailsIDKey;
+static const OSSymbol * gIOPMPSAdapterDetailsWattsKey;
+static const OSSymbol * gIOPMPSAdapterDetailsRevisionKey;
+static const OSSymbol * gIOPMPSAdapterDetailsSerialNumberKey;
+static const OSSymbol * gIOPMPSAdapterDetailsFamilyKey;
+static const OSSymbol * gIOPMPSAdapterDetailsAmperageKey;
+static const OSSymbol * gIOPMPSAdapterDetailsDescriptionKey;
+static const OSSymbol * gIOPMPSAdapterDetailsPMUConfigurationKey;
+static const OSSymbol * gIOPMPSAdapterDetailsSourceIDKey;
+static const OSSymbol * gIOPMPSAdapterDetailsErrorFlagsKey;
+static const OSSymbol * gIOPMPSAdapterDetailsSharedSourceKey;
+static const OSSymbol * gIOPMPSAdapterDetailsCloakedKey;
+static const OSSymbol * gIOPMPSInvalidWakeSecondsKey;
+static const OSSymbol * gIOPMPSPostChargeWaitSecondsKey;
+static const OSSymbol * gIOPMPSPostDishargeWaitSecondsKey;
#define kIOSleepSupportedKey "IOSleepSupported"
#define kIOPMSystemCapabilitiesKey "System Capabilities"
-#define kIOPMSystemDefaultOverrideKey "SystemPowerProfileOverrideDict"
#define kIORequestWranglerIdleKey "IORequestIdle"
#define kDefaultWranglerIdlePeriod 1000 // in milliseconds
@@ -319,24 +270,22 @@
| kIOPMSupportedOnUPS)
#define kLocalEvalClamshellCommand (1 << 15)
-#define kIdleSleepRetryInterval (3 * 60 * 1000)
-
-// Minimum time in milliseconds after AP wake that we allow idle timer to expire.
-// We impose this minimum to avoid race conditions in the AP wake path where
-// userspace clients are not able to acquire power assertions before the idle timer expires.
-#if XNU_TARGET_OS_IOS
-#define kMinimumTimeBeforeIdleSleep 3000
-#else
-#define kMinimumTimeBeforeIdleSleep 1000
-#endif
-
-#define DISPLAY_WRANGLER_PRESENT (!NO_KERNEL_HID)
+#define kIdleSleepRetryInterval (3 * 60)
enum {
kWranglerPowerStateMin = 0,
kWranglerPowerStateSleep = 2,
kWranglerPowerStateDim = 3,
kWranglerPowerStateMax = 4
+};
+
+enum {
+ OFF_STATE = 0,
+ RESTART_STATE = 1,
+ SLEEP_STATE = 2,
+ AOT_STATE = 3,
+ ON_STATE = 4,
+ NUM_POWER_STATES
};
const char *
@@ -375,9 +324,15 @@
.outputPowerCharacter = kIOPMSleep,
.inputPowerRequirement = SLEEP_POWER },
{ .version = 1,
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
.capabilityFlags = kIOPMAOTCapability,
.outputPowerCharacter = kIOPMAOTPower,
.inputPowerRequirement = ON_POWER },
+#else /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+ .capabilityFlags = 0,
+ .outputPowerCharacter = 0,
+ .inputPowerRequirement = 0xFFFFFFFF },
+#endif /* (defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
{ .version = 1,
.capabilityFlags = kIOPMPowerOn,
.outputPowerCharacter = kIOPMPowerOn,
@@ -450,8 +405,8 @@
uint32_t options;
uint32_t dataType;
union {
- OSSharedPtr<IOService> service;
- AggressivesRecord record;
+ IOService * service;
+ AggressivesRecord record;
} data;
};
@@ -481,7 +436,6 @@
kPMChildPreventSystemSleep,
kPMCPUAssertion,
kPMPCIUnsupported,
- kPMDKNotReady,
};
const char *
@@ -495,7 +449,6 @@
SYSTEM_SLEEP_PREVENTER( kPMChildPreventSystemSleep ),
SYSTEM_SLEEP_PREVENTER( kPMCPUAssertion ),
SYSTEM_SLEEP_PREVENTER( kPMPCIUnsupported ),
- SYSTEM_SLEEP_PREVENTER( kPMDKNotReady ),
{ 0, NULL }
};
return IOFindNameForValue(preventer, systemSleepPreventers);
@@ -503,68 +456,35 @@
// gDarkWakeFlags
enum {
- kDarkWakeFlagPromotionNone = 0x0000,
- kDarkWakeFlagPromotionEarly = 0x0001, // promote before gfx clamp
- kDarkWakeFlagPromotionLate = 0x0002, // promote after gfx clamp
- kDarkWakeFlagPromotionMask = 0x0003,
+ kDarkWakeFlagHIDTickleEarly = 0x01,// hid tickle before gfx suppression
+ kDarkWakeFlagHIDTickleLate = 0x02,// hid tickle after gfx suppression
+ kDarkWakeFlagHIDTickleNone = 0x03,// hid tickle is not posted
+ kDarkWakeFlagHIDTickleMask = 0x03,
kDarkWakeFlagAlarmIsDark = 0x0100,
- kDarkWakeFlagAudioNotSuppressed = 0x0200,
- kDarkWakeFlagUserWakeWorkaround = 0x1000
+ kDarkWakeFlagGraphicsPowerState1 = 0x0200,
+ kDarkWakeFlagAudioNotSuppressed = 0x0400
};
-// gClamshellFlags
-// The workaround for 9157444 is enabled at compile time using the
-// DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY macro and is not represented below.
-enum {
- kClamshell_WAR_38378787 = 0x00000001,
- kClamshell_WAR_47715679 = 0x00000002,
- kClamshell_WAR_58009435 = 0x00000004
-};
-
-// acceptSystemWakeEvents()
-enum {
- kAcceptSystemWakeEvents_Disable = 0,
- kAcceptSystemWakeEvents_Enable,
- kAcceptSystemWakeEvents_Reenable
-};
-
static IOPMrootDomain * gRootDomain;
-static IORootParent * gPatriarch;
static IONotifier * gSysPowerDownNotifier = NULL;
static UInt32 gSleepOrShutdownPending = 0;
static UInt32 gWillShutdown = 0;
static UInt32 gPagingOff = 0;
static UInt32 gSleepWakeUUIDIsSet = false;
static uint32_t gAggressivesState = 0;
-uint32_t gHaltTimeMaxLog;
-uint32_t gHaltTimeMaxPanic;
+static uint32_t gHaltTimeMaxLog;
+static uint32_t gHaltTimeMaxPanic;
IOLock * gHaltLogLock;
static char * gHaltLog;
enum { kHaltLogSize = 2048 };
static size_t gHaltLogPos;
static uint64_t gHaltStartTime;
-static char gKextNameBuf[64];
-static size_t gKextNamePos;
-static bool gKextNameEnd;
+
uuid_string_t bootsessionuuid_string;
-#if defined(XNU_TARGET_OS_OSX)
-#if DISPLAY_WRANGLER_PRESENT
-static uint32_t gDarkWakeFlags = kDarkWakeFlagPromotionNone;
-#elif defined(__arm64__)
-// Enable temporary full wake promotion workarounds
-static uint32_t gDarkWakeFlags = kDarkWakeFlagUserWakeWorkaround;
-#else
-// Enable full wake promotion workarounds
-static uint32_t gDarkWakeFlags = kDarkWakeFlagUserWakeWorkaround;
-#endif
-#else /* !defined(XNU_TARGET_OS_OSX) */
-static uint32_t gDarkWakeFlags = kDarkWakeFlagPromotionEarly;
-#endif /* !defined(XNU_TARGET_OS_OSX) */
-
+static uint32_t gDarkWakeFlags = kDarkWakeFlagHIDTickleNone;
static uint32_t gNoIdleFlag = 0;
-static uint32_t gSleepDisabledFlag = 0;
static uint32_t gSwdPanic = 1;
static uint32_t gSwdSleepTimeout = 0;
static uint32_t gSwdWakeTimeout = 0;
@@ -574,61 +494,26 @@
static uint32_t swd_panic_phase;
#endif
-static uint32_t gClamshellFlags = 0
-#if defined(__i386__) || defined(__x86_64__)
- | kClamshell_WAR_58009435
-#endif
-;
#if HIBERNATION
-
-#if defined(__arm64__)
-static IOReturn
-defaultSleepPolicyHandler(void *ctx, const IOPMSystemSleepPolicyVariables *vars, IOPMSystemSleepParameters *params)
-{
- uint32_t sleepType = kIOPMSleepTypeDeepIdle;
-
- assert(vars->signature == kIOPMSystemSleepPolicySignature);
- assert(vars->version == kIOPMSystemSleepPolicyVersion);
-
- // Hibernation enabled and either user forced hibernate or low battery sleep
- if ((vars->hibernateMode & kIOHibernateModeOn) &&
- (((vars->hibernateMode & kIOHibernateModeSleep) == 0) ||
- (vars->sleepFactors & kIOPMSleepFactorBatteryLow))) {
- sleepType = kIOPMSleepTypeHibernate;
- }
- params->version = kIOPMSystemSleepParametersVersion;
- params->sleepType = sleepType;
- return kIOReturnSuccess;
-}
-static IOPMSystemSleepPolicyHandler gSleepPolicyHandler = &defaultSleepPolicyHandler;
-#else /* defined(__arm64__) */
static IOPMSystemSleepPolicyHandler gSleepPolicyHandler = NULL;
-#endif /* defined(__arm64__) */
-
static IOPMSystemSleepPolicyVariables * gSleepPolicyVars = NULL;
static void * gSleepPolicyTarget;
#endif
struct timeval gIOLastSleepTime;
struct timeval gIOLastWakeTime;
-AbsoluteTime gIOLastWakeAbsTime;
-AbsoluteTime gIOLastSleepAbsTime;
struct timeval gIOLastUserSleepTime;
static char gWakeReasonString[128];
-static char gBootReasonString[80];
-static char gShutdownReasonString[80];
-static uint64_t gShutdownTime;
static bool gWakeReasonSysctlRegistered = false;
-static bool gBootReasonSysctlRegistered = false;
-static bool gShutdownReasonSysctlRegistered = false;
-static bool gWillShutdownSysctlRegistered = false;
+static AbsoluteTime gIOLastWakeAbsTime;
+static AbsoluteTime gIOLastSleepAbsTime;
static AbsoluteTime gUserActiveAbsTime;
static AbsoluteTime gUserInactiveAbsTime;
-#if defined(__i386__) || defined(__x86_64__) || (defined(__arm64__) && HIBERNATION)
+#if defined(__i386__) || defined(__x86_64__)
static bool gSpinDumpBufferFull = false;
#endif
@@ -645,8 +530,8 @@
static int gPMHaltDepth;
static uint32_t gPMHaltMessageType;
static IOLock * gPMHaltLock = NULL;
-static OSSharedPtr<OSArray> gPMHaltArray;
-static OSSharedPtr<const OSSymbol> gPMHaltClientAcknowledgeKey;
+static OSArray * gPMHaltArray = NULL;
+static const OSSymbol * gPMHaltClientAcknowledgeKey = NULL;
static bool gPMQuiesced;
// Constants used as arguments to IOPMrootDomain::informCPUStateChange
@@ -657,11 +542,11 @@
kInformableCount = 2
};
-OSSharedPtr<const OSSymbol> gIOPMStatsResponseTimedOut;
-OSSharedPtr<const OSSymbol> gIOPMStatsResponseCancel;
-OSSharedPtr<const OSSymbol> gIOPMStatsResponseSlow;
-OSSharedPtr<const OSSymbol> gIOPMStatsResponsePrompt;
-OSSharedPtr<const OSSymbol> gIOPMStatsDriverPSChangeSlow;
+const OSSymbol *gIOPMStatsResponseTimedOut;
+const OSSymbol *gIOPMStatsResponseCancel;
+const OSSymbol *gIOPMStatsResponseSlow;
+const OSSymbol *gIOPMStatsResponsePrompt;
+const OSSymbol *gIOPMStatsDriverPSChangeSlow;
#define kBadPMFeatureID 0
@@ -696,7 +581,7 @@
IOPMSettingControllerCallback func;
OSObject *target;
uintptr_t refcon;
- OSDataAllocation<uint32_t> publishedFeatureID;
+ uint32_t *publishedFeatureID;
uint32_t settingCount;
bool disabled;
@@ -712,7 +597,7 @@
const OSSymbol *settings[],
OSObject **handle_obj);
- IOReturn dispatchPMSetting(const OSSymbol *type, OSObject *object);
+ void dispatchPMSetting(const OSSymbol *type, OSObject *object);
void clientHandleFreed(void);
};
@@ -742,7 +627,7 @@
public:
typedef enum { kPowerChangeStart, kPowerChangeCompleted } change_t;
- static OSPtr<PMTraceWorker> tracer( IOPMrootDomain * );
+ static PMTraceWorker *tracer( IOPMrootDomain * );
void tracePCIPowerChange(change_t, IOService *, uint32_t, uint32_t);
void tracePoint(uint8_t phase);
void traceDetail(uint32_t detail);
@@ -759,7 +644,7 @@
private:
IOPMrootDomain *owner;
IOLock *pmTraceWorkerLock;
- OSSharedPtr<OSArray> pciDeviceBitMappings;
+ OSArray *pciDeviceBitMappings;
uint8_t addedToRegistry;
uint8_t tracePhase;
@@ -769,90 +654,6 @@
uint8_t coreGraphicsData;
};
-struct IOPMAssertionLog {
- IOPMAssertionLogData data;
-
- mach_port_t notificationPort;
- uint64_t notificationThreshold;
-
-public:
- IOReturn
- setNotificationThreshold(uint64_t threshold)
- {
- if (threshold > ARRAY_LEN(data.intervals)) {
- return kIOReturnBadArgument;
- }
- notificationThreshold = threshold;
- return kIOReturnSuccess;
- }
-
- IOReturn
- setNotificationPort(mach_port_t port)
- {
- if (port != MACH_PORT_NULL && notificationPort != MACH_PORT_NULL) {
- return kIOReturnExclusiveAccess;
- }
-
- notificationPort = port;
- return kIOReturnSuccess;
- }
-
- void
- notify()
- {
- if (notificationPort == MACH_PORT_NULL) {
- return;
- }
-
- mach_msg_header_t msg;
- msg.msgh_bits = MACH_MSGH_BITS_SET(MACH_MSG_TYPE_COPY_SEND, 0, 0, 0);
- msg.msgh_id = 0;
- msg.msgh_size = sizeof(mach_msg_header_t);
- msg.msgh_local_port = MACH_PORT_NULL;
- msg.msgh_remote_port = notificationPort;
- (void)mach_msg_send_from_kernel_with_options(&msg, msg.msgh_size, MACH64_SEND_TIMEOUT, MACH_MSG_TIMEOUT_NONE);
- }
-
- void
- addInterval(IOPMDriverAssertionID id, uint64_t create_timestamp, uint64_t delete_timestamp)
- {
- IOPMAssertionLogData::Interval& interval = data.intervals[data.intervals_pos++ % ARRAY_LEN(data.intervals)];
- interval.id = id;
- interval.create_timestamp = create_timestamp;
- interval.delete_timestamp = delete_timestamp;
-
- if (notificationPort && notificationThreshold == (data.intervals_pos % ARRAY_LEN(data.intervals))) {
- notify();
- }
- }
-
- void
- addName(IOPMDriverAssertionID id, const char *name)
- {
- IOPMAssertionLogData::Properties& prop = data.props[data.props_pos++ % ARRAY_LEN(data.props)];
- prop.id = id;
- strlcpy(prop.name, name, sizeof(prop.name));
- }
-};
-
-/*
- * this should be treated as POD, as it's byte-copied around
- * and we cannot rely on d'tor firing at the right time
- */
-struct PMAssertStruct {
- IOPMDriverAssertionID id;
- IOPMDriverAssertionType assertionBits;
- uint64_t createdTime;
- uint64_t modifiedTime;
- const OSSymbol *ownerString;
- IOService *ownerService;
- uint64_t registryEntryID;
- IOPMDriverAssertionLevel level;
- uint64_t assertCPUStartTime;
- uint64_t assertCPUDuration;
-};
-OSDefineValueObjectForDependentType(PMAssertStruct)
-
/*
* PMAssertionsTracker
* Tracks kernel and user space PM assertions
@@ -868,39 +669,41 @@
IOReturn setAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
IOReturn setUserAssertionLevels(IOPMDriverAssertionType);
- OSSharedPtr<OSArray> copyAssertionsArray(void);
+ OSArray *copyAssertionsArray(void);
IOPMDriverAssertionType getActivatedAssertions(void);
IOPMDriverAssertionLevel getAssertionLevel(IOPMDriverAssertionType);
- IOReturn handleCreateAssertion(OSValueObject<PMAssertStruct> *);
+ IOReturn handleCreateAssertion(OSData *);
IOReturn handleReleaseAssertion(IOPMDriverAssertionID);
IOReturn handleSetAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
IOReturn handleSetUserAssertionLevels(void * arg0);
void publishProperties(void);
- void reportCPUBitAccounting(void);
- PMAssertStruct *detailsForID(IOPMDriverAssertionID, int *);
private:
+ typedef struct {
+ IOPMDriverAssertionID id;
+ IOPMDriverAssertionType assertionBits;
+ uint64_t createdTime;
+ uint64_t modifiedTime;
+ const OSSymbol *ownerString;
+ IOService *ownerService;
+ uint64_t registryEntryID;
+ IOPMDriverAssertionLevel level;
+ } PMAssertStruct;
+
uint32_t tabulateProducerCount;
uint32_t tabulateConsumerCount;
- uint64_t maxAssertCPUDuration;
- uint64_t maxAssertCPUEntryId;
-
+ PMAssertStruct *detailsForID(IOPMDriverAssertionID, int *);
void tabulate(void);
- void updateCPUBitAccounting(PMAssertStruct * assertStruct);
IOPMrootDomain *owner;
- OSSharedPtr<OSArray> assertionsArray;
+ OSArray *assertionsArray;
IOLock *assertionsArrayLock;
IOPMDriverAssertionID issuingUniqueID __attribute__((aligned(8)));/* aligned for atomic access */
IOPMDriverAssertionType assertionsKernel;
IOPMDriverAssertionType assertionsUser;
IOPMDriverAssertionType assertionsCombined;
-
- IOPMAssertionLog assertionsLog;
-
- friend class IOPMrootDomain;
};
OSDefineMetaClassAndFinalStructors(PMAssertionsTracker, OSObject);
@@ -960,13 +763,13 @@
extern "C" IONotifier *
registerSleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
{
- return gRootDomain->registerInterest( gIOGeneralInterest, handler, self, ref ).detach();
+ return gRootDomain->registerInterest( gIOGeneralInterest, handler, self, ref );
}
extern "C" IONotifier *
registerPrioritySleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
{
- return gRootDomain->registerInterest( gIOPriorityPowerStateInterest, handler, self, ref ).detach();
+ return gRootDomain->registerInterest( gIOPriorityPowerStateInterest, handler, self, ref );
}
extern "C" IOReturn
@@ -1050,12 +853,12 @@
extern uint32_t gFSState;
extern "C" void
-IOSystemShutdownNotification(int howto, int stage)
+IOSystemShutdownNotification(int stage)
{
uint64_t startTime;
if (kIOSystemShutdownNotificationStageRootUnmount == stage) {
-#if defined(XNU_TARGET_OS_OSX)
+#if !CONFIG_EMBEDDED
uint64_t nano, millis;
startTime = mach_absolute_time();
IOService::getPlatform()->waitQuiet(30 * NSEC_PER_SEC);
@@ -1064,19 +867,7 @@
if (gHaltTimeMaxLog && (millis >= gHaltTimeMaxLog)) {
printf("waitQuiet() for unmount %qd ms\n", millis);
}
-#endif /* defined(XNU_TARGET_OS_OSX) */
- return;
- }
-
- if (kIOSystemShutdownNotificationTerminateDEXTs == stage) {
- uint64_t nano, millis;
- startTime = mach_absolute_time();
- IOServicePH::systemHalt(howto);
- absolutetime_to_nanoseconds(mach_absolute_time() - startTime, &nano);
- millis = nano / NSEC_PER_MSEC;
- if (true || (gHaltTimeMaxLog && (millis >= gHaltTimeMaxLog))) {
- printf("IOServicePH::systemHalt took %qd ms\n", millis);
- }
+#endif
return;
}
@@ -1084,7 +875,7 @@
IOLockLock(gHaltLogLock);
if (!gHaltLog) {
- gHaltLog = IONewData(char, (vm_size_t)kHaltLogSize);
+ gHaltLog = IONew(char, kHaltLogSize);
gHaltStartTime = mach_absolute_time();
if (gHaltLog) {
halt_log_putc('\n');
@@ -1104,6 +895,7 @@
gRootDomain->handlePlatformHaltRestart(kPEPagingOff);
}
}
+
extern "C" int sync_internal(void);
@@ -1180,30 +972,27 @@
IOPMrootDomain::updateConsoleUsers(void)
{
IOService::updateConsoleUsers(NULL, kIOMessageSystemHasPoweredOn);
- updateTasksSuspend(kTasksSuspendUnsuspended, kTasksSuspendNoChange);
-}
-
-bool
-IOPMrootDomain::updateTasksSuspend(int newTasksSuspended, int newAOTTasksSuspended)
+ if (tasksSuspended) {
+ tasksSuspended = FALSE;
+ updateTasksSuspend();
+ }
+}
+
+void
+IOPMrootDomain::updateTasksSuspend(void)
{
bool newSuspend;
- WAKEEVENT_LOCK();
- if (newTasksSuspended != kTasksSuspendNoChange) {
- tasksSuspended = (newTasksSuspended != kTasksSuspendUnsuspended);
- }
- if (newAOTTasksSuspended != kTasksSuspendNoChange) {
- _aotTasksSuspended = (newAOTTasksSuspended != kTasksSuspendUnsuspended);
- }
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
newSuspend = (tasksSuspended || _aotTasksSuspended);
+#else /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+ newSuspend = tasksSuspended;
+#endif /* (defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
if (newSuspend == tasksSuspendState) {
- WAKEEVENT_UNLOCK();
- return false;
+ return;
}
tasksSuspendState = newSuspend;
- WAKEEVENT_UNLOCK();
tasks_system_suspend(newSuspend);
- return true;
}
//******************************************************************************
@@ -1211,7 +1000,7 @@
static void
disk_sync_callout( thread_call_param_t p0, thread_call_param_t p1 )
{
- IOPMrootDomain * rootDomain = (IOPMrootDomain *) p0;
+ IOService * rootDomain = (IOService *) p0;
uint32_t notifyRef = (uint32_t)(uintptr_t) p1;
uint32_t powerState = rootDomain->getPowerState();
@@ -1229,7 +1018,9 @@
else {
IOHibernateSystemPostWake(false);
- rootDomain->sleepWakeDebugSaveSpinDumpFile();
+ if (gRootDomain) {
+ gRootDomain->sleepWakeDebugSaveSpinDumpFile();
+ }
}
#endif
@@ -1273,18 +1064,18 @@
return sysctl_io_opaque(req, &t, sizeof(t), NULL);
} else {
struct user32_timeval t = {};
- t.tv_sec = (typeof(t.tv_sec))swt->tv_sec;
+ t.tv_sec = swt->tv_sec;
t.tv_usec = swt->tv_usec;
return sysctl_io_opaque(req, &t, sizeof(t), NULL);
}
}
static SYSCTL_PROC(_kern, OID_AUTO, sleeptime,
- CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
&gIOLastUserSleepTime, 0, sysctl_sleepwaketime, "S,timeval", "");
static SYSCTL_PROC(_kern, OID_AUTO, waketime,
- CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
&gIOLastWakeTime, 0, sysctl_sleepwaketime, "S,timeval", "");
SYSCTL_QUAD(_kern, OID_AUTO, wake_abs_time, CTLFLAG_RD | CTLFLAG_LOCKED, &gIOLastWakeAbsTime, "");
@@ -1293,15 +1084,11 @@
SYSCTL_QUAD(_kern, OID_AUTO, userinactive_abs_time, CTLFLAG_RD | CTLFLAG_LOCKED, &gUserInactiveAbsTime, "");
static int
-sysctl_willshutdown SYSCTL_HANDLER_ARGS
-{
- int new_value, changed, error;
-
- if (!gWillShutdownSysctlRegistered) {
- return ENOENT;
- }
-
- error = sysctl_io_number(req, gWillShutdown, sizeof(int), &new_value, &changed);
+sysctl_willshutdown
+(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
+{
+ int new_value, changed;
+ int error = sysctl_io_number(req, gWillShutdown, sizeof(int), &new_value, &changed);
if (changed) {
if (!gWillShutdown && (new_value == 1)) {
IOPMRootDomainWillShutdown();
@@ -1313,10 +1100,13 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, willshutdown,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_willshutdown, "I", "");
-#if defined(XNU_TARGET_OS_OSX)
+extern struct sysctl_oid sysctl__kern_iokittest;
+extern struct sysctl_oid sysctl__debug_iokit;
+
+#if !CONFIG_EMBEDDED
static int
sysctl_progressmeterenable
@@ -1351,14 +1141,14 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, progressmeterenable,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_progressmeterenable, "I", "");
static SYSCTL_PROC(_kern, OID_AUTO, progressmeter,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_progressmeter, "I", "");
-#endif /* defined(XNU_TARGET_OS_OSX) */
+#endif /* !CONFIG_EMBEDDED */
@@ -1379,7 +1169,7 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, consoleoptions,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_consoleoptions, "I", "");
@@ -1390,7 +1180,7 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, progressoptions,
- CTLTYPE_STRUCT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
+ CTLTYPE_STRUCT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
NULL, 0, sysctl_progressoptions, "S,vc_progress_user_options", "");
@@ -1400,157 +1190,41 @@
char wr[sizeof(gWakeReasonString)];
wr[0] = '\0';
- if (gRootDomain && gWakeReasonSysctlRegistered) {
+ if (gRootDomain) {
gRootDomain->copyWakeReasonString(wr, sizeof(wr));
- } else {
- return ENOENT;
}
return sysctl_io_string(req, wr, 0, 0, NULL);
}
SYSCTL_PROC(_kern, OID_AUTO, wakereason,
- CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_wakereason, "A", "wakereason");
-
-static int
-sysctl_bootreason SYSCTL_HANDLER_ARGS
-{
- if (!os_atomic_load(&gBootReasonSysctlRegistered, acquire)) {
- return ENOENT;
- }
-
- return sysctl_io_string(req, gBootReasonString, 0, 0, NULL);
-}
-
-SYSCTL_PROC(_kern, OID_AUTO, bootreason,
- CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
- NULL, 0, sysctl_bootreason, "A", "");
-
-static int
-sysctl_shutdownreason SYSCTL_HANDLER_ARGS
-{
- char sr[sizeof(gShutdownReasonString)];
-
- sr[0] = '\0';
- if (gRootDomain && gShutdownReasonSysctlRegistered) {
- gRootDomain->copyShutdownReasonString(sr, sizeof(sr));
- } else {
- return ENOENT;
- }
-
- return sysctl_io_string(req, sr, 0, 0, NULL);
-}
-
-SYSCTL_PROC(_kern, OID_AUTO, shutdownreason,
- CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
- NULL, 0, sysctl_shutdownreason, "A", "shutdownreason");
-
-// This value is meant to represent the last time the device shut down
-// in a unit of the PMU driver's choosing see rdar://138590268 for details
-static int
-sysctl_shutdowntime SYSCTL_HANDLER_ARGS
-{
- uint64_t shutdownTime = 0;
-
- if (gRootDomain && gShutdownReasonSysctlRegistered) {
- gRootDomain->copyShutdownTime(&shutdownTime);
- } else {
- return ENOENT;
- }
-
- return SYSCTL_OUT(req, &shutdownTime, sizeof(shutdownTime));
-}
-
-SYSCTL_PROC(_kern, OID_AUTO, shutdowntime,
- CTLTYPE_QUAD | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
- NULL, 0, sysctl_shutdowntime, "Q", "shutdowntime");
static int
sysctl_targettype SYSCTL_HANDLER_ARGS
{
IOService * root;
- OSSharedPtr<OSObject> obj;
+ OSObject * obj;
OSData * data;
char tt[32];
tt[0] = '\0';
root = IOService::getServiceRoot();
if (root && (obj = root->copyProperty(gIODTTargetTypeKey))) {
- if ((data = OSDynamicCast(OSData, obj.get()))) {
+ if ((data = OSDynamicCast(OSData, obj))) {
strlcpy(tt, (const char *) data->getBytesNoCopy(), sizeof(tt));
}
+ obj->release();
}
return sysctl_io_string(req, tt, 0, 0, NULL);
}
SYSCTL_PROC(_hw, OID_AUTO, targettype,
- CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_targettype, "A", "targettype");
-static SECURITY_READ_ONLY_LATE(char*) jetsam_properties_product_type_string = NULL;
-static SECURITY_READ_ONLY_LATE(size_t) jetsam_properties_product_type_string_len = 0;
-
-/*
- * SecureDTLookupEntry() is only guaranteed to work before PE_init_iokit(),
- * so we load the jetsam_properties_product_type string (if available) in a startup handler.
- */
-__startup_func
-static void
-sysctl_load_jetsam_properties_product_type(void)
-{
- DTEntry node;
- void const *value = NULL;
- unsigned int size = 0;
-
- if (kSuccess != SecureDTLookupEntry(nullptr, "/product", &node)) {
- return;
- }
-
- if (kSuccess != SecureDTGetProperty(node, "jetsam-properties-product-type", (void const **) &value, &size)) {
- return;
- }
-
- if (size == 0) {
- return;
- }
-
- jetsam_properties_product_type_string = (char *) zalloc_permanent(size, ZALIGN_NONE);
- if (jetsam_properties_product_type_string == NULL) {
- return;
- }
-
- memcpy(jetsam_properties_product_type_string, value, size);
- jetsam_properties_product_type_string_len = size;
-}
-STARTUP(SYSCTL, STARTUP_RANK_MIDDLE, sysctl_load_jetsam_properties_product_type);
-
-static int
-sysctl_jetsam_properties_product_type SYSCTL_HANDLER_ARGS
-{
- if (jetsam_properties_product_type_string != NULL) {
- return SYSCTL_OUT(req, jetsam_properties_product_type_string, jetsam_properties_product_type_string_len);
- }
-
- IOService * root;
- OSSharedPtr<OSObject> obj;
- OSData * data;
- char tt[32];
-
- tt[0] = '\0';
- root = IOService::getServiceRoot();
- if (root && (obj = root->copyProperty(gIODTTargetTypeKey))) {
- if ((data = OSDynamicCast(OSData, obj.get()))) {
- strlcpy(tt, (const char *) data->getBytesNoCopy(), sizeof(tt));
- }
- }
- return sysctl_io_string(req, tt, 0, 0, NULL);
-}
-
-SYSCTL_PROC(_hw, OID_AUTO, jetsam_properties_product_type,
- CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED,
- NULL, 0, sysctl_jetsam_properties_product_type, "A", "jetsam_properties_product_type");
-
+static SYSCTL_INT(_debug, OID_AUTO, darkwake, CTLFLAG_RW, &gDarkWakeFlags, 0, "");
static SYSCTL_INT(_debug, OID_AUTO, noidle, CTLFLAG_RW, &gNoIdleFlag, 0, "");
static SYSCTL_INT(_debug, OID_AUTO, swd_sleep_timeout, CTLFLAG_RW, &gSwdSleepTimeout, 0, "");
static SYSCTL_INT(_debug, OID_AUTO, swd_wake_timeout, CTLFLAG_RW, &gSwdWakeTimeout, 0, "");
@@ -1558,12 +1232,9 @@
static SYSCTL_INT(_debug, OID_AUTO, swd_panic, CTLFLAG_RW, &gSwdPanic, 0, "");
#if DEVELOPMENT || DEBUG
static SYSCTL_INT(_debug, OID_AUTO, swd_panic_phase, CTLFLAG_RW, &swd_panic_phase, 0, "");
-#if defined(XNU_TARGET_OS_OSX)
-static SYSCTL_INT(_debug, OID_AUTO, clamshell, CTLFLAG_RW, &gClamshellFlags, 0, "");
-static SYSCTL_INT(_debug, OID_AUTO, darkwake, CTLFLAG_RW, &gDarkWakeFlags, 0, "");
-#endif /* defined(XNU_TARGET_OS_OSX) */
-#endif /* DEVELOPMENT || DEBUG */
-
+#endif
+
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
//******************************************************************************
// AOT
@@ -1574,16 +1245,13 @@
return ENOENT;
}
if (NULL == gRootDomain->_aotMetrics) {
- IOPMAOTMetrics nullMetrics = {};
- return sysctl_io_opaque(req, &nullMetrics, sizeof(IOPMAOTMetrics), NULL);
+ return ENOENT;
}
return sysctl_io_opaque(req, gRootDomain->_aotMetrics, sizeof(IOPMAOTMetrics), NULL);
}
-TUNABLE_DT_WRITEABLE(uint32_t, gAOTMode, "/product/iopm",
- "aot-mode", "aot_mode", 0, TUNABLE_DT_NONE);
static SYSCTL_PROC(_kern, OID_AUTO, aotmetrics,
- CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
+ CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
NULL, 0, sysctl_aotmetrics, "S,IOPMAOTMetrics", "");
@@ -1599,11 +1267,14 @@
unsigned int oldCount;
if (mode && !gRootDomain->_aotMetrics) {
- gRootDomain->_aotMetrics = IOMallocType(IOPMAOTMetrics);
+ gRootDomain->_aotMetrics = IONewZero(IOPMAOTMetrics, 1);
+ if (!gRootDomain->_aotMetrics) {
+ return ENOMEM;
+ }
}
oldCount = gRootDomain->idleSleepPreventersCount();
- gRootDomain->_aotMode = (mode & kIOPMAOTModeMask);
+ gRootDomain->_aotMode = mode;
gRootDomain->updatePreventIdleSleepListInternal(NULL, false, oldCount);
return 0;
});
@@ -1629,7 +1300,7 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, aotmodebits,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED,
NULL, 0, sysctl_aotmodebits, "I", "");
static int
@@ -1654,46 +1325,39 @@
}
static SYSCTL_PROC(_kern, OID_AUTO, aotmode,
- CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
+ CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN | CTLFLAG_LOCKED | CTLFLAG_ANYBODY,
NULL, 0, sysctl_aotmode, "I", "");
-TUNABLE_DT(uint32_t, gAOTLingerTimeMS, "/product/iopm",
- "aot-linger-time-ms", "aot_linger_time_ms", 800, TUNABLE_DT_NONE);
-
-// Low Power Wake tunables
-TUNABLE_DT_WRITEABLE(uint64_t, gLPWFlags, "/product/iopm",
- "low-power-wake", "low_power_wake", false, TUNABLE_DT_NONE);
-static SYSCTL_QUAD(_kern, OID_AUTO, lowpowerwake, CTLFLAG_RW | CTLFLAG_LOCKED,
- &gLPWFlags, "Low Power Wake");
-
-//******************************************************************************
-
-static OSSharedPtr<const OSSymbol> gIOPMSettingAutoWakeCalendarKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingAutoWakeSecondsKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingAutoPowerCalendarKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingAutoPowerSecondsKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingDebugWakeRelativeKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingDebugPowerRelativeKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingMaintenanceWakeCalendarKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingSleepServiceWakeCalendarKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingSilentRunningKey;
-static OSSharedPtr<const OSSymbol> gIOPMUserTriggeredFullWakeKey;
-static OSSharedPtr<const OSSymbol> gIOPMUserIsActiveKey;
-static OSSharedPtr<const OSSymbol> gIOPMSettingLowLatencyAudioModeKey;
+//******************************************************************************
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+
+
+static const OSSymbol * gIOPMSettingAutoWakeCalendarKey;
+static const OSSymbol * gIOPMSettingAutoWakeSecondsKey;
+static const OSSymbol * gIOPMSettingAutoPowerCalendarKey;
+static const OSSymbol * gIOPMSettingAutoPowerSecondsKey;
+static const OSSymbol * gIOPMSettingDebugWakeRelativeKey;
+static const OSSymbol * gIOPMSettingDebugPowerRelativeKey;
+static const OSSymbol * gIOPMSettingMaintenanceWakeCalendarKey;
+static const OSSymbol * gIOPMSettingSleepServiceWakeCalendarKey;
+static const OSSymbol * gIOPMSettingSilentRunningKey;
+static const OSSymbol * gIOPMUserTriggeredFullWakeKey;
+static const OSSymbol * gIOPMUserIsActiveKey;
//******************************************************************************
// start
//
//******************************************************************************
-#define kRootDomainSettingsCount 21
-#define kRootDomainNoPublishSettingsCount 4
+#define kRootDomainSettingsCount 19
+#define kRootDomainNoPublishSettingsCount 3
bool
IOPMrootDomain::start( IOService * nub )
{
- OSSharedPtr<OSIterator> psIterator;
- OSSharedPtr<OSDictionary> tmpDict;
+ OSIterator *psIterator;
+ OSDictionary *tmpDict;
+ IORootParent * patriarch;
super::start(nub);
@@ -1709,7 +1373,6 @@
gIOPMSettingSilentRunningKey = OSSymbol::withCStringNoCopy(kIOPMSettingSilentRunningKey);
gIOPMUserTriggeredFullWakeKey = OSSymbol::withCStringNoCopy(kIOPMUserTriggeredFullWakeKey);
gIOPMUserIsActiveKey = OSSymbol::withCStringNoCopy(kIOPMUserIsActiveKey);
- gIOPMSettingLowLatencyAudioModeKey = OSSymbol::withCStringNoCopy(kIOPMSettingLowLatencyAudioModeKey);
gIOPMStatsResponseTimedOut = OSSymbol::withCString(kIOPMStatsResponseTimedOut);
gIOPMStatsResponseCancel = OSSymbol::withCString(kIOPMStatsResponseCancel);
@@ -1719,9 +1382,8 @@
sleepSupportedPEFunction = OSSymbol::withCString("IOPMSetSleepSupported");
sleepMessagePEFunction = OSSymbol::withCString("IOPMSystemSleepMessage");
- gIOPMWakeTypeUserKey = OSSymbol::withCStringNoCopy(kIOPMRootDomainWakeTypeUser);
-
- OSSharedPtr<const OSSymbol> settingsArr[kRootDomainSettingsCount] =
+
+ const OSSymbol *settingsArr[kRootDomainSettingsCount] =
{
OSSymbol::withCString(kIOPMSettingSleepOnPowerButtonKey),
gIOPMSettingAutoWakeSecondsKey,
@@ -1732,7 +1394,6 @@
gIOPMSettingDebugPowerRelativeKey,
OSSymbol::withCString(kIOPMSettingWakeOnRingKey),
OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey),
- OSSymbol::withCString(kIOPMSettingRestartOnPowerConnectKey),
OSSymbol::withCString(kIOPMSettingWakeOnClamshellKey),
OSSymbol::withCString(kIOPMSettingWakeOnACChangeKey),
OSSymbol::withCString(kIOPMSettingTimeZoneOffsetKey),
@@ -1743,24 +1404,16 @@
OSSymbol::withCString(kIOPMSettingProModeControl),
OSSymbol::withCString(kIOPMSettingProModeDefer),
gIOPMSettingSilentRunningKey,
- gIOPMSettingLowLatencyAudioModeKey,
};
- OSSharedPtr<const OSSymbol> noPublishSettingsArr[kRootDomainNoPublishSettingsCount] =
+ const OSSymbol *noPublishSettingsArr[kRootDomainNoPublishSettingsCount] =
{
OSSymbol::withCString(kIOPMSettingProModeControl),
OSSymbol::withCString(kIOPMSettingProModeDefer),
gIOPMSettingSilentRunningKey,
- gIOPMSettingLowLatencyAudioModeKey,
};
-#if DEVELOPMENT || DEBUG
-#if defined(XNU_TARGET_OS_OSX)
PE_parse_boot_argn("darkwake", &gDarkWakeFlags, sizeof(gDarkWakeFlags));
- PE_parse_boot_argn("clamshell", &gClamshellFlags, sizeof(gClamshellFlags));
-#endif /* defined(XNU_TARGET_OS_OSX) */
-#endif /* DEVELOPMENT || DEBUG */
-
PE_parse_boot_argn("noidle", &gNoIdleFlag, sizeof(gNoIdleFlag));
PE_parse_boot_argn("swd_sleeptimeout", &gSwdSleepTimeout, sizeof(gSwdSleepTimeout));
PE_parse_boot_argn("swd_waketimeout", &gSwdWakeTimeout, sizeof(gSwdWakeTimeout));
@@ -1768,15 +1421,6 @@
PE_parse_boot_argn("haltmspanic", &gHaltTimeMaxPanic, sizeof(gHaltTimeMaxPanic));
PE_parse_boot_argn("haltmslog", &gHaltTimeMaxLog, sizeof(gHaltTimeMaxLog));
- _aotMode = gAOTMode;
- _aotLingerTime = gAOTLingerTimeMS;
- _aotMetrics = _aotMode ? IOMallocType(IOPMAOTMetrics) : NULL;
-
- // read noidle setting from Device Tree
- if (PE_get_default("no-idle", &gNoIdleFlag, sizeof(gNoIdleFlag))) {
- DLOG("Setting gNoIdleFlag to %u from device tree\n", gNoIdleFlag);
- }
-
queue_init(&aggressivesQueue);
aggressivesThreadCall = thread_call_allocate(handleAggressivesFunction, this);
aggressivesData = OSData::withCapacity(
@@ -1807,12 +1451,11 @@
&updateConsoleUsersCallout,
(thread_call_param_t) this);
-#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
- fullWakeThreadCall = thread_call_allocate_with_options(
+#if DARK_TO_FULL_EVALUATE_CLAMSHELL
+ fullWakeThreadCall = thread_call_allocate(
OSMemberFunctionCast(thread_call_func_t, this,
&IOPMrootDomain::fullWakeDelayedWork),
- (thread_call_param_t) this, THREAD_CALL_PRIORITY_KERNEL,
- THREAD_CALL_OPTIONS_ONCE);
+ (thread_call_param_t) this);
#endif
setProperty(kIOSleepSupportedKey, true);
@@ -1826,20 +1469,14 @@
userDisabledAllSleep = false;
systemBooting = true;
idleSleepEnabled = false;
- idleSleepRevertible = true;
sleepSlider = 0;
idleSleepTimerPending = false;
wrangler = NULL;
- clamshellClosed = false;
- clamshellExists = false;
-#if DISPLAY_WRANGLER_PRESENT
- clamshellDisabled = true;
-#else
- clamshellDisabled = false;
-#endif
- clamshellIgnoreClose = false;
+ clamshellClosed = false;
+ clamshellExists = false;
+ clamshellDisabled = true;
acAdaptorConnected = true;
- clamshellSleepDisableMask = 0;
+ clamshellSleepDisabled = false;
gWakeReasonString[0] = '\0';
// Initialize to user active.
@@ -1847,7 +1484,7 @@
fullWakeReason = kFullWakeReasonLocalUser;
userIsActive = userWasActive = true;
clock_get_uptime(&gUserActiveAbsTime);
- setProperty(gIOPMUserIsActiveKey.get(), kOSBooleanTrue);
+ setProperty(gIOPMUserIsActiveKey, kOSBooleanTrue);
// Set the default system capabilities at boot.
_currentCapability = kIOPMSystemCapabilityCPU |
@@ -1876,14 +1513,8 @@
idxPMCPULimitedPower = kCPUUnknownIndex;
tmpDict = OSDictionary::withCapacity(1);
- setProperty(kRootDomainSupportedFeatures, tmpDict.get());
-
- // Set a default "SystemPowerProfileOverrideDict" for platform
- // drivers without any overrides.
- if (!propertyExists(kIOPMSystemDefaultOverrideKey)) {
- tmpDict = OSDictionary::withCapacity(1);
- setProperty(kIOPMSystemDefaultOverrideKey, tmpDict.get());
- }
+ setProperty(kRootDomainSupportedFeatures, tmpDict);
+ tmpDict->release();
settingsCallbacks = OSDictionary::withCapacity(1);
@@ -1908,9 +1539,6 @@
PMinit(); // creates gIOPMWorkLoop
gIOPMWorkLoop = getIOPMWorkloop();
- commandGate = IOCommandGate::commandGate(gIOPMWorkLoop);
- gIOPMWorkLoop->addEventSource(commandGate.get());
-
// Create IOPMPowerStateQueue used to queue external power
// events, and to handle those events on the PM work loop.
pmPowerStateQueue = IOPMPowerStateQueue::PMPowerStateQueue(
@@ -1918,70 +1546,99 @@
&IOPMrootDomain::dispatchPowerEvent));
gIOPMWorkLoop->addEventSource(pmPowerStateQueue);
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+ _aotMode = 0;
_aotTimerES = IOTimerEventSource::timerEventSource(this,
OSMemberFunctionCast(IOTimerEventSource::Action,
this, &IOPMrootDomain::aotEvaluate));
- gIOPMWorkLoop->addEventSource(_aotTimerES.get());
-
- // Avoid publishing service early so gIOPMWorkLoop is
- // guaranteed to be initialized by rootDomain.
- publishPMRootDomain();
+ gIOPMWorkLoop->addEventSource(_aotTimerES);
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
// create our power parent
- gPatriarch = new IORootParent;
- gPatriarch->init();
- gPatriarch->attach(this);
- gPatriarch->start(this);
- gPatriarch->addPowerChild(this);
+ patriarch = new IORootParent;
+ patriarch->init();
+ patriarch->attach(this);
+ patriarch->start(this);
+ patriarch->addPowerChild(this);
registerPowerDriver(this, ourPowerStates, NUM_POWER_STATES);
- changePowerStateWithTagToPriv(ON_STATE, kCPSReasonInit);
+ changePowerStateToPriv(ON_STATE);
// install power change handler
gSysPowerDownNotifier = registerPrioritySleepWakeInterest( &sysPowerDownHandler, this, NULL);
-#if DISPLAY_WRANGLER_PRESENT
+#if !NO_KERNEL_HID
+ // Register for a notification when IODisplayWrangler is published
+ if ((tmpDict = serviceMatching("IODisplayWrangler"))) {
+ _displayWranglerNotifier = addMatchingNotification(
+ gIOPublishNotification, tmpDict,
+ (IOServiceMatchingNotificationHandler) & displayWranglerMatchPublished,
+ this, NULL);
+ tmpDict->release();
+ }
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+
+ wranglerIdleSettings = NULL;
+ OSNumber * wranglerIdlePeriod = NULL;
wranglerIdleSettings = OSDictionary::withCapacity(1);
- OSSharedPtr<OSNumber> wranglerIdlePeriod = OSNumber::withNumber(kDefaultWranglerIdlePeriod, 32);
+ wranglerIdlePeriod = OSNumber::withNumber(kDefaultWranglerIdlePeriod, 32);
if (wranglerIdleSettings && wranglerIdlePeriod) {
wranglerIdleSettings->setObject(kIORequestWranglerIdleKey,
- wranglerIdlePeriod.get());
- }
-
-#endif /* DISPLAY_WRANGLER_PRESENT */
-
- lowLatencyAudioNotifierDict = OSDictionary::withCapacity(2);
- lowLatencyAudioNotifyStateSym = OSSymbol::withCString("LowLatencyAudioNotifyState");
- lowLatencyAudioNotifyTimestampSym = OSSymbol::withCString("LowLatencyAudioNotifyTimestamp");
- lowLatencyAudioNotifyStateVal = OSNumber::withNumber(0ull, 32);
- lowLatencyAudioNotifyTimestampVal = OSNumber::withNumber(0ull, 64);
-
- if (lowLatencyAudioNotifierDict && lowLatencyAudioNotifyStateSym && lowLatencyAudioNotifyTimestampSym &&
- lowLatencyAudioNotifyStateVal && lowLatencyAudioNotifyTimestampVal) {
- lowLatencyAudioNotifierDict->setObject(lowLatencyAudioNotifyStateSym.get(), lowLatencyAudioNotifyStateVal.get());
- lowLatencyAudioNotifierDict->setObject(lowLatencyAudioNotifyTimestampSym.get(), lowLatencyAudioNotifyTimestampVal.get());
- }
-
- OSSharedPtr<const OSSymbol> ucClassName = OSSymbol::withCStringNoCopy("RootDomainUserClient");
- setProperty(gIOUserClientClassKey, const_cast<OSObject *>(static_cast<const OSObject *>(ucClassName.get())));
+ wranglerIdlePeriod);
+ }
+
+ if (wranglerIdlePeriod) {
+ wranglerIdlePeriod->release();
+ }
+#endif
+
+ const OSSymbol *ucClassName = OSSymbol::withCStringNoCopy("RootDomainUserClient");
+ setProperty(gIOUserClientClassKey, (OSObject *) ucClassName);
+ ucClassName->release();
// IOBacklightDisplay can take a long time to load at boot, or it may
// not load at all if you're booting with clamshell closed. We publish
// 'DisplayDims' here redundantly to get it published early and at all.
- OSSharedPtr<OSDictionary> matching;
+ OSDictionary * matching;
matching = serviceMatching("IOPMPowerSource");
- psIterator = getMatchingServices(matching.get());
-
+ psIterator = getMatchingServices( matching );
+ if (matching) {
+ matching->release();
+ }
if (psIterator && psIterator->getNextObject()) {
// There's at least one battery on the system, so we publish
// 'DisplayDims' support for the LCD.
publishFeature("DisplayDims");
}
+ if (psIterator) {
+ psIterator->release();
+ }
// read swd_panic boot-arg
PE_parse_boot_argn("swd_panic", &gSwdPanic, sizeof(gSwdPanic));
- gWillShutdownSysctlRegistered = true;
+ sysctl_register_oid(&sysctl__kern_sleeptime);
+ sysctl_register_oid(&sysctl__kern_waketime);
+ sysctl_register_oid(&sysctl__kern_willshutdown);
+ sysctl_register_oid(&sysctl__kern_iokittest);
+ sysctl_register_oid(&sysctl__debug_iokit);
+ sysctl_register_oid(&sysctl__hw_targettype);
+
+#if !CONFIG_EMBEDDED
+ sysctl_register_oid(&sysctl__kern_progressmeterenable);
+ sysctl_register_oid(&sysctl__kern_progressmeter);
+ sysctl_register_oid(&sysctl__kern_wakereason);
+#endif /* !CONFIG_EMBEDDED */
+ sysctl_register_oid(&sysctl__kern_consoleoptions);
+ sysctl_register_oid(&sysctl__kern_progressoptions);
+
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+ sysctl_register_oid(&sysctl__kern_aotmode);
+ sysctl_register_oid(&sysctl__kern_aotmodebits);
+ sysctl_register_oid(&sysctl__kern_aotmetrics);
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
#if HIBERNATION
IOHibernateSystemInit(this);
@@ -2004,21 +1661,20 @@
{
IOReturn return_value = kIOReturnSuccess;
OSDictionary *dict = OSDynamicCast(OSDictionary, props_obj);
- OSBoolean *b = NULL;
- OSNumber *n = NULL;
- const OSSymbol *key = NULL;
- OSObject *obj = NULL;
- OSSharedPtr<OSCollectionIterator> iter;
+ OSBoolean *b;
+ OSNumber *n;
+ const OSSymbol *key;
+ OSObject *obj;
+ OSCollectionIterator * iter = NULL;
if (!dict) {
return kIOReturnBadArgument;
}
bool clientEntitled = false;
- {
- OSSharedPtr<OSObject> obj = IOUserClient::copyClientEntitlement(current_task(), kRootDomainEntitlementSetProperty);
- clientEntitled = (obj == kOSBooleanTrue);
- }
+ obj = IOUserClient::copyClientEntitlement(current_task(), kRootDomainEntitlementSetProperty);
+ clientEntitled = (obj == kOSBooleanTrue);
+ OSSafeReleaseNULL(obj);
if (!clientEntitled) {
const char * errorSuffix = NULL;
@@ -2026,12 +1682,12 @@
// IOPMSchedulePowerEvent() clients may not be entitled, but must be root.
// That API can set 6 possible keys that are checked below.
if ((dict->getCount() == 1) &&
- (dict->getObject(gIOPMSettingAutoWakeSecondsKey.get()) ||
- dict->getObject(gIOPMSettingAutoPowerSecondsKey.get()) ||
- dict->getObject(gIOPMSettingAutoWakeCalendarKey.get()) ||
- dict->getObject(gIOPMSettingAutoPowerCalendarKey.get()) ||
- dict->getObject(gIOPMSettingDebugWakeRelativeKey.get()) ||
- dict->getObject(gIOPMSettingDebugPowerRelativeKey.get()))) {
+ (dict->getObject(gIOPMSettingAutoWakeSecondsKey) ||
+ dict->getObject(gIOPMSettingAutoPowerSecondsKey) ||
+ dict->getObject(gIOPMSettingAutoWakeCalendarKey) ||
+ dict->getObject(gIOPMSettingAutoPowerCalendarKey) ||
+ dict->getObject(gIOPMSettingDebugWakeRelativeKey) ||
+ dict->getObject(gIOPMSettingDebugPowerRelativeKey))) {
return_value = IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator);
if (return_value != kIOReturnSuccess) {
errorSuffix = "privileged";
@@ -2042,41 +1698,32 @@
}
if (return_value != kIOReturnSuccess) {
- OSSharedPtr<OSString> procName(IOCopyLogNameForPID(proc_selfpid()), OSNoRetain);
+ OSString * procName = IOCopyLogNameForPID(proc_selfpid());
DLOG("%s failed, process %s is not %s\n", __func__,
procName ? procName->getCStringNoCopy() : "", errorSuffix);
+ OSSafeReleaseNULL(procName);
return return_value;
}
}
- OSSharedPtr<const OSSymbol> publish_simulated_battery_string = OSSymbol::withCString("SoftwareSimulatedBatteries");
- OSSharedPtr<const OSSymbol> boot_complete_string = OSSymbol::withCString("System Boot Complete");
- OSSharedPtr<const OSSymbol> sys_shutdown_string = OSSymbol::withCString("System Shutdown");
- OSSharedPtr<const OSSymbol> stall_halt_string = OSSymbol::withCString("StallSystemAtHalt");
- OSSharedPtr<const OSSymbol> battery_warning_disabled_string = OSSymbol::withCString("BatteryWarningsDisabled");
- OSSharedPtr<const OSSymbol> idle_seconds_string = OSSymbol::withCString("System Idle Seconds");
- OSSharedPtr<const OSSymbol> idle_milliseconds_string = OSSymbol::withCString("System Idle Milliseconds");
- OSSharedPtr<const OSSymbol> sleepdisabled_string = OSSymbol::withCString("SleepDisabled");
- OSSharedPtr<const OSSymbol> ondeck_sleepwake_uuid_string = OSSymbol::withCString(kIOPMSleepWakeUUIDKey);
- OSSharedPtr<const OSSymbol> loginwindow_progress_string = OSSymbol::withCString(kIOPMLoginWindowProgressKey);
- OSSharedPtr<const OSSymbol> coredisplay_progress_string = OSSymbol::withCString(kIOPMCoreDisplayProgressKey);
- OSSharedPtr<const OSSymbol> coregraphics_progress_string = OSSymbol::withCString(kIOPMCoreGraphicsProgressKey);
-#if DEBUG || DEVELOPMENT
- OSSharedPtr<const OSSymbol> clamshell_close_string = OSSymbol::withCString("IOPMTestClamshellClose");
- OSSharedPtr<const OSSymbol> clamshell_open_string = OSSymbol::withCString("IOPMTestClamshellOpen");
- OSSharedPtr<const OSSymbol> ac_detach_string = OSSymbol::withCString("IOPMTestACDetach");
- OSSharedPtr<const OSSymbol> ac_attach_string = OSSymbol::withCString("IOPMTestACAttach");
- OSSharedPtr<const OSSymbol> desktopmode_set_string = OSSymbol::withCString("IOPMTestDesktopModeSet");
- OSSharedPtr<const OSSymbol> desktopmode_remove_string = OSSymbol::withCString("IOPMTestDesktopModeRemove");
-#endif
-
+ const OSSymbol *publish_simulated_battery_string = OSSymbol::withCString("SoftwareSimulatedBatteries");
+ const OSSymbol *boot_complete_string = OSSymbol::withCString("System Boot Complete");
+ const OSSymbol *sys_shutdown_string = OSSymbol::withCString("System Shutdown");
+ const OSSymbol *stall_halt_string = OSSymbol::withCString("StallSystemAtHalt");
+ const OSSymbol *battery_warning_disabled_string = OSSymbol::withCString("BatteryWarningsDisabled");
+ const OSSymbol *idle_seconds_string = OSSymbol::withCString("System Idle Seconds");
+ const OSSymbol *sleepdisabled_string = OSSymbol::withCString("SleepDisabled");
+ const OSSymbol *ondeck_sleepwake_uuid_string = OSSymbol::withCString(kIOPMSleepWakeUUIDKey);
+ const OSSymbol *loginwindow_progress_string = OSSymbol::withCString(kIOPMLoginWindowProgressKey);
+ const OSSymbol *coredisplay_progress_string = OSSymbol::withCString(kIOPMCoreDisplayProgressKey);
+ const OSSymbol *coregraphics_progress_string = OSSymbol::withCString(kIOPMCoreGraphicsProgressKey);
#if HIBERNATION
- OSSharedPtr<const OSSymbol> hibernatemode_string = OSSymbol::withCString(kIOHibernateModeKey);
- OSSharedPtr<const OSSymbol> hibernatefile_string = OSSymbol::withCString(kIOHibernateFileKey);
- OSSharedPtr<const OSSymbol> hibernatefilemin_string = OSSymbol::withCString(kIOHibernateFileMinSizeKey);
- OSSharedPtr<const OSSymbol> hibernatefilemax_string = OSSymbol::withCString(kIOHibernateFileMaxSizeKey);
- OSSharedPtr<const OSSymbol> hibernatefreeratio_string = OSSymbol::withCString(kIOHibernateFreeRatioKey);
- OSSharedPtr<const OSSymbol> hibernatefreetime_string = OSSymbol::withCString(kIOHibernateFreeTimeKey);
+ const OSSymbol *hibernatemode_string = OSSymbol::withCString(kIOHibernateModeKey);
+ const OSSymbol *hibernatefile_string = OSSymbol::withCString(kIOHibernateFileKey);
+ const OSSymbol *hibernatefilemin_string = OSSymbol::withCString(kIOHibernateFileMinSizeKey);
+ const OSSymbol *hibernatefilemax_string = OSSymbol::withCString(kIOHibernateFileMaxSizeKey);
+ const OSSymbol *hibernatefreeratio_string = OSSymbol::withCString(kIOHibernateFreeRatioKey);
+ const OSSymbol *hibernatefreetime_string = OSSymbol::withCString(kIOHibernateFreeTimeKey);
#endif
iter = OSCollectionIterator::withCollection(dict);
@@ -2087,66 +1734,61 @@
while ((key = (const OSSymbol *) iter->getNextObject()) &&
(obj = dict->getObject(key))) {
- if (key->isEqualTo(publish_simulated_battery_string.get())) {
+ if (key->isEqualTo(publish_simulated_battery_string)) {
if (OSDynamicCast(OSBoolean, obj)) {
publishResource(key, kOSBooleanTrue);
}
- } else if (key->isEqualTo(idle_seconds_string.get())) {
+ } else if (key->isEqualTo(idle_seconds_string)) {
if ((n = OSDynamicCast(OSNumber, obj))) {
setProperty(key, n);
- idleMilliSeconds = n->unsigned32BitValue() * 1000;
- }
- } else if (key->isEqualTo(idle_milliseconds_string.get())) {
+ idleSeconds = n->unsigned32BitValue();
+ }
+ } else if (key->isEqualTo(boot_complete_string)) {
+ pmPowerStateQueue->submitPowerEvent(kPowerEventSystemBootCompleted);
+ } else if (key->isEqualTo(sys_shutdown_string)) {
+ if ((b = OSDynamicCast(OSBoolean, obj))) {
+ pmPowerStateQueue->submitPowerEvent(kPowerEventSystemShutdown, (void *) b);
+ }
+ } else if (key->isEqualTo(battery_warning_disabled_string)) {
+ setProperty(key, obj);
+ }
+#if HIBERNATION
+ else if (key->isEqualTo(hibernatemode_string) ||
+ key->isEqualTo(hibernatefilemin_string) ||
+ key->isEqualTo(hibernatefilemax_string) ||
+ key->isEqualTo(hibernatefreeratio_string) ||
+ key->isEqualTo(hibernatefreetime_string)) {
if ((n = OSDynamicCast(OSNumber, obj))) {
setProperty(key, n);
- idleMilliSeconds = n->unsigned32BitValue();
- }
- } else if (key->isEqualTo(boot_complete_string.get())) {
- pmPowerStateQueue->submitPowerEvent(kPowerEventSystemBootCompleted);
- } else if (key->isEqualTo(sys_shutdown_string.get())) {
- if ((b = OSDynamicCast(OSBoolean, obj))) {
- pmPowerStateQueue->submitPowerEvent(kPowerEventSystemShutdown, (void *) b);
- }
- } else if (key->isEqualTo(battery_warning_disabled_string.get())) {
- setProperty(key, obj);
- }
-#if HIBERNATION
- else if (key->isEqualTo(hibernatemode_string.get()) ||
- key->isEqualTo(hibernatefilemin_string.get()) ||
- key->isEqualTo(hibernatefilemax_string.get()) ||
- key->isEqualTo(hibernatefreeratio_string.get()) ||
- key->isEqualTo(hibernatefreetime_string.get())) {
- if ((n = OSDynamicCast(OSNumber, obj))) {
- setProperty(key, n);
- }
- } else if (key->isEqualTo(hibernatefile_string.get())) {
+ }
+ } else if (key->isEqualTo(hibernatefile_string)) {
OSString * str = OSDynamicCast(OSString, obj);
if (str) {
setProperty(key, str);
}
}
#endif
- else if (key->isEqualTo(sleepdisabled_string.get())) {
+ else if (key->isEqualTo(sleepdisabled_string)) {
if ((b = OSDynamicCast(OSBoolean, obj))) {
setProperty(key, b);
pmPowerStateQueue->submitPowerEvent(kPowerEventUserDisabledSleep, (void *) b);
}
- } else if (key->isEqualTo(ondeck_sleepwake_uuid_string.get())) {
+ } else if (key->isEqualTo(ondeck_sleepwake_uuid_string)) {
obj->retain();
pmPowerStateQueue->submitPowerEvent(kPowerEventQueueSleepWakeUUID, (void *)obj);
- } else if (key->isEqualTo(loginwindow_progress_string.get())) {
+ } else if (key->isEqualTo(loginwindow_progress_string)) {
if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
uint32_t data = n->unsigned32BitValue();
pmTracer->traceComponentWakeProgress(kIOPMLoginWindowProgress, data);
kdebugTrace(kPMLogComponentWakeProgress, 0, kIOPMLoginWindowProgress, data);
}
- } else if (key->isEqualTo(coredisplay_progress_string.get())) {
+ } else if (key->isEqualTo(coredisplay_progress_string)) {
if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
uint32_t data = n->unsigned32BitValue();
pmTracer->traceComponentWakeProgress(kIOPMCoreDisplayProgress, data);
kdebugTrace(kPMLogComponentWakeProgress, 0, kIOPMCoreDisplayProgress, data);
}
- } else if (key->isEqualTo(coregraphics_progress_string.get())) {
+ } else if (key->isEqualTo(coregraphics_progress_string)) {
if (pmTracer && (n = OSDynamicCast(OSNumber, obj))) {
uint32_t data = n->unsigned32BitValue();
pmTracer->traceComponentWakeProgress(kIOPMCoreGraphicsProgress, data);
@@ -2155,7 +1797,7 @@
} else if (key->isEqualTo(kIOPMDeepSleepEnabledKey) ||
key->isEqualTo(kIOPMDestroyFVKeyOnStandbyKey) ||
key->isEqualTo(kIOPMAutoPowerOffEnabledKey) ||
- key->isEqualTo(stall_halt_string.get())) {
+ key->isEqualTo(stall_halt_string)) {
if ((b = OSDynamicCast(OSBoolean, obj))) {
setProperty(key, b);
}
@@ -2168,125 +1810,102 @@
}
} else if (key->isEqualTo(kIOPMUserWakeAlarmScheduledKey)) {
if (kOSBooleanTrue == obj) {
- OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_userScheduledAlarmMask);
+ OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_userScheduledAlarm);
} else {
- OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_userScheduledAlarmMask);
- }
- DLOG("_userScheduledAlarmMask 0x%x\n", (uint32_t) _userScheduledAlarmMask);
- }
-#if DEBUG || DEVELOPMENT
- else if (key->isEqualTo(clamshell_close_string.get())) {
- DLOG("SetProperties: setting clamshell close\n");
- UInt32 msg = kIOPMClamshellClosed;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- } else if (key->isEqualTo(clamshell_open_string.get())) {
- DLOG("SetProperties: setting clamshell open\n");
- UInt32 msg = kIOPMClamshellOpened;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- } else if (key->isEqualTo(ac_detach_string.get())) {
- DLOG("SetProperties: setting ac detach\n");
- UInt32 msg = kIOPMSetACAdaptorConnected;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- } else if (key->isEqualTo(ac_attach_string.get())) {
- DLOG("SetProperties: setting ac attach\n");
- UInt32 msg = kIOPMSetACAdaptorConnected | kIOPMSetValue;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- } else if (key->isEqualTo(desktopmode_set_string.get())) {
- DLOG("SetProperties: setting desktopmode");
- UInt32 msg = kIOPMSetDesktopMode | kIOPMSetValue;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- } else if (key->isEqualTo(desktopmode_remove_string.get())) {
- DLOG("SetProperties: removing desktopmode\n");
- UInt32 msg = kIOPMSetDesktopMode;
- pmPowerStateQueue->submitPowerEvent(kPowerEventReceivedPowerNotification, (void *)(uintptr_t)msg);
- }
-#endif
+ OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_userScheduledAlarm);
+ }
+ DLOG("_userScheduledAlarm = 0x%x\n", (uint32_t) _userScheduledAlarm);
+ }
// Relay our allowed PM settings onto our registered PM clients
else if ((allowedPMSettings->getNextIndexOfObject(key, 0) != (unsigned int) -1)) {
return_value = setPMSetting(key, obj);
if (kIOReturnSuccess != return_value) {
break;
}
+
+ if (gIOPMSettingDebugWakeRelativeKey == key) {
+ if ((n = OSDynamicCast(OSNumber, obj)) &&
+ (_debugWakeSeconds = n->unsigned32BitValue())) {
+ OSBitOrAtomic(kIOPMAlarmBitDebugWake, &_scheduledAlarms);
+ } else {
+ _debugWakeSeconds = 0;
+ OSBitAndAtomic(~kIOPMAlarmBitDebugWake, &_scheduledAlarms);
+ }
+ DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
+ } else if (gIOPMSettingAutoWakeCalendarKey == key) {
+ OSData * data;
+ if ((data = OSDynamicCast(OSData, obj)) &&
+ (data->getLength() == sizeof(IOPMCalendarStruct))) {
+ const IOPMCalendarStruct * cs =
+ (const IOPMCalendarStruct *) data->getBytesNoCopy();
+ IOLog("gIOPMSettingAutoWakeCalendarKey " YMDTF "\n", YMDT(cs));
+ if (cs->year) {
+ _scheduledAlarmUTC = IOPMConvertCalendarToSeconds(cs);
+ OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_scheduledAlarms);
+ } else {
+ _scheduledAlarmUTC = 0;
+ OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_scheduledAlarms);
+ }
+ DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
+ }
+ }
} else {
DLOG("setProperties(%s) not handled\n", key->getCStringNoCopy());
}
}
exit:
+ if (publish_simulated_battery_string) {
+ publish_simulated_battery_string->release();
+ }
+ if (boot_complete_string) {
+ boot_complete_string->release();
+ }
+ if (sys_shutdown_string) {
+ sys_shutdown_string->release();
+ }
+ if (stall_halt_string) {
+ stall_halt_string->release();
+ }
+ if (battery_warning_disabled_string) {
+ battery_warning_disabled_string->release();
+ }
+ if (idle_seconds_string) {
+ idle_seconds_string->release();
+ }
+ if (sleepdisabled_string) {
+ sleepdisabled_string->release();
+ }
+ if (ondeck_sleepwake_uuid_string) {
+ ondeck_sleepwake_uuid_string->release();
+ }
+ if (loginwindow_progress_string) {
+ loginwindow_progress_string->release();
+ }
+ if (coredisplay_progress_string) {
+ coredisplay_progress_string->release();
+ }
+ if (coregraphics_progress_string) {
+ coregraphics_progress_string->release();
+ }
+#if HIBERNATION
+ if (hibernatemode_string) {
+ hibernatemode_string->release();
+ }
+ if (hibernatefile_string) {
+ hibernatefile_string->release();
+ }
+ if (hibernatefreeratio_string) {
+ hibernatefreeratio_string->release();
+ }
+ if (hibernatefreetime_string) {
+ hibernatefreetime_string->release();
+ }
+#endif
+ if (iter) {
+ iter->release();
+ }
return return_value;
-}
-
-#if HIBERNATION
-// MARK: -
-// MARK: setLockdownModeHibernation
-// ***************************************************************************
-void
-IOPMrootDomain::setLockdownModeHibernation(uint32_t status)
-{
- if (!gIOPMWorkLoop->inGate()) {
- gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::setLockdownModeHibernation),
- this, (void *)(uintptr_t) status);
- return;
- }
-
- ldmHibernateDisable = status;
- DLOG("ldmHibernateDisable %d\n", status);
- setProperty("IOPMLDMHibernationDisable", status);
-}
-#endif
-
-IOReturn
-IOPMrootDomain::getAssertionLog(IOPMAssertionLogData *outLog)
-{
- if (!gIOPMWorkLoop->inGate()) {
- return gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::getAssertionLog),
- this, (void *)(uintptr_t) outLog);
- }
-
- if (!pmAssertions) {
- return kIOReturnNotFound;
- }
-
- *outLog = pmAssertions->assertionsLog.data;
- return kIOReturnSuccess;
-}
-
-IOReturn
-IOPMrootDomain::setAssertionLogNotificationPort(mach_port_t port)
-{
- if (!gIOPMWorkLoop->inGate()) {
- return gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::setAssertionLogNotificationPort),
- this, (void *)(uintptr_t) port);
- }
-
- if (!pmAssertions) {
- return kIOReturnNotFound;
- }
-
- return pmAssertions->assertionsLog.setNotificationPort(port);
-}
-
-IOReturn
-IOPMrootDomain::setAssertionLogNotificationThreshold(uint64_t threshold)
-{
- if (!gIOPMWorkLoop->inGate()) {
- return gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::setAssertionLogNotificationThreshold),
- this, (void *)(uintptr_t) threshold);
- }
-
- if (!pmAssertions) {
- return kIOReturnNotFound;
- }
-
- return pmAssertions->assertionsLog.setNotificationThreshold(threshold);
}
// MARK: -
@@ -2319,10 +1938,6 @@
AggressivesRequest * request;
bool found = false;
- if ((type > UINT_MAX) || (value > UINT_MAX)) {
- return kIOReturnBadArgument;
- }
-
if (type == kPMMinutesToDim || type == kPMMinutesToSleep) {
DLOG("setAggressiveness(%x) %s = %u\n",
(uint32_t) options, getAggressivenessTypeString((uint32_t) type), (uint32_t) value);
@@ -2331,7 +1946,12 @@
(uint32_t) options, getAggressivenessTypeString((uint32_t) type), (uint32_t) value);
}
- request = IOMallocType(AggressivesRequest);
+ request = IONew(AggressivesRequest, 1);
+ if (!request) {
+ return kIOReturnNoMemory;
+ }
+
+ memset(request, 0, sizeof(*request));
request->options = options;
request->dataType = kAggressivesRequestTypeRecord;
request->data.record.type = (uint32_t) type;
@@ -2355,7 +1975,7 @@
if ((entry->dataType == kAggressivesRequestTypeRecord) &&
(entry->data.record.type == type) &&
((entry->options & kAggressivesOptionQuickSpindownMask) == 0)) {
- entry->data.record.value = (uint32_t) value;
+ entry->data.record.value = value;
found = true;
break;
}
@@ -2369,7 +1989,7 @@
AGGRESSIVES_UNLOCK();
if (found) {
- IOFreeType(request, AggressivesRequest);
+ IODelete(request, AggressivesRequest, 1);
}
if (options & kAggressivesOptionSynchronous) {
@@ -2396,7 +2016,7 @@
uint32_t value = 0;
int source = 0;
- if (!outLevel || (type > UINT_MAX)) {
+ if (!outLevel) {
return kIOReturnBadArgument;
}
@@ -2475,9 +2095,16 @@
DEBUG_LOG("joinAggressiveness %s %p\n", service->getName(), OBFUSCATE(service));
- request = IOMallocType(AggressivesRequest);
+ request = IONew(AggressivesRequest, 1);
+ if (!request) {
+ return kIOReturnNoMemory;
+ }
+
+ service->retain(); // released by synchronizeAggressives()
+
+ memset(request, 0, sizeof(*request));
request->dataType = kAggressivesRequestTypeService;
- request->data.service.reset(service, OSRetain); // released by synchronizeAggressives()
+ request->data.service = service;
AGGRESSIVES_LOCK();
queue_enter(&aggressivesQueue, request, AggressivesRequest *, chain);
@@ -2582,7 +2209,7 @@
DLOG("disk spindown accelerated\n");
}
- aggressivesData->appendValue(newRecord);
+ aggressivesData->appendBytes(&newRecord, sizeof(newRecord));
// OSData may have switched to another (larger) buffer.
count = aggressivesData->getLength() / sizeof(AggressivesRecord);
@@ -2591,7 +2218,7 @@
}
// Finished processing the request, release it.
- IOFreeType(request, AggressivesRequest);
+ IODelete(request, AggressivesRequest, 1);
break;
case kAggressivesRequestTypeService:
@@ -2600,7 +2227,7 @@
break;
default:
- panic("bad aggressives request type %x", request->dataType);
+ panic("bad aggressives request type %x\n", request->dataType);
break;
}
} while (!queue_empty(&aggressivesQueue));
@@ -2659,7 +2286,7 @@
const AggressivesRecord * array,
int count )
{
- OSSharedPtr<IOService> service;
+ IOService * service;
AggressivesRequest * request;
const AggressivesRecord * record;
IOPMDriverCallEntry callEntry;
@@ -2669,13 +2296,12 @@
while (!queue_empty(joinedQueue)) {
queue_remove_first(joinedQueue, request, AggressivesRequest *, chain);
if (request->dataType == kAggressivesRequestTypeService) {
- // retained by joinAggressiveness(), so take ownership
- service = os::move(request->data.service);
+ service = request->data.service;
} else {
- service.reset();
- }
-
- IOFreeType(request, AggressivesRequest);
+ service = NULL;
+ }
+
+ IODelete(request, AggressivesRequest, 1);
request = NULL;
if (service) {
@@ -2692,6 +2318,7 @@
}
service->deassertPMDriverCall(&callEntry);
}
+ service->release(); // retained by joinAggressiveness()
}
}
}
@@ -2707,21 +2334,19 @@
const AggressivesRecord * array,
int count )
{
- OSSharedPtr<IORegistryIterator> iter;
- IORegistryEntry *entry;
- OSSharedPtr<IORegistryEntry> child;
- IOPowerConnection *connect;
- IOService *service;
- const AggressivesRecord *record;
- IOPMDriverCallEntry callEntry;
- uint32_t value;
- int i;
+ IORegistryIterator * iter;
+ IORegistryEntry * entry;
+ IOPowerConnection * connect;
+ IOService * service;
+ const AggressivesRecord * record;
+ IOPMDriverCallEntry callEntry;
+ uint32_t value;
+ int i;
iter = IORegistryIterator::iterateOver(
this, gIOPowerPlane, kIORegistryIterateRecursively);
if (iter) {
do{
- // !! reset the iterator
iter->reset();
while ((entry = iter->getNextObject())) {
connect = OSDynamicCast(IOPowerConnection, entry);
@@ -2729,27 +2354,26 @@
continue;
}
- child = connect->copyChildEntry(gIOPowerPlane);
- if (child) {
- if ((service = OSDynamicCast(IOService, child.get()))) {
- if (service->assertPMDriverCall(&callEntry, kIOPMDriverCallMethodSetAggressive)) {
- for (i = 0, record = array; i < count; i++, record++) {
- if (record->flags & kAggressivesRecordFlagModified) {
- value = record->value;
- if (record->flags & kAggressivesRecordFlagMinValue) {
- value = kAggressivesMinValue;
- }
- _LOG("broadcastAggressives %x = %u to %s\n",
- record->type, value, service->getName());
- service->setAggressiveness(record->type, value);
+ if ((service = OSDynamicCast(IOService, connect->copyChildEntry(gIOPowerPlane)))) {
+ if (service->assertPMDriverCall(&callEntry, kIOPMDriverCallMethodSetAggressive)) {
+ for (i = 0, record = array; i < count; i++, record++) {
+ if (record->flags & kAggressivesRecordFlagModified) {
+ value = record->value;
+ if (record->flags & kAggressivesRecordFlagMinValue) {
+ value = kAggressivesMinValue;
}
+ _LOG("broadcastAggressives %x = %u to %s\n",
+ record->type, value, service->getName());
+ service->setAggressiveness(record->type, value);
}
- service->deassertPMDriverCall(&callEntry);
}
+ service->deassertPMDriverCall(&callEntry);
}
+ service->release();
}
}
}while (!entry && !iter->isValid());
+ iter->release();
}
}
@@ -2787,7 +2411,7 @@
//******************************************************************************
void
-IOPMrootDomain::startIdleSleepTimer( uint32_t inMilliSeconds )
+IOPMrootDomain::startIdleSleepTimer( uint32_t inSeconds )
{
AbsoluteTime deadline;
@@ -2796,37 +2420,14 @@
DLOG("idle timer not set (noidle=%d)\n", gNoIdleFlag);
return;
}
- if (inMilliSeconds) {
- if (inMilliSeconds < kMinimumTimeBeforeIdleSleep) {
- AbsoluteTime now;
- uint64_t nsec_since_wake;
- uint64_t msec_since_wake;
-
- // Adjust idle timer so it will not expire until atleast kMinimumTimeBeforeIdleSleep milliseconds
- // after the most recent AP wake.
- clock_get_uptime(&now);
- SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
- absolutetime_to_nanoseconds(now, &nsec_since_wake);
- msec_since_wake = nsec_since_wake / NSEC_PER_MSEC;
-
- if (msec_since_wake < kMinimumTimeBeforeIdleSleep) {
- uint32_t newIdleTimer = kMinimumTimeBeforeIdleSleep - (uint32_t)msec_since_wake;
-
- // Ensure that our new idle timer is not less than inMilliSeconds,
- // as we should only be increasing the timer duration, not decreasing it
- if (newIdleTimer > inMilliSeconds) {
- DLOG("startIdleSleepTimer increasing timeout from %u to %u\n", inMilliSeconds, newIdleTimer);
- inMilliSeconds = newIdleTimer;
- }
- }
- }
- clock_interval_to_deadline(inMilliSeconds, kMillisecondScale, &deadline);
+ if (inSeconds) {
+ clock_interval_to_deadline(inSeconds, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepTimerPending = true;
} else {
thread_call_enter(extraSleepTimer);
}
- DLOG("idle timer set for %u milliseconds\n", inMilliSeconds);
+ DLOG("idle timer set for %u seconds\n", inSeconds);
}
//******************************************************************************
@@ -2887,10 +2488,14 @@
return;
}
+ AbsoluteTime time;
+
DLOG("sleep timer expired\n");
ASSERT_GATED();
idleSleepTimerPending = false;
+
+ clock_get_uptime(&time);
setQuickSpinDownTimeout();
adjustPowerState(true);
}
@@ -2898,7 +2503,7 @@
//******************************************************************************
// getTimeToIdleSleep
//
-// Returns number of milliseconds left before going into idle sleep.
+// Returns number of seconds left before going into idle sleep.
// Caller has to make sure that idle sleep is allowed at the time of calling
// this function
//******************************************************************************
@@ -2909,7 +2514,7 @@
AbsoluteTime now, lastActivityTime;
uint64_t nanos;
uint32_t minutesSinceUserInactive = 0;
- uint32_t sleepDelay = 0;
+ uint32_t sleepDelay = 0;
if (!idleSleepEnabled) {
return 0xffffffff;
@@ -2921,14 +2526,8 @@
lastActivityTime = userBecameInactiveTime;
}
- // Ignore any lastActivityTime that predates the last system wake.
- // The goal is to avoid a sudden idle sleep right after a dark wake
- // due to sleepDelay=0 computed below. The alternative 60s minimum
- // timeout should be large enough to allow dark wake to complete,
- // at which point the idle timer will be promptly cancelled.
clock_get_uptime(&now);
- if ((CMP_ABSOLUTETIME(&lastActivityTime, &gIOLastWakeAbsTime) >= 0) &&
- (CMP_ABSOLUTETIME(&now, &lastActivityTime) > 0)) {
+ if (CMP_ABSOLUTETIME(&now, &lastActivityTime) > 0) {
SUB_ABSOLUTETIME(&now, &lastActivityTime);
absolutetime_to_nanoseconds(now, &nanos);
minutesSinceUserInactive = nanos / (60000000000ULL);
@@ -2939,15 +2538,13 @@
sleepDelay = sleepSlider - minutesSinceUserInactive;
}
} else {
- DLOG("ignoring lastActivityTime 0x%qx, now 0x%qx, wake 0x%qx\n",
- lastActivityTime, now, gIOLastWakeAbsTime);
sleepDelay = sleepSlider;
}
DLOG("user inactive %u min, time to idle sleep %u min\n",
minutesSinceUserInactive, sleepDelay);
- return sleepDelay * 60 * 1000;
+ return sleepDelay * 60;
}
//******************************************************************************
@@ -3012,9 +2609,6 @@
if (reason && reason->isEqualTo(kIOPMDarkWakeThermalEmergencyKey)) {
return privateSleepSystem(kIOPMSleepReasonDarkWakeThermalEmergency);
}
- if (reason && reason->isEqualTo(kIOPMNotificationWakeExitKey)) {
- return privateSleepSystem(kIOPMSleepReasonNotificationWakeExit);
- }
}
return privateSleepSystem( kIOPMSleepReasonSoftware);
@@ -3049,13 +2643,14 @@
#if !__i386__ && !__x86_64__
uint64_t timeSinceReset = 0;
#endif
- uint64_t now;
- unsigned long newState;
+ uint64_t now;
+ unsigned long newState;
clock_sec_t secs;
clock_usec_t microsecs;
- uint32_t lastDebugWakeSeconds;
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
clock_sec_t adjWakeTime;
IOPMCalendarStruct nowCalendar;
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
ASSERT_GATED();
newState = getPowerState();
@@ -3069,29 +2664,17 @@
notifierThread = current_thread();
switch (getPowerState()) {
case SLEEP_STATE: {
-#if defined(__arm64__) && HIBERNATION
- if (kIOHibernateStateInactive == gIOHibernateState)
-#endif /* defined(__arm64__) && HIBERNATION */
- {
- if (kIOPMDriverAssertionLevelOn == getPMAssertionLevel(kIOPMDriverAssertionForceWakeupBit)) {
- IOLog("accelerate wake for assertion\n");
- setWakeTime(mach_continuous_time());
- }
- if (kIOPMDriverAssertionLevelOn == getPMAssertionLevel(kIOPMDriverAssertionForceFullWakeupBit)) {
- // Note: The scheduled RTC wakeup will trigger a full wake.
- scheduleImmediateDebugWake();
- }
- }
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (kPMCalendarTypeInvalid != _aotWakeTimeCalendar.selector) {
secs = 0;
microsecs = 0;
PEGetUTCTimeOfDay(&secs, µsecs);
adjWakeTime = 0;
- if ((kIOPMAOTModeRespectTimers & _aotMode) && (_calendarWakeAlarmUTC < _aotWakeTimeUTC)) {
- IOLog("use _calendarWakeAlarmUTC\n");
- adjWakeTime = _calendarWakeAlarmUTC;
- } else if (kIOPMWakeEventAOTExitFlags & _aotPendingFlags) {
+ if ((kIOPMAOTModeRespectTimers & _aotMode) && (_scheduledAlarmUTC < _aotWakeTimeUTC)) {
+ IOLog("use _scheduledAlarmUTC\n");
+ adjWakeTime = _scheduledAlarmUTC;
+ } else if (_aotExit || (kIOPMWakeEventAOTExitFlags & _aotPendingFlags)) {
IOLog("accelerate _aotWakeTime for exit\n");
adjWakeTime = secs;
} else if (kIOPMDriverAssertionLevelOn == getPMAssertionLevel(kIOPMDriverAssertionCPUBit)) {
@@ -3117,39 +2700,24 @@
}
}
_aotPendingFlags &= ~kIOPMWakeEventAOTPerCycleFlags;
- if (_aotTimerScheduled) {
- _aotTimerES->cancelTimeout();
- _aotTimerScheduled = false;
- }
- acceptSystemWakeEvents(kAcceptSystemWakeEvents_Enable);
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+ acceptSystemWakeEvents(true);
// re-enable this timer for next sleep
cancelIdleSleepTimer();
-
- if (clamshellExists) {
-#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
- if (gClamshellFlags & kClamshell_WAR_58009435) {
- // Disable clamshell sleep until system has completed full wake.
- // This prevents a system sleep request (due to a clamshell close)
- // from being queued until the end of system full wake - even if
- // other clamshell disable bits outside of our control is wrong.
- setClamShellSleepDisable(true, kClamshellSleepDisableInternal);
- }
-#endif
-
- // Log the last known clamshell state before system sleep
- DLOG("clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
- clamshellClosed, clamshellDisabled, clamshellSleepDisableMask,
- desktopMode, acAdaptorConnected);
- }
clock_get_calendar_absolute_and_microtime(&secs, µsecs, &now);
logtime(secs);
gIOLastSleepTime.tv_sec = secs;
gIOLastSleepTime.tv_usec = microsecs;
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (!_aotLastWakeTime) {
gIOLastUserSleepTime = gIOLastSleepTime;
}
+#else
+ gIOLastUserSleepTime = gIOLastSleepTime;
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+
gIOLastWakeTime.tv_sec = 0;
gIOLastWakeTime.tv_usec = 0;
gIOLastSleepAbsTime = now;
@@ -3169,33 +2737,22 @@
}
#if HIBERNATION
LOG("System %sSleep\n", gIOHibernateState ? "Safe" : "");
-#if (DEVELOPMENT || DEBUG)
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "System State",
- gIOHibernateState ? "Enter Hibernate" : "Enter Sleep"
- );
-#endif /* DEVELOPMENT || DEBUG */
+
IOHibernateSystemHasSlept();
evaluateSystemSleepPolicyFinal();
#else
LOG("System Sleep\n");
-#if (DEVELOPMENT || DEBUG)
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "System State", "Enter Sleep");
-#endif /* DEVELOPMENT || DEBUG */
#endif
if (thermalWarningState) {
- OSSharedPtr<const OSSymbol> event = OSSymbol::withCString(kIOPMThermalLevelWarningKey);
+ const OSSymbol *event = OSSymbol::withCString(kIOPMThermalLevelWarningKey);
if (event) {
- systemPowerEventOccurred(event.get(), kIOPMThermalLevelUnknown);
+ systemPowerEventOccurred(event, kIOPMThermalLevelUnknown);
+ event->release();
}
}
assertOnWakeSecs = 0;
lowBatteryCondition = false;
- thermalEmergencyState = false;
#if DEVELOPMENT || DEBUG
extern int g_should_log_clock_adjustments;
@@ -3221,12 +2778,6 @@
clock_get_uptime(&gIOLastWakeAbsTime);
IOLog("gIOLastWakeAbsTime: %lld\n", gIOLastWakeAbsTime);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "System State", "Waking Up"
- );
-#endif /* DEVELOPMENT || DEBUG */
_highestCapability = 0;
#if HIBERNATION
@@ -3242,6 +2793,7 @@
gIOLastWakeTime.tv_sec = secs;
gIOLastWakeTime.tv_usec = microsecs;
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
// aot
if (_aotWakeTimeCalendar.selector != kPMCalendarTypeInvalid) {
_aotWakeTimeCalendar.selector = kPMCalendarTypeInvalid;
@@ -3261,13 +2813,12 @@
if (_aotTestTime) {
if (_aotWakeTimeUTC <= secs) {
- _aotTestTime = mach_continuous_time() + _aotTestInterval;
+ _aotTestTime = _aotTestTime + _aotTestInterval;
}
- if (_aotTestTime < _aotEndTime) {
- _setWakeTime(_aotTestTime);
- }
- }
- }
+ setWakeTime(_aotTestTime);
+ }
+ }
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
#if HIBERNATION
LOG("System %sWake\n", gIOHibernateState ? "SafeSleep " : "");
@@ -3275,57 +2826,48 @@
lastSleepReason = 0;
- lastDebugWakeSeconds = _debugWakeSeconds;
- _debugWakeSeconds = 0;
- _scheduledAlarmMask = 0;
- _nextScheduledAlarmType = NULL;
-
- darkWakeExit = false;
- darkWakePowerClamped = false;
+ _lastDebugWakeSeconds = _debugWakeSeconds;
+ _debugWakeSeconds = 0;
+ _scheduledAlarms = 0;
+
+#if defined(__i386__) || defined(__x86_64__)
+ kdebugTrace(kPMLogSystemWake, 0, 0, 0);
+ wranglerTickled = false;
+ graphicsSuppressed = false;
darkWakePostTickle = false;
darkWakeHibernateError = false;
darkWakeToSleepASAP = true;
- darkWakeLogClamp = true;
+ logGraphicsClamp = true;
sleepTimerMaintenance = false;
sleepToStandby = false;
- wranglerTickled = false;
+ wranglerTickleLatched = false;
userWasActive = false;
isRTCAlarmWake = false;
- clamshellIgnoreClose = false;
fullWakeReason = kFullWakeReasonNone;
- idleSleepRevertible = true;
-
-#if defined(__i386__) || defined(__x86_64__)
- kdebugTrace(kPMLogSystemWake, 0, 0, 0);
-
- OSSharedPtr<OSObject> wakeTypeProp = copyProperty(kIOPMRootDomainWakeTypeKey);
- OSSharedPtr<OSObject> wakeReasonProp = copyProperty(kIOPMRootDomainWakeReasonKey);
- OSString * wakeType = OSDynamicCast(OSString, wakeTypeProp.get());
- OSString * wakeReason = OSDynamicCast(OSString, wakeReasonProp.get());
+
+ OSString * wakeType = OSDynamicCast(
+ OSString, getProperty(kIOPMRootDomainWakeTypeKey));
+ OSString * wakeReason = OSDynamicCast(
+ OSString, getProperty(kIOPMRootDomainWakeReasonKey));
if (wakeReason && (wakeReason->getLength() >= 2) &&
gWakeReasonString[0] == '\0') {
- WAKEEVENT_LOCK();
// Until the platform driver can claim its wake reasons
strlcat(gWakeReasonString, wakeReason->getCStringNoCopy(),
sizeof(gWakeReasonString));
- if (!gWakeReasonSysctlRegistered) {
- gWakeReasonSysctlRegistered = true;
- }
- WAKEEVENT_UNLOCK();
}
if (wakeType && wakeType->isEqualTo(kIOPMrootDomainWakeTypeLowBattery)) {
lowBatteryCondition = true;
darkWakeMaintenance = true;
- } else {
+ } else if ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) != 0) {
#if HIBERNATION
- OSSharedPtr<OSObject> hibOptionsProp = copyProperty(kIOHibernateOptionsKey);
- OSNumber * hibOptions = OSDynamicCast( OSNumber, hibOptionsProp.get());
+ OSNumber * hibOptions = OSDynamicCast(
+ OSNumber, getProperty(kIOHibernateOptionsKey));
if (hibernateAborted || ((hibOptions &&
!(hibOptions->unsigned32BitValue() & kIOHibernateOptionDarkWake)))) {
// Hibernate aborted, or EFI brought up graphics
- darkWakeExit = true;
+ wranglerTickled = true;
if (hibernateAborted) {
DLOG("Hibernation aborted\n");
} else {
@@ -3337,7 +2879,7 @@
wakeType->isEqualTo(kIOPMRootDomainWakeTypeUser) ||
wakeType->isEqualTo(kIOPMRootDomainWakeTypeAlarm))) {
// User wake or RTC alarm
- darkWakeExit = true;
+ wranglerTickled = true;
if (wakeType->isEqualTo(kIOPMRootDomainWakeTypeAlarm)) {
isRTCAlarmWake = true;
}
@@ -3346,10 +2888,10 @@
// SMC standby timer trumps SleepX
darkWakeMaintenance = true;
sleepTimerMaintenance = true;
- } else if ((lastDebugWakeSeconds != 0) &&
+ } else if ((_lastDebugWakeSeconds != 0) &&
((gDarkWakeFlags & kDarkWakeFlagAlarmIsDark) == 0)) {
// SleepX before maintenance
- darkWakeExit = true;
+ wranglerTickled = true;
} else if (wakeType &&
wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance)) {
darkWakeMaintenance = true;
@@ -3370,70 +2912,55 @@
// Unidentified wake source, resume to full wake if debug
// alarm is pending.
- if (lastDebugWakeSeconds &&
+ if (_lastDebugWakeSeconds &&
(!wakeReason || wakeReason->isEqualTo(""))) {
- darkWakeExit = true;
+ wranglerTickled = true;
}
}
- }
-
- if (darkWakeExit) {
+ } else {
+ if (wakeType &&
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepTimer)) {
+ darkWakeMaintenance = true;
+ sleepTimerMaintenance = true;
+ } else if (hibernateAborted || !wakeType ||
+ !wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance) ||
+ !wakeReason || !wakeReason->isEqualTo("RTC")) {
+ // Post a HID tickle immediately - except for RTC maintenance wake.
+ wranglerTickled = true;
+ } else {
+ darkWakeMaintenance = true;
+ }
+ }
+
+ if (wranglerTickled) {
darkWakeToSleepASAP = false;
fullWakeReason = kFullWakeReasonLocalUser;
reportUserInput();
} else if (displayPowerOnRequested && checkSystemCanSustainFullWake()) {
- handleSetDisplayPowerOn(true);
+ handleDisplayPowerOn();
} else if (!darkWakeMaintenance) {
// Early/late tickle for non-maintenance wake.
- if ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) != kDarkWakeFlagPromotionNone) {
+ if (((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
+ kDarkWakeFlagHIDTickleEarly) ||
+ ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
+ kDarkWakeFlagHIDTickleLate)) {
darkWakePostTickle = true;
}
}
#else /* !__i386__ && !__x86_64__ */
timeSinceReset = ml_get_time_since_reset();
- kdebugTrace(kPMLogSystemWake, 0, (uintptr_t)(timeSinceReset >> 32), (uintptr_t) timeSinceReset);
-
- if ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) == kDarkWakeFlagPromotionEarly) {
- wranglerTickled = true;
- fullWakeReason = kFullWakeReasonLocalUser;
- requestUserActive(this, "Full wake on dark wake promotion boot-arg");
- } else if ((lastDebugWakeSeconds != 0) && !(gDarkWakeFlags & kDarkWakeFlagAlarmIsDark)) {
- isRTCAlarmWake = true;
- fullWakeReason = kFullWakeReasonLocalUser;
- requestUserActive(this, "RTC debug alarm");
- } else {
-#if HIBERNATION
- OSSharedPtr<OSObject> hibOptionsProp = copyProperty(kIOHibernateOptionsKey);
- OSNumber * hibOptions = OSDynamicCast(OSNumber, hibOptionsProp.get());
- if (hibOptions && !(hibOptions->unsigned32BitValue() & kIOHibernateOptionDarkWake)) {
- fullWakeReason = kFullWakeReasonLocalUser;
- requestUserActive(this, "hibernate user wake");
- }
-#endif
- }
-
+
+ kdebugTrace(kPMLogSystemWake, 0, timeSinceReset >> 32, timeSinceReset);
// stay awake for at least 30 seconds
- startIdleSleepTimer(30 * 1000);
+ wranglerTickled = true;
+ fullWakeReason = kFullWakeReasonLocalUser;
+ startIdleSleepTimer(30);
#endif
sleepCnt++;
thread_call_enter(updateConsoleUsersEntry);
- // Skip AOT_STATE if we are waking up from an RTC timer.
- // This check needs to be done after the epoch change is processed
- // and before the changePowerStateWithTagToPriv() call below.
- WAKEEVENT_LOCK();
- aotShouldExit(false);
- unsigned long newState = getRUN_STATE();
- if (AOT_STATE == newState) {
- if (gLPWFlags) {
- _aotRunMode = gLPWFlags | _aotWakeEventRunMode;
- }
- IOLog("_aotRunMode = 0x%llx|0x%llx\n", gLPWFlags, _aotWakeEventRunMode);
- }
- WAKEEVENT_UNLOCK();
-
- changePowerStateWithTagToPriv(newState, kCPSReasonWake);
+ changePowerStateToPriv(getRUN_STATE());
break;
}
#if !__i386__ && !__x86_64__
@@ -3452,7 +2979,7 @@
// state since the changePowerStateToPriv() issued at the tail
// end of SLEEP_STATE case should take care of that.
if (getPowerState() == ON_STATE) {
- changePowerStateWithTagToPriv(ON_STATE, kCPSReasonWake);
+ changePowerStateToPriv(ON_STATE);
}
break;
}
@@ -3480,30 +3007,6 @@
}
-static void
-makeSleepPreventersListLog(const OSSharedPtr<OSSet> &preventers, char *buf, size_t buf_size)
-{
- if (!preventers->getCount()) {
- return;
- }
-
- char *buf_iter = buf + strlen(buf);
- char *buf_end = buf + buf_size;
-
- OSSharedPtr<OSCollectionIterator> iterator = OSCollectionIterator::withCollection(preventers.get());
- OSObject *obj = NULL;
-
- while ((obj = iterator->getNextObject())) {
- IOService *srv = OSDynamicCast(IOService, obj);
- if (buf_iter < buf_end) {
- buf_iter += snprintf(buf_iter, buf_end - buf_iter, " %s", srv->getName());
- } else {
- DLOG("Print buffer exhausted for sleep preventers list\n");
- break;
- }
- }
-}
-
//******************************************************************************
// updatePreventIdleSleepList
//
@@ -3530,10 +3033,9 @@
ASSERT_GATED();
-#if defined(XNU_TARGET_OS_OSX)
- // Only the display wrangler and no-idle-sleep kernel assertions
- // can prevent idle sleep. The kIOPMPreventIdleSleep capability flag
- // reported by drivers in their power state table is ignored.
+#if defined(__i386__) || defined(__x86_64__)
+ // Disregard disk I/O (besides the display wrangler) as a factor preventing
+ // idle sleep, except in the case of legacy disk I/O
if (service && (service != wrangler) && (service != this)) {
return false;
}
@@ -3542,21 +3044,14 @@
if (service) {
if (addNotRemove) {
preventIdleSleepList->setObject(service);
- DLOG("Added %s to idle sleep preventers list (Total %u)\n",
+ DLOG("prevent idle sleep list: %s+ (%u)\n",
service->getName(), preventIdleSleepList->getCount());
} else if (preventIdleSleepList->member(service)) {
preventIdleSleepList->removeObject(service);
- DLOG("Removed %s from idle sleep preventers list (Total %u)\n",
+ DLOG("prevent idle sleep list: %s- (%u)\n",
service->getName(), preventIdleSleepList->getCount());
}
-
- if (preventIdleSleepList->getCount()) {
- char buf[256] = "Idle Sleep Preventers:";
- makeSleepPreventersListLog(preventIdleSleepList, buf, sizeof(buf));
- DLOG("%s\n", buf);
- }
- }
-
+ }
newCount = idleSleepPreventersCount();
if ((oldCount == 0) && (newCount != 0)) {
@@ -3564,18 +3059,18 @@
// Update the driver desire to prevent idle sleep.
// Driver desire does not prevent demand sleep.
- changePowerStateWithTagTo(getRUN_STATE(), kCPSReasonIdleSleepPrevent);
+ changePowerStateTo(getRUN_STATE());
} else if ((oldCount != 0) && (newCount == 0)) {
// Last driver removed from prevent list.
// Drop the driver clamp to allow idle sleep.
- changePowerStateWithTagTo(SLEEP_STATE, kCPSReasonIdleSleepAllow);
+ changePowerStateTo(SLEEP_STATE);
evaluatePolicy( kStimulusNoIdleSleepPreventers );
}
- messageClient(kIOPMMessageIdleSleepPreventers, systemCapabilityNotifier.get(),
+ messageClient(kIOPMMessageIdleSleepPreventers, systemCapabilityNotifier,
&newCount, sizeof(newCount));
-#if defined(XNU_TARGET_OS_OSX)
+#if defined(__i386__) || defined(__x86_64__)
if (addNotRemove && (service == wrangler) && !checkSystemCanSustainFullWake()) {
DLOG("Cannot cancel idle sleep\n");
return false; // do not idle-cancel
@@ -3615,7 +3110,7 @@
oldCount = preventSystemSleepList->getCount();
if (addNotRemove) {
preventSystemSleepList->setObject(service);
- DLOG("Added %s to system sleep preventers list (Total %u)\n",
+ DLOG("prevent system sleep list: %s+ (%u)\n",
service->getName(), preventSystemSleepList->getCount());
if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
AbsoluteTime now;
@@ -3630,7 +3125,7 @@
}
} else if (preventSystemSleepList->member(service)) {
preventSystemSleepList->removeObject(service);
- DLOG("Removed %s from system sleep preventers list (Total %u)\n",
+ DLOG("prevent system sleep list: %s- (%u)\n",
service->getName(), preventSystemSleepList->getCount());
if ((oldCount != 0) && (preventSystemSleepList->getCount() == 0)) {
@@ -3639,24 +3134,17 @@
evaluatePolicy( kStimulusDarkWakeEvaluate );
}
}
-
newCount = preventSystemSleepList->getCount();
- if (newCount) {
- char buf[256] = "System Sleep Preventers:";
- makeSleepPreventersListLog(preventSystemSleepList, buf, sizeof(buf));
- DLOG("%s\n", buf);
- }
-
- messageClient(kIOPMMessageSystemSleepPreventers, systemCapabilityNotifier.get(),
+ messageClient(kIOPMMessageSystemSleepPreventers, systemCapabilityNotifier,
&newCount, sizeof(newCount));
}
void
IOPMrootDomain::copySleepPreventersList(OSArray **idleSleepList, OSArray **systemSleepList)
{
- OSSharedPtr<OSCollectionIterator> iterator;
+ OSCollectionIterator *iterator = NULL;
OSObject *object = NULL;
- OSSharedPtr<OSArray> array;
+ OSArray *array = NULL;
if (!gIOPMWorkLoop->inGate()) {
gIOPMWorkLoop->runAction(
@@ -3667,48 +3155,42 @@
}
if (idleSleepList && preventIdleSleepList && (preventIdleSleepList->getCount() != 0)) {
- iterator = OSCollectionIterator::withCollection(preventIdleSleepList.get());
+ iterator = OSCollectionIterator::withCollection(preventIdleSleepList);
array = OSArray::withCapacity(5);
- if (iterator && array) {
- while ((object = iterator->getNextObject())) {
- IOService *service = OSDynamicCast(IOService, object);
- if (service) {
- OSSharedPtr<const OSSymbol> name = service->copyName();
- if (name) {
- array->setObject(name.get());
- }
- }
- }
- }
- *idleSleepList = array.detach();
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (object) {
+ array->setObject(OSSymbol::withCString(service->getName()));
+ }
+ }
+
+ iterator->release();
+ *idleSleepList = array;
}
if (systemSleepList && preventSystemSleepList && (preventSystemSleepList->getCount() != 0)) {
- iterator = OSCollectionIterator::withCollection(preventSystemSleepList.get());
+ iterator = OSCollectionIterator::withCollection(preventSystemSleepList);
array = OSArray::withCapacity(5);
- if (iterator && array) {
- while ((object = iterator->getNextObject())) {
- IOService *service = OSDynamicCast(IOService, object);
- if (service) {
- OSSharedPtr<const OSSymbol> name = service->copyName();
- if (name) {
- array->setObject(name.get());
- }
- }
- }
- }
- *systemSleepList = array.detach();
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (object) {
+ array->setObject(OSSymbol::withCString(service->getName()));
+ }
+ }
+
+ iterator->release();
+ *systemSleepList = array;
}
}
void
IOPMrootDomain::copySleepPreventersListWithID(OSArray **idleSleepList, OSArray **systemSleepList)
{
- OSSharedPtr<OSCollectionIterator> iterator;
+ OSCollectionIterator *iterator = NULL;
OSObject *object = NULL;
- OSSharedPtr<OSArray> array;
+ OSArray *array = NULL;
if (!gIOPMWorkLoop->inGate()) {
gIOPMWorkLoop->runAction(
@@ -3719,47 +3201,49 @@
}
if (idleSleepList && preventIdleSleepList && (preventIdleSleepList->getCount() != 0)) {
- iterator = OSCollectionIterator::withCollection(preventIdleSleepList.get());
+ iterator = OSCollectionIterator::withCollection(preventIdleSleepList);
array = OSArray::withCapacity(5);
- if (iterator && array) {
- while ((object = iterator->getNextObject())) {
- IOService *service = OSDynamicCast(IOService, object);
- if (service) {
- OSSharedPtr<OSDictionary> dict = OSDictionary::withCapacity(2);
- OSSharedPtr<const OSSymbol> name = service->copyName();
- OSSharedPtr<OSNumber> id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
- if (dict && name && id) {
- dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id.get());
- dict->setObject(kIOPMDriverAssertionOwnerStringKey, name.get());
- array->setObject(dict.get());
- }
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (object) {
+ OSDictionary *dict = OSDictionary::withCapacity(2);
+ if (dict) {
+ OSNumber *id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
+ dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id);
+ dict->setObject(kIOPMDriverAssertionOwnerStringKey, OSSymbol::withCString(service->getName()));
+ array->setObject(dict);
+ id->release();
+ dict->release();
}
}
}
- *idleSleepList = array.detach();
+
+ iterator->release();
+ *idleSleepList = array;
}
if (systemSleepList && preventSystemSleepList && (preventSystemSleepList->getCount() != 0)) {
- iterator = OSCollectionIterator::withCollection(preventSystemSleepList.get());
+ iterator = OSCollectionIterator::withCollection(preventSystemSleepList);
array = OSArray::withCapacity(5);
- if (iterator && array) {
- while ((object = iterator->getNextObject())) {
- IOService *service = OSDynamicCast(IOService, object);
- if (service) {
- OSSharedPtr<OSDictionary> dict = OSDictionary::withCapacity(2);
- OSSharedPtr<const OSSymbol> name = service->copyName();
- OSSharedPtr<OSNumber> id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
- if (dict && name && id) {
- dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id.get());
- dict->setObject(kIOPMDriverAssertionOwnerStringKey, name.get());
- array->setObject(dict.get());
- }
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (object) {
+ OSDictionary *dict = OSDictionary::withCapacity(2);
+ if (dict) {
+ OSNumber *id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
+ dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id);
+ dict->setObject(kIOPMDriverAssertionOwnerStringKey, OSSymbol::withCString(service->getName()));
+ array->setObject(dict);
+ id->release();
+ dict->release();
}
}
}
- *systemSleepList = array.detach();
+
+ iterator->release();
+ *systemSleepList = array;
}
}
@@ -3872,6 +3356,7 @@
*cancel = true;
DLOG("cancel dark->sleep\n");
}
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (_aotMode && (kPMCalendarTypeInvalid != _aotWakeTimeCalendar.selector)) {
uint64_t now = mach_continuous_time();
if (((now + _aotWakePreWindow) >= _aotWakeTimeContinuous)
@@ -3880,6 +3365,7 @@
IOLog("AOT wake window cancel: %qd, %qd\n", now, _aotWakeTimeContinuous);
}
}
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
}
}
@@ -3895,23 +3381,21 @@
// reset console lock state
thread_call_enter(updateConsoleUsersEntry);
- if (idleSleepEnabled) {
- if (!wrangler) {
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- startIdleSleepTimer(kIdleSleepRetryInterval);
-#else
- startIdleSleepTimer(idleMilliSeconds);
-#endif
- } else if (!userIsActive) {
+ if (!wrangler) {
+ if (idleSleepEnabled) {
+ // stay awake for at least idleSeconds
+ startIdleSleepTimer(idleSeconds);
+ }
+ } else {
+ if (idleSleepEnabled && !userIsActive) {
// Manually start the idle sleep timer besides waiting for
// the user to become inactive.
- startIdleSleepTimer(kIdleSleepRetryInterval);
+ startIdleSleepTimer( kIdleSleepRetryInterval );
}
}
preventTransitionToUserActive(false);
IOService::setAdvisoryTickleEnable( true );
- idleSleepRevertible = true;
// After idle revert and cancel, send a did-change message to powerd
// to balance the previous will-change message. Kernel clients do not
@@ -3932,7 +3416,7 @@
DLOG("MESG cap %x->%x did change\n",
params.fromCapabilities, params.toCapabilities);
- messageClient(kIOMessageSystemCapabilityChange, systemCapabilityNotifier.get(),
+ messageClient(kIOMessageSystemCapabilityChange, systemCapabilityNotifier,
¶ms, sizeof(params));
}
}
@@ -3986,7 +3470,7 @@
// Notify platform that sleep was cancelled or resumed.
getPlatform()->callPlatformFunction(
- sleepMessagePEFunction.get(), false,
+ sleepMessagePEFunction, false,
(void *)(uintptr_t) kIOMessageSystemHasPoweredOn,
NULL, NULL, NULL);
@@ -4012,11 +3496,6 @@
tracePoint( kIOPMTracePointWakeApplications );
tellClients( kIOMessageSystemHasPoweredOn );
- } else if (stateNum == AOT_STATE) {
- if (getPowerState() == AOT_STATE) {
- // Sleep was cancelled by idle cancel or revert
- startIdleSleepTimer(idleMilliSeconds);
- }
}
}
@@ -4112,7 +3591,7 @@
// Notify platform that sleep has begun, after the early
// sleep policy evaluation.
getPlatform()->callPlatformFunction(
- sleepMessagePEFunction.get(), false,
+ sleepMessagePEFunction, false,
(void *)(uintptr_t) kIOMessageSystemWillSleep,
NULL, NULL, NULL);
@@ -4163,18 +3642,26 @@
void
IOPMrootDomain::handleQueueSleepWakeUUID(OSObject *obj)
{
- OSSharedPtr<OSString> str;
+ OSString *str = NULL;
if (kOSBooleanFalse == obj) {
- handlePublishSleepWakeUUID(false);
- } else {
- str.reset(OSDynamicCast(OSString, obj), OSNoRetain);
- if (str) {
- // This branch caches the UUID for an upcoming sleep/wake
- queuedSleepWakeUUIDString = str;
- DLOG("SleepWake UUID queued: %s\n", queuedSleepWakeUUIDString->getCStringNoCopy());
- }
- }
+ handlePublishSleepWakeUUID(NULL);
+ } else if ((str = OSDynamicCast(OSString, obj))) {
+ // This branch caches the UUID for an upcoming sleep/wake
+ if (queuedSleepWakeUUIDString) {
+ queuedSleepWakeUUIDString->release();
+ queuedSleepWakeUUIDString = NULL;
+ }
+ queuedSleepWakeUUIDString = str;
+ queuedSleepWakeUUIDString->retain();
+
+ DLOG("SleepWake UUID queued: %s\n", queuedSleepWakeUUIDString->getCStringNoCopy());
+ }
+
+ if (obj) {
+ obj->release();
+ }
+ return;
}
//******************************************************************************
// handlePublishSleepWakeUUID
@@ -4207,18 +3694,21 @@
* Optionally, publish a new UUID
*/
if (queuedSleepWakeUUIDString && shouldPublish) {
- OSSharedPtr<OSString> publishThisUUID;
+ OSString *publishThisUUID = NULL;
publishThisUUID = queuedSleepWakeUUIDString;
+ publishThisUUID->retain();
if (publishThisUUID) {
- setProperty(kIOPMSleepWakeUUIDKey, publishThisUUID.get());
+ setProperty(kIOPMSleepWakeUUIDKey, publishThisUUID);
+ publishThisUUID->release();
}
gSleepWakeUUIDIsSet = true;
messageClients(kIOPMMessageSleepWakeUUIDChange, kIOPMMessageSleepWakeUUIDSet);
- queuedSleepWakeUUIDString.reset();
+ queuedSleepWakeUUIDString->release();
+ queuedSleepWakeUUIDString = NULL;
}
}
@@ -4239,53 +3729,21 @@
}
if (buffer != NULL) {
- OSSharedPtr<OSString> string =
- OSDynamicPtrCast<OSString>(gRootDomain->copyProperty(kIOPMSleepWakeUUIDKey));
-
- if (!string) {
+ OSString *string;
+
+ string = (OSString *)
+ gRootDomain->copyProperty(kIOPMSleepWakeUUIDKey);
+
+ if (string == NULL) {
*buffer = '\0';
} else {
strlcpy(buffer, string->getCStringNoCopy(), buf_len);
+
+ string->release();
}
}
return true;
-}
-
-//******************************************************************************
-// lowLatencyAudioNotify
-//
-// Used to send an update about low latency audio activity to interested
-// clients. To keep the overhead minimal the OSDictionary used here
-// is initialized at boot.
-//******************************************************************************
-
-void
-IOPMrootDomain::lowLatencyAudioNotify(uint64_t time, boolean_t state)
-{
- if (lowLatencyAudioNotifierDict && lowLatencyAudioNotifyStateSym && lowLatencyAudioNotifyTimestampSym &&
- lowLatencyAudioNotifyStateVal && lowLatencyAudioNotifyTimestampVal) {
- lowLatencyAudioNotifyTimestampVal->setValue(time);
- lowLatencyAudioNotifyStateVal->setValue(state);
- setPMSetting(gIOPMSettingLowLatencyAudioModeKey.get(), lowLatencyAudioNotifierDict.get());
- } else {
- DLOG("LowLatencyAudioNotify error\n");
- }
- return;
-}
-
-//******************************************************************************
-// IOPMrootDomainRTNotifier
-//
-// Used by performance controller to update the timestamp and state associated
-// with low latency audio activity in the system.
-//******************************************************************************
-
-extern "C" void
-IOPMrootDomainRTNotifier(uint64_t time, boolean_t state)
-{
- gRootDomain->lowLatencyAudioNotify(time, state);
- return;
}
//******************************************************************************
@@ -4308,74 +3766,33 @@
}
//******************************************************************************
-// Root domain uses the private and tagged changePowerState methods for
-// tracking and logging purposes.
-//******************************************************************************
-
-#define REQUEST_TAG_TO_REASON(x) ((uint16_t)x)
-
-static uint32_t
-nextRequestTag( IOPMRequestTag tag )
-{
- static SInt16 msb16 = 1;
- uint16_t id = OSAddAtomic16(1, &msb16);
- return ((uint32_t)id << 16) | REQUEST_TAG_TO_REASON(tag);
-}
-
-// TODO: remove this shim function and exported symbol
+// changePowerStateTo & changePowerStateToPriv
+//
+// Override of these methods for logging purposes.
+//******************************************************************************
+
IOReturn
IOPMrootDomain::changePowerStateTo( unsigned long ordinal )
{
- return changePowerStateWithTagTo(ordinal, kCPSReasonNone);
-}
-
-// TODO: remove this shim function and exported symbol
+ DLOG("changePowerStateTo(%u)\n", (uint32_t) ordinal);
+
+ if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
+ return kIOReturnUnsupported;
+ }
+
+ return super::changePowerStateTo(ordinal);
+}
+
IOReturn
IOPMrootDomain::changePowerStateToPriv( unsigned long ordinal )
{
- return changePowerStateWithTagToPriv(ordinal, kCPSReasonNone);
-}
-
-IOReturn
-IOPMrootDomain::changePowerStateWithOverrideTo(
- IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
-{
- uint32_t tag = nextRequestTag(reason);
- DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
+ DLOG("changePowerStateToPriv(%u)\n", (uint32_t) ordinal);
if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
return kIOReturnUnsupported;
}
- return super::changePowerStateWithOverrideTo(ordinal, tag);
-}
-
-IOReturn
-IOPMrootDomain::changePowerStateWithTagTo(
- IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
-{
- uint32_t tag = nextRequestTag(reason);
- DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
-
- if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
- return kIOReturnUnsupported;
- }
-
- return super::changePowerStateWithTagTo(ordinal, tag);
-}
-
-IOReturn
-IOPMrootDomain::changePowerStateWithTagToPriv(
- IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
-{
- uint32_t tag = nextRequestTag(reason);
- DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
-
- if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
- return kIOReturnUnsupported;
- }
-
- return super::changePowerStateWithTagToPriv(ordinal, tag);
+ return super::changePowerStateToPriv(ordinal);
}
//******************************************************************************
@@ -4392,12 +3809,6 @@
bool
IOPMrootDomain::abortHibernation(void)
{
-#if __arm64__
- // don't allow hibernation to be aborted on ARM due to user activity
- // since once ApplePMGR decides we're hibernating, we can't turn back
- // see: <rdar://problem/63848862> Tonga ApplePMGR diff quiesce path support
- return false;
-#else
bool ret = activitySinceSleep();
if (ret && !hibernateAborted && checkSystemCanSustainFullWake()) {
@@ -4405,7 +3816,6 @@
hibernateAborted = true;
}
return ret;
-#endif
}
extern "C" int
@@ -4419,167 +3829,93 @@
}
//******************************************************************************
-// scheduleImmediateDebugWake
+// willNotifyPowerChildren
//
-// Schedule a wake with RTC to wake us back up immediately after we sleep.
-// Useful when a cancel request comes in past the revert point on the sleep path
+// Called after all interested drivers have all acknowledged the power change,
+// but before any power children is informed. Dispatched though a thread call,
+// so it is safe to perform work that might block on a sleeping disk. PM state
+// machine (not thread) will block w/o timeout until this function returns.
//******************************************************************************
void
-IOPMrootDomain::scheduleImmediateDebugWake( void )
-{
- OSSharedPtr<OSDictionary> dict = OSDictionary::withCapacity(1);
- OSSharedPtr<OSNumber> secs = OSNumber::withNumber(1, 32);
-
- if (dict && secs) {
- dict->setObject(gIOPMSettingDebugWakeRelativeKey.get(), secs.get());
- gRootDomain->setProperties(dict.get());
- MSG("Reverting sleep with relative wake\n");
- }
-}
-
-//******************************************************************************
-// willNotifyInterest
-//
-// Called after all priority clients have all acknowledged the power change,
-// but before any interested drivers and any power children are informed.
-// Dispatched though a thread call, so it is safe to perform work that might block on a
-// sleeping disk. PM state machine (not thread) will block w/o timeout until this function returns.
-//******************************************************************************
-
-void
-IOPMrootDomain::willNotifyInterested( IOPMPowerStateIndex newPowerState )
-{
+IOPMrootDomain::willNotifyPowerChildren( IOPMPowerStateIndex newPowerState )
+{
+ OSDictionary *dict;
+ OSNumber *secs;
+
if (SLEEP_STATE == newPowerState) {
+ notifierThread = current_thread();
+ if (!tasksSuspended) {
+ AbsoluteTime deadline;
+ tasksSuspended = TRUE;
+ updateTasksSuspend();
+
+ clock_interval_to_deadline(10, kSecondScale, &deadline);
+#if !CONFIG_EMBEDDED
+ vm_pageout_wait(AbsoluteTime_to_scalar(&deadline));
+#endif /* !CONFIG_EMBEDDED */
+ }
+
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
_aotReadyToFullWake = false;
#if 0
if (_aotLingerTime) {
- uint64_t interval, deadline;
+ uint64_t deadline;
IOLog("aot linger no return\n");
- nanoseconds_to_absolutetime(_aotLingerTime * NSEC_PER_MSEC, &interval);
- clock_absolutetime_interval_to_deadline(interval, &deadline);
+ clock_absolutetime_interval_to_deadline(_aotLingerTime, &deadline);
clock_delay_until(deadline);
}
#endif
if (!_aotMode) {
_aotTestTime = 0;
_aotWakeTimeCalendar.selector = kPMCalendarTypeInvalid;
- _aotLastWakeTime = 0;
if (_aotMetrics) {
bzero(_aotMetrics, sizeof(IOPMAOTMetrics));
}
} else if (!_aotNow && !_debugWakeSeconds) {
_aotNow = true;
+ _aotExit = false;
_aotPendingFlags = 0;
_aotTasksSuspended = true;
_aotLastWakeTime = 0;
bzero(_aotMetrics, sizeof(IOPMAOTMetrics));
if (kIOPMAOTModeCycle & _aotMode) {
- clock_interval_to_absolutetime_interval(10, kSecondScale, &_aotTestInterval);
+ clock_interval_to_absolutetime_interval(60, kSecondScale, &_aotTestInterval);
_aotTestTime = mach_continuous_time() + _aotTestInterval;
- AbsoluteTime endInterval;
- clock_interval_to_absolutetime_interval(60, kSecondScale, &endInterval);
- _aotEndTime = mach_continuous_time() + endInterval;
- _setWakeTime(_aotTestTime);
- }
+ setWakeTime(_aotTestTime);
+ }
+ uint32_t lingerSecs;
+ if (!PE_parse_boot_argn("aotlinger", &lingerSecs, sizeof(lingerSecs))) {
+ lingerSecs = 0;
+ }
+ clock_interval_to_absolutetime_interval(lingerSecs, kSecondScale, &_aotLingerTime);
clock_interval_to_absolutetime_interval(2000, kMillisecondScale, &_aotWakePreWindow);
clock_interval_to_absolutetime_interval(1100, kMillisecondScale, &_aotWakePostWindow);
}
-
- if (updateTasksSuspend(kTasksSuspendSuspended, kTasksSuspendNoChange)) {
- IOLog("PMRD: tasks suspend\n");
- AbsoluteTime deadline;
-
- clock_interval_to_deadline(10, kSecondScale, &deadline);
-#if defined(XNU_TARGET_OS_OSX)
- vm_pageout_wait(AbsoluteTime_to_scalar(&deadline));
-#endif /* defined(XNU_TARGET_OS_OSX) */
- }
- }
-}
-
-//******************************************************************************
-// willNotifyPowerChildren
-//
-// Called after all interested drivers have all acknowledged the power change,
-// but before any power children are informed.
-// Dispatched though a thread call, so it is safe to perform work that might block on a
-// sleeping disk. PM state machine (not thread) will block w/o timeout until this function returns.
-//******************************************************************************
-
-void
-IOPMrootDomain::willNotifyPowerChildren( IOPMPowerStateIndex newPowerState )
-{
- if (SLEEP_STATE == newPowerState) {
- notifierThread = current_thread();
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
#if HIBERNATION
- // Adjust watchdog for IOHibernateSystemSleep
- int defaultTimeout = getWatchdogTimeout();
- int timeout = defaultTimeout > WATCHDOG_HIBERNATION_TIMEOUT ?
- defaultTimeout : WATCHDOG_HIBERNATION_TIMEOUT;
- reset_watchdog_timer(timeout);
-
IOHibernateSystemSleep();
IOHibernateIOKitSleep();
#endif
-#if defined(__arm64__) && HIBERNATION
- if (gIOHibernateState == kIOHibernateStateInactive) {
- setProperty(kIOPMSystemSleepTypeKey, kIOPMSleepTypeDeepIdle, 32);
- }
- // On AS, hibernation cannot be aborted. Resetting RTC to 1s during hibernation upon detecting
- // user activity is pointless (we are likely to spend >1s hibernating). It also clears existing
- // alarms, which can mess with cycler tools.
- if (gRootDomain->activitySinceSleep() && gIOHibernateState == kIOHibernateStateInactive) {
-#else /* defined(__arm64__) && HIBERNATION */
- // On non-AS, hibernation can be aborted if user activity is detected. So continue to reset the
- // RTC alarm (even during hibernation) so we can immediately wake from regular S2R if needed.
if (gRootDomain->activitySinceSleep()) {
-#endif /* defined(__arm64__) && HIBERNATION */
- scheduleImmediateDebugWake();
+ dict = OSDictionary::withCapacity(1);
+ secs = OSNumber::withNumber(1, 32);
+
+ if (dict && secs) {
+ dict->setObject(gIOPMSettingDebugWakeRelativeKey, secs);
+ gRootDomain->setProperties(dict);
+ MSG("Reverting sleep with relative wake\n");
+ }
+ if (dict) {
+ dict->release();
+ }
+ if (secs) {
+ secs->release();
+ }
}
notifierThread = NULL;
- }
-}
-
-//******************************************************************************
-// willTellSystemCapabilityDidChange
-//
-// IOServicePM calls this from OurChangeTellCapabilityDidChange() when root
-// domain is raising its power state, immediately after notifying interested
-// drivers and power children.
-//******************************************************************************
-
-void
-IOPMrootDomain::willTellSystemCapabilityDidChange( void )
-{
- if ((_systemTransitionType == kSystemTransitionWake) &&
- !CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
- // After powering up drivers, dark->full promotion on the current wake
- // transition is no longer possible. That is because the next machine
- // state will issue the system capability change messages.
- // The darkWakePowerClamped flag may already be set if the system has
- // at least one driver that was power clamped due to dark wake.
- // This function sets the darkWakePowerClamped flag in case there
- // is no power-clamped driver in the system.
- //
- // Last opportunity to exit dark wake using:
- // requestFullWake( kFullWakeReasonLocalUser );
-
- if (!darkWakePowerClamped) {
- if (darkWakeLogClamp) {
- AbsoluteTime now;
- uint64_t nsec;
-
- clock_get_uptime(&now);
- SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
- absolutetime_to_nanoseconds(now, &nsec);
- DLOG("dark wake promotion disabled at %u ms\n",
- ((int)((nsec) / NSEC_PER_MSEC)));
- }
- darkWakePowerClamped = true;
- }
}
}
@@ -4597,10 +3933,10 @@
return false;
}
- DLOG("clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
- clamshellClosed, clamshellDisabled, clamshellSleepDisableMask, desktopMode, acAdaptorConnected);
-
- return !clamshellDisabled && !(desktopMode && acAdaptorConnected) && !clamshellSleepDisableMask;
+ DLOG("clamshell closed %d, disabled %d, desktopMode %d, ac %d sleepDisabled %d\n",
+ clamshellClosed, clamshellDisabled, desktopMode, acAdaptorConnected, clamshellSleepDisabled);
+
+ return !clamshellDisabled && !(desktopMode && acAdaptorConnected) && !clamshellSleepDisabled;
}
bool
@@ -4612,10 +3948,10 @@
return false;
}
- DLOG("shouldSleepOnRTCAlarmWake: clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
- clamshellClosed, clamshellDisabled, clamshellSleepDisableMask, desktopMode, acAdaptorConnected);
-
- return !acAdaptorConnected && !clamshellSleepDisableMask;
+ DLOG("shouldSleepOnRTCAlarmWake: clamshell closed %d, disabled %d, desktopMode %d, ac %d sleepDisabled %d\n",
+ clamshellClosed, clamshellDisabled, desktopMode, acAdaptorConnected, clamshellSleepDisabled);
+
+ return !acAdaptorConnected && !clamshellSleepDisabled;
}
void
@@ -4666,37 +4002,30 @@
}
//******************************************************************************
-// setClamShellSleepDisable
+// setDisableClamShellSleep
//
//******************************************************************************
void
-IOPMrootDomain::setClamShellSleepDisable( bool disable, uint32_t bitmask )
-{
- uint32_t oldMask;
-
- // User client calls this in non-gated context
+IOPMrootDomain::setDisableClamShellSleep( bool val )
+{
if (gIOPMWorkLoop->inGate() == false) {
gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::setClamShellSleepDisable),
- (OSObject *) this,
- (void *) disable, (void *)(uintptr_t) bitmask);
+ OSMemberFunctionCast(IOWorkLoop::Action, this, &IOPMrootDomain::setDisableClamShellSleep),
+ (OSObject *)this,
+ (void *)val);
+
return;
- }
-
- oldMask = clamshellSleepDisableMask;
- if (disable) {
- clamshellSleepDisableMask |= bitmask;
} else {
- clamshellSleepDisableMask &= ~bitmask;
- }
- DLOG("setClamShellSleepDisable(%x->%x)\n", oldMask, clamshellSleepDisableMask);
-
- if (clamshellExists && clamshellClosed &&
- (clamshellSleepDisableMask != oldMask) &&
- (clamshellSleepDisableMask == 0)) {
- handlePowerNotification(kLocalEvalClamshellCommand);
+ DLOG("setDisableClamShellSleep(%x)\n", (uint32_t) val);
+ if (clamshellSleepDisabled != val) {
+ clamshellSleepDisabled = val;
+ // If clamshellSleepDisabled is reset to 0, reevaluate if
+ // system need to go to sleep due to clamshell state
+ if (!clamshellSleepDisabled && clamshellClosed) {
+ handlePowerNotification(kLocalEvalClamshellCommand);
+ }
+ }
}
}
@@ -4710,89 +4039,6 @@
IOPMrootDomain::wakeFromDoze( void )
{
// Preserve symbol for familes (IOUSBFamily and IOGraphics)
-}
-
-//******************************************************************************
-// recordRTCAlarm
-//
-// Record the earliest scheduled RTC alarm to determine whether a RTC wake
-// should be a dark wake or a full wake. Both Maintenance and SleepService
-// alarms are dark wake, while AutoWake (WakeByCalendarDate) and DebugWake
-// (WakeRelativeToSleep) should trigger a full wake. Scheduled power-on
-// PMSettings are ignored.
-//
-// Caller serialized using settingsCtrlLock.
-//******************************************************************************
-
-void
-IOPMrootDomain::recordRTCAlarm(
- const OSSymbol *type,
- OSObject *object )
-{
- uint32_t previousAlarmMask = _scheduledAlarmMask;
-
- if (type == gIOPMSettingDebugWakeRelativeKey) {
- OSNumber * n = OSDynamicCast(OSNumber, object);
- if (n) {
- // Debug wake has highest scheduling priority so it overrides any
- // pre-existing alarm.
- uint32_t debugSecs = n->unsigned32BitValue();
- _nextScheduledAlarmType.reset(type, OSRetain);
- _nextScheduledAlarmUTC = debugSecs;
-
- _debugWakeSeconds = debugSecs;
- OSBitOrAtomic(kIOPMAlarmBitDebugWake, &_scheduledAlarmMask);
- DLOG("next alarm (%s) in %u secs\n",
- type->getCStringNoCopy(), debugSecs);
- }
- } else if ((type == gIOPMSettingAutoWakeCalendarKey.get()) ||
- (type == gIOPMSettingMaintenanceWakeCalendarKey.get()) ||
- (type == gIOPMSettingSleepServiceWakeCalendarKey.get())) {
- OSData * data = OSDynamicCast(OSData, object);
- if (data && (data->getLength() == sizeof(IOPMCalendarStruct))) {
- const IOPMCalendarStruct * cs;
- bool replaceNextAlarm = false;
- clock_sec_t secs;
-
- cs = (const IOPMCalendarStruct *) data->getBytesNoCopy();
- secs = IOPMConvertCalendarToSeconds(cs);
- DLOG("%s " YMDTF "\n", type->getCStringNoCopy(), YMDT(cs));
-
- // Update the next scheduled alarm type
- if ((_nextScheduledAlarmType == NULL) ||
- ((_nextScheduledAlarmType != gIOPMSettingDebugWakeRelativeKey) &&
- (secs < _nextScheduledAlarmUTC))) {
- replaceNextAlarm = true;
- }
-
- if (type == gIOPMSettingAutoWakeCalendarKey.get()) {
- if (cs->year) {
- _calendarWakeAlarmUTC = IOPMConvertCalendarToSeconds(cs);
- OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_scheduledAlarmMask);
- } else {
- // TODO: can this else-block be removed?
- _calendarWakeAlarmUTC = 0;
- OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_scheduledAlarmMask);
- }
- }
- if (type == gIOPMSettingMaintenanceWakeCalendarKey.get()) {
- OSBitOrAtomic(kIOPMAlarmBitMaintenanceWake, &_scheduledAlarmMask);
- }
- if (type == gIOPMSettingSleepServiceWakeCalendarKey.get()) {
- OSBitOrAtomic(kIOPMAlarmBitSleepServiceWake, &_scheduledAlarmMask);
- }
-
- if (replaceNextAlarm) {
- _nextScheduledAlarmType.reset(type, OSRetain);
- _nextScheduledAlarmUTC = secs;
- DLOG("next alarm (%s) " YMDTF "\n", type->getCStringNoCopy(), YMDT(cs));
- }
- }
- }
-
- if (_scheduledAlarmMask != previousAlarmMask) {
- DLOG("scheduled alarm mask 0x%x\n", (uint32_t) _scheduledAlarmMask);
- }
}
// MARK: -
@@ -4822,14 +4068,13 @@
uint32_t supportedWhere,
uint32_t *uniqueFeatureID)
{
- static uint16_t next_feature_id = 500;
-
- OSSharedPtr<OSNumber> new_feature_data;
- OSNumber *existing_feature = NULL;
- OSArray *existing_feature_arr_raw = NULL;
- OSSharedPtr<OSArray> existing_feature_arr;
- OSObject *osObj = NULL;
- uint32_t feature_value = 0;
+ static uint16_t next_feature_id = 500;
+
+ OSNumber *new_feature_data = NULL;
+ OSNumber *existing_feature = NULL;
+ OSArray *existing_feature_arr = NULL;
+ OSObject *osObj = NULL;
+ uint32_t feature_value = 0;
supportedWhere &= kRD_AllPowerSources; // mask off any craziness!
@@ -4847,13 +4092,12 @@
IOLockLock(featuresDictLock);
}
- OSSharedPtr<OSObject> origFeaturesProp = copyProperty(kRootDomainSupportedFeatures);
- OSDictionary *origFeatures = OSDynamicCast(OSDictionary, origFeaturesProp.get());
- OSSharedPtr<OSDictionary> features;
+ OSDictionary *features =
+ (OSDictionary *) getProperty(kRootDomainSupportedFeatures);
// Create new features dict if necessary
- if (origFeatures) {
- features = OSDictionary::withDictionary(origFeatures);
+ if (features && OSDynamicCast(OSDictionary, features)) {
+ features = OSDictionary::withDictionary(features);
} else {
features = OSDictionary::withCapacity(1);
}
@@ -4881,24 +4125,30 @@
// We need to create an OSArray to hold the now 2 elements.
existing_feature_arr = OSArray::withObjects(
(const OSObject **)&existing_feature, 1, 2);
- } else if ((existing_feature_arr_raw = OSDynamicCast(OSArray, osObj))) {
+ } else if ((existing_feature_arr = OSDynamicCast(OSArray, osObj))) {
// Add object to existing array
existing_feature_arr = OSArray::withArray(
- existing_feature_arr_raw,
- existing_feature_arr_raw->getCount() + 1);
+ existing_feature_arr,
+ existing_feature_arr->getCount() + 1);
}
if (existing_feature_arr) {
- existing_feature_arr->setObject(new_feature_data.get());
- features->setObject(feature, existing_feature_arr.get());
+ existing_feature_arr->setObject(new_feature_data);
+ features->setObject(feature, existing_feature_arr);
+ existing_feature_arr->release();
+ existing_feature_arr = NULL;
}
} else {
// The easy case: no previously existing features listed. We simply
// set the OSNumber at key 'feature' and we're on our way.
- features->setObject(feature, new_feature_data.get());
- }
-
- setProperty(kRootDomainSupportedFeatures, features.get());
+ features->setObject(feature, new_feature_data);
+ }
+
+ new_feature_data->release();
+
+ setProperty(kRootDomainSupportedFeatures, features);
+
+ features->release();
if (featuresDictLock) {
IOLockUnlock(featuresDictLock);
@@ -4926,12 +4176,12 @@
bool madeAChange = false;
OSSymbol *dictKey = NULL;
- OSSharedPtr<OSCollectionIterator> dictIterator;
+ OSCollectionIterator *dictIterator = NULL;
OSArray *arrayMember = NULL;
OSNumber *numberMember = NULL;
OSObject *osObj = NULL;
OSNumber *osNum = NULL;
- OSSharedPtr<OSArray> arrayMemberCopy;
+ OSArray *arrayMemberCopy;
if (kBadPMFeatureID == removeFeatureID) {
return kIOReturnNotFound;
@@ -4941,15 +4191,14 @@
IOLockLock(featuresDictLock);
}
- OSSharedPtr<OSObject> origFeaturesProp = copyProperty(kRootDomainSupportedFeatures);
- OSDictionary *origFeatures = OSDynamicCast(OSDictionary, origFeaturesProp.get());
- OSSharedPtr<OSDictionary> features;
-
- if (origFeatures) {
+ OSDictionary *features =
+ (OSDictionary *) getProperty(kRootDomainSupportedFeatures);
+
+ if (features && OSDynamicCast(OSDictionary, features)) {
// Any modifications to the dictionary are made to the copy to prevent
// races & crashes with userland clients. Dictionary updated
// automically later.
- features = OSDictionary::withDictionary(origFeatures);
+ features = OSDictionary::withDictionary(features);
} else {
features = NULL;
ret = kIOReturnNotFound;
@@ -4960,7 +4209,7 @@
// with 'removeFeatureID'. If found, we remove it from our tracking
// structures and notify the OS via a general interest message.
- dictIterator = OSCollectionIterator::withCollection(features.get());
+ dictIterator = OSCollectionIterator::withCollection(features);
if (!dictIterator) {
goto exit;
}
@@ -5004,7 +4253,8 @@
arrayMemberCopy = OSArray::withArray(arrayMember);
if (arrayMemberCopy) {
arrayMemberCopy->removeObject(i);
- features->setObject(dictKey, arrayMemberCopy.get());
+ features->setObject(dictKey, arrayMemberCopy);
+ arrayMemberCopy->release();
}
}
@@ -5015,10 +4265,12 @@
}
}
+ dictIterator->release();
+
if (madeAChange) {
ret = kIOReturnSuccess;
- setProperty(kRootDomainSupportedFeatures, features.get());
+ setProperty(kRootDomainSupportedFeatures, features);
// Notify EnergySaver and all those in user space so they might
// re-populate their feature specific UI
@@ -5030,6 +4282,9 @@
}
exit:
+ if (features) {
+ features->release();
+ }
if (featuresDictLock) {
IOLockUnlock(featuresDictLock);
}
@@ -5071,13 +4326,11 @@
OSObject *object )
{
PMSettingCallEntry *entries = NULL;
- OSSharedPtr<OSArray> chosen;
+ OSArray *chosen = NULL;
const OSArray *array;
PMSettingObject *pmso;
thread_t thisThread;
int i, j, count, capacity;
- bool ok = false;
- IOReturn ret;
if (NULL == type) {
return kIOReturnBadArgument;
@@ -5127,20 +4380,7 @@
// Call each pmso in the chosen array.
for (i = 0; i < count; i++) {
pmso = (PMSettingObject *) chosen->getObject(i);
- ret = pmso->dispatchPMSetting(type, object);
- if (ret == kIOReturnSuccess) {
- // At least one setting handler was successful
- ok = true;
-#if DEVELOPMENT || DEBUG
- } else {
- // Log the handler and kext that failed
- OSSharedPtr<const OSSymbol> kextName = copyKextIdentifierWithAddress((vm_address_t) pmso->func);
- if (kextName) {
- DLOG("PMSetting(%s) error 0x%x from %s\n",
- type->getCStringNoCopy(), ret, kextName->getCStringNoCopy());
- }
-#endif
- }
+ pmso->dispatchPMSetting(type, object);
}
PMSETTING_LOCK();
@@ -5151,13 +4391,12 @@
PMSETTING_WAKEUP(pmso);
}
}
-
- if (ok) {
- recordRTCAlarm(type, object);
- }
unlock_exit:
PMSETTING_UNLOCK();
+ if (chosen) {
+ chosen->release();
+ }
if (entries) {
IODelete(entries, PMSettingCallEntry, capacity);
}
@@ -5172,18 +4411,21 @@
// notifications.
//******************************************************************************
-OSSharedPtr<OSObject>
+OSObject *
IOPMrootDomain::copyPMSetting(
OSSymbol *whichSetting)
{
- OSSharedPtr<OSObject> obj;
+ OSObject *obj = NULL;
if (!whichSetting) {
return NULL;
}
PMSETTING_LOCK();
- obj.reset(fPMSettingsDict->getObject(whichSetting), OSRetain);
+ obj = fPMSettingsDict->getObject(whichSetting);
+ if (obj) {
+ obj->retain();
+ }
PMSETTING_UNLOCK();
return obj;
@@ -5240,6 +4482,7 @@
{
PMSettingObject *pmso = NULL;
OSObject *pmsh = NULL;
+ OSArray *list = NULL;
int i;
if (NULL == settings ||
@@ -5259,13 +4502,12 @@
PMSETTING_LOCK();
for (i = 0; settings[i]; i++) {
- OSSharedPtr<OSArray> newList;
- OSArray *list = OSDynamicCast(OSArray, settingsCallbacks->getObject(settings[i]));
+ list = OSDynamicCast(OSArray, settingsCallbacks->getObject(settings[i]));
if (!list) {
// New array of callbacks for this setting
- newList = OSArray::withCapacity(1);
- settingsCallbacks->setObject(settings[i], newList.get());
- list = newList.get();
+ list = OSArray::withCapacity(1);
+ settingsCallbacks->setObject(settings[i], list);
+ list->release();
}
// Add caller to the callback list
@@ -5290,7 +4532,7 @@
{
thread_t thisThread = current_thread();
PMSettingCallEntry *callEntry;
- OSSharedPtr<OSCollectionIterator> iter;
+ OSCollectionIterator *iter;
OSSymbol *sym;
OSArray *array;
int index;
@@ -5319,7 +4561,7 @@
} while (wait);
// Search each PM settings array in the kernel.
- iter = OSCollectionIterator::withCollection(settingsCallbacks.get());
+ iter = OSCollectionIterator::withCollection(settingsCallbacks);
if (iter) {
while ((sym = OSDynamicCast(OSSymbol, iter->getNextObject()))) {
array = OSDynamicCast(OSArray, settingsCallbacks->getObject(sym));
@@ -5328,6 +4570,7 @@
array->removeObject(index);
}
}
+ iter->release();
}
PMSETTING_UNLOCK();
@@ -5461,36 +4704,8 @@
IOPMrootDomain::evaluateSystemSleepPolicy(
IOPMSystemSleepParameters * params, int sleepPhase, uint32_t * hibMode )
{
-#define SLEEP_FACTOR(x) {(uint32_t) kIOPMSleepFactor ## x, #x}
-
- static const IONamedValue factorValues[] = {
- SLEEP_FACTOR( SleepTimerWake ),
- SLEEP_FACTOR( LidOpen ),
- SLEEP_FACTOR( ACPower ),
- SLEEP_FACTOR( BatteryLow ),
- SLEEP_FACTOR( StandbyNoDelay ),
- SLEEP_FACTOR( StandbyForced ),
- SLEEP_FACTOR( StandbyDisabled ),
- SLEEP_FACTOR( USBExternalDevice ),
- SLEEP_FACTOR( BluetoothHIDDevice ),
- SLEEP_FACTOR( ExternalMediaMounted ),
- SLEEP_FACTOR( ThunderboltDevice ),
- SLEEP_FACTOR( RTCAlarmScheduled ),
- SLEEP_FACTOR( MagicPacketWakeEnabled ),
- SLEEP_FACTOR( HibernateForced ),
- SLEEP_FACTOR( AutoPowerOffDisabled ),
- SLEEP_FACTOR( AutoPowerOffForced ),
- SLEEP_FACTOR( ExternalDisplay ),
- SLEEP_FACTOR( NetworkKeepAliveActive ),
- SLEEP_FACTOR( LocalUserActivity ),
- SLEEP_FACTOR( HibernateFailed ),
- SLEEP_FACTOR( ThermalWarning ),
- SLEEP_FACTOR( DisplayCaptured ),
- { 0, NULL }
- };
-
const IOPMSystemSleepPolicyTable * pt;
- OSSharedPtr<OSObject> prop;
+ OSObject * prop = NULL;
OSData * policyData;
uint64_t currentFactors = 0;
char currentFactorsBuf[512];
@@ -5513,9 +4728,9 @@
// Fetch additional settings
standbyEnabled = (getSleepOption(kIOPMDeepSleepDelayKey, &standbyDelay)
- && propertyHasValue(kIOPMDeepSleepEnabledKey, kOSBooleanTrue));
+ && (getProperty(kIOPMDeepSleepEnabledKey) == kOSBooleanTrue));
powerOffEnabled = (getSleepOption(kIOPMAutoPowerOffDelayKey, &powerOffDelay)
- && propertyHasValue(kIOPMAutoPowerOffEnabledKey, kOSBooleanTrue));
+ && (getProperty(kIOPMAutoPowerOffEnabledKey) == kOSBooleanTrue));
if (!getSleepOption(kIOPMAutoPowerOffTimerKey, &powerOffTimer)) {
powerOffTimer = powerOffDelay;
}
@@ -5540,106 +4755,120 @@
// If poweroff is enabled, force poweroff.
if (standbyEnabled) {
currentFactors |= kIOPMSleepFactorStandbyForced;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "StandbyForced");
} else if (powerOffEnabled) {
currentFactors |= kIOPMSleepFactorAutoPowerOffForced;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "AutoPowerOffForced");
} else {
currentFactors |= kIOPMSleepFactorHibernateForced;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "HibernateForced");
}
}
// Current factors based on environment and assertions
if (sleepTimerMaintenance) {
currentFactors |= kIOPMSleepFactorSleepTimerWake;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "SleepTimerWake");
}
if (standbyEnabled && sleepToStandby && !gSleepPolicyHandler) {
currentFactors |= kIOPMSleepFactorSleepTimerWake;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "SleepTimerWake");
}
if (!clamshellClosed) {
currentFactors |= kIOPMSleepFactorLidOpen;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "LidOpen");
}
if (acAdaptorConnected) {
currentFactors |= kIOPMSleepFactorACPower;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "ACPower");
}
if (lowBatteryCondition) {
- hibernateMode = 0;
- getSleepOption(kIOHibernateModeKey, &hibernateMode);
- if ((hibernateMode & kIOHibernateModeOn) == 0) {
- DLOG("HibernateMode is 0. Not sending LowBattery factor to IOPPF\n");
- } else {
- currentFactors |= kIOPMSleepFactorBatteryLow;
- }
+ currentFactors |= kIOPMSleepFactorBatteryLow;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "BatteryLow");
}
if (!standbyDelay || !standbyTimer) {
currentFactors |= kIOPMSleepFactorStandbyNoDelay;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "StandbyNoDelay");
}
if (standbyNixed || !standbyEnabled) {
currentFactors |= kIOPMSleepFactorStandbyDisabled;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "StandbyDisabled");
}
if (resetTimers) {
currentFactors |= kIOPMSleepFactorLocalUserActivity;
currentFactors &= ~kIOPMSleepFactorSleepTimerWake;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "LocalUserActivity, !SleepTimerWake");
}
if (getPMAssertionLevel(kIOPMDriverAssertionUSBExternalDeviceBit) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorUSBExternalDevice;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "USBExternalDevice");
}
if (getPMAssertionLevel(kIOPMDriverAssertionBluetoothHIDDevicePairedBit) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorBluetoothHIDDevice;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "BluetoothHIDDevice");
}
if (getPMAssertionLevel(kIOPMDriverAssertionExternalMediaMountedBit) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorExternalMediaMounted;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "ExternalMediaMounted");
}
if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit5) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorThunderboltDevice;
- }
- if (_scheduledAlarmMask != 0) {
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "ThunderboltDevice");
+ }
+ if (_scheduledAlarms != 0) {
currentFactors |= kIOPMSleepFactorRTCAlarmScheduled;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "RTCAlaramScheduled");
}
if (getPMAssertionLevel(kIOPMDriverAssertionMagicPacketWakeEnabledBit) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorMagicPacketWakeEnabled;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "MagicPacketWakeEnabled");
}
#define TCPKEEPALIVE 1
#if TCPKEEPALIVE
if (getPMAssertionLevel(kIOPMDriverAssertionNetworkKeepAliveActiveBit) !=
kIOPMDriverAssertionLevelOff) {
currentFactors |= kIOPMSleepFactorNetworkKeepAliveActive;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "NetworkKeepAliveActive");
}
#endif
if (!powerOffEnabled) {
currentFactors |= kIOPMSleepFactorAutoPowerOffDisabled;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "AutoPowerOffDisabled");
}
if (desktopMode) {
currentFactors |= kIOPMSleepFactorExternalDisplay;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "ExternalDisplay");
}
if (userWasActive) {
currentFactors |= kIOPMSleepFactorLocalUserActivity;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "LocalUserActivity");
}
if (darkWakeHibernateError && !CAP_HIGHEST(kIOPMSystemCapabilityGraphics)) {
currentFactors |= kIOPMSleepFactorHibernateFailed;
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "HibernateFailed");
}
if (thermalWarningState) {
currentFactors |= kIOPMSleepFactorThermalWarning;
- }
-
- for (int factorBit = 0; factorBit < (8 * sizeof(uint32_t)); factorBit++) {
- uint32_t factor = 1 << factorBit;
- if (factor & currentFactors) {
- strlcat(currentFactorsBuf, ", ", sizeof(currentFactorsBuf));
- strlcat(currentFactorsBuf, IOFindNameForValue(factor, factorValues), sizeof(currentFactorsBuf));
- }
- }
- DLOG("sleep factors 0x%llx%s\n", currentFactors, currentFactorsBuf);
+ snprintf(currentFactorsBuf, sizeof(currentFactorsBuf), "%s, %s", currentFactorsBuf, "ThermalWarning");
+ }
+
+ DLOG("sleep factors 0x%llx %s\n", currentFactors, currentFactorsBuf);
if (gSleepPolicyHandler) {
uint32_t savedHibernateMode;
IOReturn result;
if (!gSleepPolicyVars) {
- gSleepPolicyVars = IOMallocType(IOPMSystemSleepPolicyVariables);
+ gSleepPolicyVars = IONew(IOPMSystemSleepPolicyVariables, 1);
+ if (!gSleepPolicyVars) {
+ goto done;
+ }
+ bzero(gSleepPolicyVars, sizeof(*gSleepPolicyVars));
}
gSleepPolicyVars->signature = kIOPMSystemSleepPolicySignature;
gSleepPolicyVars->version = kIOPMSystemSleepPolicyVersion;
@@ -5651,7 +4880,7 @@
gSleepPolicyVars->standbyDelay = standbyDelay;
gSleepPolicyVars->standbyTimer = standbyTimer;
gSleepPolicyVars->poweroffDelay = powerOffDelay;
- gSleepPolicyVars->scheduledAlarms = _scheduledAlarmMask | _userScheduledAlarmMask;
+ gSleepPolicyVars->scheduledAlarms = _scheduledAlarms | _userScheduledAlarm;
gSleepPolicyVars->poweroffTimer = powerOffTimer;
if (kIOPMSleepPhase0 == sleepPhase) {
@@ -5697,7 +4926,7 @@
}
// Validate the sleep policy table
- policyData = OSDynamicCast(OSData, prop.get());
+ policyData = OSDynamicCast(OSData, prop);
if (!policyData || (policyData->getLength() <= sizeof(IOPMSystemSleepPolicyTable))) {
goto done;
}
@@ -5768,6 +4997,10 @@
}
done:
+ if (prop) {
+ prop->release();
+ }
+
return found;
}
@@ -5825,7 +5058,7 @@
IOPMrootDomain::evaluateSystemSleepPolicyFinal( void )
{
IOPMSystemSleepParameters params;
- OSSharedPtr<OSData> paramsData;
+ OSData * paramsData;
bool wakeNow;
// Evaluate sleep policy after sleeping drivers but before platform sleep.
@@ -5868,9 +5101,10 @@
resetTimers = false;
}
- paramsData = OSData::withValue(params);
+ paramsData = OSData::withBytes(¶ms, sizeof(params));
if (paramsData) {
- setProperty(kIOPMSystemSleepParametersKey, paramsData.get());
+ setProperty(kIOPMSystemSleepParametersKey, paramsData);
+ paramsData->release();
}
if (getSleepTypeAttributes(params.sleepType) &
@@ -5905,29 +5139,39 @@
bool
IOPMrootDomain::getSleepOption( const char * key, uint32_t * option )
{
- OSSharedPtr<OSObject> optionsProp;
- OSDictionary * optionsDict;
- OSSharedPtr<OSObject> obj;
- OSNumber * num;
- bool ok = false;
+ OSObject * optionsProp;
+ OSDictionary * optionsDict;
+ OSObject * obj = NULL;
+ OSNumber * num;
+ bool ok = false;
optionsProp = copyProperty(kRootDomainSleepOptionsKey);
- optionsDict = OSDynamicCast(OSDictionary, optionsProp.get());
+ optionsDict = OSDynamicCast(OSDictionary, optionsProp);
if (optionsDict) {
- obj.reset(optionsDict->getObject(key), OSRetain);
+ obj = optionsDict->getObject(key);
+ if (obj) {
+ obj->retain();
+ }
}
if (!obj) {
obj = copyProperty(key);
}
if (obj) {
- if ((num = OSDynamicCast(OSNumber, obj.get()))) {
+ if ((num = OSDynamicCast(OSNumber, obj))) {
*option = num->unsigned32BitValue();
ok = true;
- } else if (OSDynamicCast(OSBoolean, obj.get())) {
+ } else if (OSDynamicCast(OSBoolean, obj)) {
*option = (obj == kOSBooleanTrue) ? 1 : 0;
ok = true;
}
+ }
+
+ if (obj) {
+ obj->release();
+ }
+ if (optionsProp) {
+ optionsProp->release();
}
return ok;
@@ -6068,7 +5312,6 @@
{
AbsoluteTime startTime, elapsedTime;
uint32_t deltaTime;
- bool nvramSync = false;
memset(&gHaltRestartCtx, 0, sizeof(gHaltRestartCtx));
gHaltRestartCtx.RootDomain = this;
@@ -6080,14 +5323,12 @@
gHaltRestartCtx.PowerState = OFF_STATE;
gHaltRestartCtx.MessageType = kIOMessageSystemWillPowerOff;
gHaltRestartCtx.LogString = "PowerOff";
- nvramSync = true;
break;
case kPERestartCPU:
gHaltRestartCtx.PowerState = RESTART_STATE;
gHaltRestartCtx.MessageType = kIOMessageSystemWillRestart;
gHaltRestartCtx.LogString = "Restart";
- nvramSync = true;
break;
case kPEPagingOff:
@@ -6104,22 +5345,21 @@
return;
}
- if (nvramSync) {
- PESyncNVRAM();
- }
-
gHaltRestartCtx.phase = kNotifyPriorityClients;
// Notify legacy clients
applyToInterested(gIOPriorityPowerStateInterest, platformHaltRestartApplier, &gHaltRestartCtx);
// For normal shutdown, turn off File Server Mode.
if (kPEHaltCPU == pe_type) {
- OSSharedPtr<const OSSymbol> setting = OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey);
- OSSharedPtr<OSNumber> num = OSNumber::withNumber((unsigned long long) 0, 32);
+ const OSSymbol * setting = OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey);
+ OSNumber * num = OSNumber::withNumber((unsigned long long) 0, 32);
if (setting && num) {
- setPMSetting(setting.get(), num.get());
- }
- }
+ setPMSetting(setting, num);
+ setting->release();
+ num->release();
+ }
+ }
+
if (kPEPagingOff != pe_type) {
gHaltRestartCtx.phase = kNotifyPowerPlaneDrivers;
@@ -6128,13 +5368,13 @@
}
gHaltRestartCtx.phase = kNotifyHaltRestartAction;
-#if defined(XNU_TARGET_OS_OSX)
+#if !CONFIG_EMBEDDED
IOCPURunPlatformHaltRestartActions(pe_type);
-#else /* !defined(XNU_TARGET_OS_OSX) */
+#else
if (kPEPagingOff != pe_type) {
IOCPURunPlatformHaltRestartActions(pe_type);
}
-#endif /* !defined(XNU_TARGET_OS_OSX) */
+#endif
// Wait for PM to quiesce
if ((kPEPagingOff != pe_type) && gPMHaltLock) {
@@ -6231,11 +5471,11 @@
void
IOPMrootDomain::tagPowerPlaneService(
- IOService * service,
- IOPMActions * actions,
- IOPMPowerStateIndex maxPowerState )
+ IOService * service,
+ IOPMActions * actions )
{
uint32_t flags = 0;
+ bool isDisplayWrangler;
memset(actions, 0, sizeof(*actions));
actions->target = this;
@@ -6258,28 +5498,31 @@
return;
}
-#if DISPLAY_WRANGLER_PRESENT
- if (NULL != service->metaCast("IODisplayWrangler")) {
- // XXX should this really retain?
- wrangler.reset(service, OSRetain);
- wrangler->registerInterest(gIOGeneralInterest,
- &displayWranglerNotification, this, NULL);
-
+#if !NO_KERNEL_HID
+ isDisplayWrangler = (NULL != service->metaCast("IODisplayWrangler"));
+ if (isDisplayWrangler) {
+ wrangler = service;
// found the display wrangler, check for any display assertions already created
if (pmAssertions->getActivatedAssertions() & kIOPMDriverAssertionPreventDisplaySleepBit) {
DLOG("wrangler setIgnoreIdleTimer\(1) due to pre-existing assertion\n");
wrangler->setIgnoreIdleTimer( true );
}
+ }
+#else
+ isDisplayWrangler = false;
+#endif
+
+#if defined(__i386__) || defined(__x86_64__)
+ if (isDisplayWrangler) {
flags |= kPMActionsFlagIsDisplayWrangler;
}
-#endif /* DISPLAY_WRANGLER_PRESENT */
-
- if (service->propertyExists("IOPMStrictTreeOrder")) {
- flags |= kPMActionsFlagIsGraphicsDriver;
- }
- if (service->propertyExists("IOPMUnattendedWakePowerState")) {
- flags |= kPMActionsFlagIsAudioDriver;
- }
+ if (service->getProperty("IOPMStrictTreeOrder")) {
+ flags |= kPMActionsFlagIsGraphicsDevice;
+ }
+ if (service->getProperty("IOPMUnattendedWakePowerState")) {
+ flags |= kPMActionsFlagIsAudioDevice;
+ }
+#endif
// Find the power connection object that is a child of the PCI host
// bridge, and has a graphics/audio device attached below. Mark the
@@ -6290,7 +5533,7 @@
IORegistryEntry * parent = child->getParentEntry(gIOPowerPlane);
while (child != this) {
- if (child->propertyHasValue("IOPCITunnelled", kOSBooleanTrue)) {
+ if (child->getProperty("IOPCITunnelled") == kOSBooleanTrue) {
// Skip delaying notifications and clamping power on external graphics and audio devices.
DLOG("Avoiding delayChildNotification on object 0x%llx. flags: 0x%x\n", service->getRegistryEntryID(), flags);
flags = 0;
@@ -6310,25 +5553,13 @@
}
}
- OSSharedPtr<OSObject> prop = service->copyProperty(kIOPMDarkWakeMaxPowerStateKey);
- if (prop) {
- OSNumber * num = OSDynamicCast(OSNumber, prop.get());
- if (num) {
- actions->darkWakePowerState = num->unsigned32BitValue();
- if (actions->darkWakePowerState < maxPowerState) {
- flags |= kPMActionsFlagHasDarkWakePowerState;
- }
- }
- }
-
-
if (flags) {
DLOG("%s tag flags %x\n", service->getName(), flags);
- actions->flags |= flags;
+ actions->parameter |= flags;
actions->actionPowerChangeOverride =
OSMemberFunctionCast(
IOPMActionPowerChangeOverride, this,
- &IOPMrootDomain::overridePowerChangeForService);
+ &IOPMrootDomain::overridePowerChangeForUIService);
if (flags & kPMActionsFlagIsDisplayWrangler) {
actions->actionActivityTickle =
@@ -6349,8 +5580,8 @@
IOService * provider = service->getProvider();
if (OSDynamicCast(IOPlatformDevice, provider) &&
provider->inPlane(gIODTPlane)) {
- pciHostBridgeDevice.reset(provider, OSNoRetain);
- pciHostBridgeDriver.reset(service, OSNoRetain);
+ pciHostBridgeDevice = provider;
+ pciHostBridgeDriver = service;
DLOG("PMTrace found PCI host bridge %s->%s\n",
provider->getName(), service->getName());
}
@@ -6362,11 +5593,11 @@
// Would prefer to check built-in property, but tagPowerPlaneService()
// is called before pciDevice->registerService().
IORegistryEntry * parent = service->getParentEntry(gIODTPlane);
- if ((parent == pciHostBridgeDevice) && service->propertyExists("acpi-device")) {
+ if ((parent == pciHostBridgeDevice) && service->getProperty("acpi-device")) {
int bit = pmTracer->recordTopLevelPCIDevice( service );
if (bit >= 0) {
// Save the assigned bit for fast lookup.
- actions->flags |= (bit & kPMActionsPCIBitNumberMask);
+ actions->parameter |= (bit & kPMActionsPCIBitNumberMask);
actions->actionPowerChangeStart =
OSMemberFunctionCast(
@@ -6390,51 +5621,21 @@
IOPMrootDomain::overrideOurPowerChange(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
IOPMPowerStateIndex * inOutPowerState,
- IOPMPowerChangeFlags * inOutChangeFlags )
-{
+ IOPMPowerChangeFlags * inOutChangeFlags,
+ IOPMRequestTag requestTag )
+{
+ uint32_t powerState = (uint32_t) *inOutPowerState;
uint32_t changeFlags = *inOutChangeFlags;
- uint32_t desiredPowerState = (uint32_t) *inOutPowerState;
uint32_t currentPowerState = (uint32_t) getPowerState();
- if (request->getTag() == 0) {
- // Set a tag for any request that originates from IOServicePM
- (const_cast<IOPMRequest *>(request))->fTag = nextRequestTag(kCPSReasonPMInternals);
- }
-
- DLOG("PowerChangeOverride (%s->%s, %x, 0x%x) tag 0x%x\n",
- getPowerStateString(currentPowerState),
- getPowerStateString(desiredPowerState),
- _currentCapability, changeFlags,
- request->getTag());
-
-
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- /*
- * ASBM send lowBattery notifications every 1 second until the device
- * enters hibernation. This queues up multiple sleep requests.
- * After the device wakes from hibernation, none of these previously
- * queued sleep requests are valid.
- * lowBattteryCondition variable is set when ASBM notifies rootDomain
- * and is cleared at the very last point in sleep.
- * Any attempt to sleep with reason kIOPMSleepReasonLowPower without
- * lowBatteryCondition is invalid
- */
- if (REQUEST_TAG_TO_REASON(request->getTag()) == kIOPMSleepReasonLowPower) {
- if (!lowBatteryCondition) {
- DLOG("Duplicate lowBattery sleep");
- *inOutChangeFlags |= kIOPMNotDone;
- return;
- }
- }
-#endif
-
- if ((AOT_STATE == desiredPowerState) && (ON_STATE == currentPowerState)) {
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+ if ((AOT_STATE == powerState) && (ON_STATE == currentPowerState)) {
// Assertion may have been taken in AOT leading to changePowerStateTo(AOT)
*inOutChangeFlags |= kIOPMNotDone;
return;
}
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
if (changeFlags & kIOPMParentInitiated) {
// Root parent is permanently pegged at max power,
@@ -6443,20 +5644,9 @@
return;
}
-#if HIBERNATION && defined(__arm64__)
- if (lowBatteryCondition && (desiredPowerState < currentPowerState)) {
- if (!ml_is_secure_hib_supported() || ldmHibernateDisable) {
- // If hibernation is unsupported, reject sleep requests to avoid
- // racing with system shutdown.
- *inOutChangeFlags |= kIOPMNotDone;
- return;
- }
- }
-#endif /* HIBERNATION && defined(__arm64__) */
-
- if (desiredPowerState < currentPowerState) {
+ if (powerState < currentPowerState) {
if (CAP_CURRENT(kIOPMSystemCapabilityGraphics)) {
- // Root domain is dropping power state from ON->SLEEP.
+ // Root domain is dropping power state ON->SLEEP.
// If system is in full wake, first enter dark wake by
// converting the power drop to a capability change.
// Once in dark wake, transition to sleep state ASAP.
@@ -6473,13 +5663,13 @@
*inOutChangeFlags |= kIOPMSynchronize;
// Revert device desire from SLEEP to ON
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonPowerOverride);
+ changePowerStateToPriv(getRUN_STATE());
} else {
- // System is already in dark wake, ok to drop power state.
- // Broadcast root power down to entire tree.
+ // System is in dark wake, ok to drop power state.
+ // Broadcast root powering down to entire tree.
*inOutChangeFlags |= kIOPMRootChangeDown;
}
- } else if (desiredPowerState > currentPowerState) {
+ } else if (powerState > currentPowerState) {
if ((_currentCapability & kIOPMSystemCapabilityCPU) == 0) {
// Broadcast power up when waking from sleep, but not for the
// initial power change at boot by checking for cpu capability.
@@ -6492,73 +5682,55 @@
IOPMrootDomain::handleOurPowerChangeStart(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
- IOPMPowerStateIndex newPowerState,
- IOPMPowerChangeFlags * inOutChangeFlags )
-{
- IOPMRequestTag requestTag = request->getTag();
- IOPMRequestTag sleepReason;
-
+ IOPMPowerStateIndex powerState,
+ IOPMPowerChangeFlags * inOutChangeFlags,
+ IOPMRequestTag requestTag )
+{
uint32_t changeFlags = *inOutChangeFlags;
uint32_t currentPowerState = (uint32_t) getPowerState();
+ uint32_t sleepReason = requestTag ? requestTag : kIOPMSleepReasonIdle;
bool publishSleepReason = false;
-
- // Check if request has a valid sleep reason
- sleepReason = REQUEST_TAG_TO_REASON(requestTag);
- if (sleepReason < kIOPMSleepReasonClamshell) {
- sleepReason = kIOPMSleepReasonIdle;
- }
_systemTransitionType = kSystemTransitionNone;
_systemMessageClientMask = 0;
capabilityLoss = false;
toldPowerdCapWillChange = false;
- // Emergency notifications may arrive after the initial sleep request
- // has been queued. Override the sleep reason so powerd and others can
- // treat this as an emergency sleep.
if (lowBatteryCondition) {
+ // Low battery notification may arrive after the initial sleep request
+ // has been queued. Override the sleep reason so powerd and others can
+ // treat this as an emergency sleep.
sleepReason = kIOPMSleepReasonLowPower;
- } else if (thermalEmergencyState) {
- sleepReason = kIOPMSleepReasonThermalEmergency;
}
// 1. Explicit capability change.
+
if (changeFlags & kIOPMSynchronize) {
- if (newPowerState == ON_STATE) {
+ if (powerState == ON_STATE) {
if (changeFlags & kIOPMSyncNoChildNotify) {
- setSystemTransitionTypeGated(kSystemTransitionNewCapClient);
+ _systemTransitionType = kSystemTransitionNewCapClient;
} else {
- setSystemTransitionTypeGated(kSystemTransitionCapability);
+ _systemTransitionType = kSystemTransitionCapability;
}
}
}
// 2. Going to sleep (cancellation still possible).
- else if (newPowerState < currentPowerState) {
- setSystemTransitionTypeGated(kSystemTransitionSleep);
+ else if (powerState < currentPowerState) {
+ _systemTransitionType = kSystemTransitionSleep;
}
// 3. Woke from (idle or demand) sleep.
else if (!systemBooting &&
(changeFlags & kIOPMSelfInitiated) &&
- (newPowerState > currentPowerState)) {
- setSystemTransitionTypeGated(kSystemTransitionWake);
-
- _desiredCapability = kIOPMSystemCapabilityCPU | kIOPMSystemCapabilityNetwork;
+ (powerState > currentPowerState)) {
+ _systemTransitionType = kSystemTransitionWake;
+ _desiredCapability = kIOPMSystemCapabilityCPU |
+ kIOPMSystemCapabilityNetwork;
// Early exit from dark wake to full (e.g. LID open)
if (kFullWakeReasonNone != fullWakeReason) {
_desiredCapability |= (
kIOPMSystemCapabilityGraphics |
kIOPMSystemCapabilityAudio);
-
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- if (fullWakeReason == kFullWakeReasonLocalUser) {
- darkWakeExit = true;
- darkWakeToSleepASAP = false;
- setProperty(kIOPMRootDomainWakeTypeKey, isRTCAlarmWake ?
- kIOPMRootDomainWakeTypeAlarm : kIOPMRootDomainWakeTypeUser);
- }
-#endif
}
#if HIBERNATION
IOHibernateSetWakeCapabilities(_desiredCapability);
@@ -6584,7 +5756,7 @@
if ((kSystemTransitionCapability == _systemTransitionType) &&
(_pendingCapability == _currentCapability)) {
// Cancel the PM state change.
- setSystemTransitionTypeGated(kSystemTransitionNone);
+ _systemTransitionType = kSystemTransitionNone;
*inOutChangeFlags |= kIOPMNotDone;
}
if (__builtin_popcount(_pendingCapability) <
@@ -6594,22 +5766,11 @@
}
// 1. Capability change.
+
if (kSystemTransitionCapability == _systemTransitionType) {
// Dark to Full transition.
if (CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
tracePoint( kIOPMTracePointDarkWakeExit );
-
-#if defined(XNU_TARGET_OS_OSX)
- // rdar://problem/65627936
- // When a dark->full wake promotion is scheduled before an ON->SLEEP
- // power state drop, invalidate any request to drop power state already
- // in the queue, including the override variant, unless full wake cannot
- // be sustained. Any power state drop queued after this SustainFullWake
- // request will not be affected.
- if (checkSystemCanSustainFullWake()) {
- changePowerStateWithOverrideTo(getRUN_STATE(), kCPSReasonSustainFullWake);
- }
-#endif
willEnterFullWake();
}
@@ -6619,14 +5780,17 @@
// Clear previous stats
IOLockLock(pmStatsLock);
if (pmStatsAppResponses) {
+ pmStatsAppResponses->release();
pmStatsAppResponses = OSArray::withCapacity(5);
}
IOLockUnlock(pmStatsLock);
+
tracePoint( kIOPMTracePointDarkWakeEntry );
*inOutChangeFlags |= kIOPMSyncTellPowerDown;
_systemMessageClientMask = kSystemMessageClientPowerd |
kSystemMessageClientLegacyApp;
+
// rdar://15971327
// Prevent user active transitions before notifying clients
@@ -6646,7 +5810,7 @@
DLOG("sleepDelaysReport f->9 start at 0x%llx\n", ts_sleepStart);
}
- darkWakeExit = false;
+ wranglerTickled = false;
}
}
// 2. System sleep.
@@ -6664,14 +5828,6 @@
// transition to full wake, so don't notify them unless system
// has gained graphics capability since the last system wake.
_systemMessageClientMask &= ~kSystemMessageClientKernel;
- } else {
- // System was in full wake, but the downwards power transition is driven
- // by a request that originates from IOServicePM, so it isn't tagged with
- // a valid system sleep reason.
- if (REQUEST_TAG_TO_REASON(requestTag) == kCPSReasonPMInternals) {
- // Publish the same reason for full to dark
- sleepReason = fullToDarkReason;
- }
}
#if HIBERNATION
gIOHibernateState = 0;
@@ -6692,24 +5848,16 @@
tracePoint( kIOPMTracePointWakeWillPowerOnClients );
// Clear stats about sleep
- if (AOT_STATE == newPowerState) {
- // Temporarily increase the capacity of the log subsystem to buffer logs in AOT.
- os_log_adjust_buffering_capacity(LOG_BUFFERING_CAPACITY_MAX);
- _pendingCapability = kIOPMSystemCapabilityAOT;
- } else {
- // Restore the maximum capacity of the log subsystem once waking to full wake.
- os_log_adjust_buffering_capacity(LOG_BUFFERING_CAPACITY_DEFAULT);
- }
-
- if (AOT_STATE == currentPowerState) {
- // Wake events are no longer accepted after waking to AOT_STATE.
- // Re-enable wake event acceptance to append wake events claimed
- // during the AOT to ON_STATE transition.
- acceptSystemWakeEvents(kAcceptSystemWakeEvents_Reenable);
+ if (AOT_STATE == powerState) {
+ _pendingCapability = 0;
}
if (_pendingCapability & kIOPMSystemCapabilityGraphics) {
willEnterFullWake();
+ } else {
+ // Message powerd only
+ _systemMessageClientMask = kSystemMessageClientPowerd;
+ tellClients(kIOMessageSystemWillPowerOn);
}
}
@@ -6729,20 +5877,13 @@
kIOPMThermalEmergencySleepKey,
kIOPMMaintenanceSleepKey,
kIOPMSleepServiceExitKey,
- kIOPMDarkWakeThermalEmergencyKey,
- kIOPMNotificationWakeExitKey
+ kIOPMDarkWakeThermalEmergencyKey
};
// Record sleep cause in IORegistry
uint32_t reasonIndex = sleepReason - kIOPMSleepReasonClamshell;
if (reasonIndex < sizeof(IOPMSleepReasons) / sizeof(IOPMSleepReasons[0])) {
DLOG("sleep reason %s\n", IOPMSleepReasons[reasonIndex]);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Sleep Reason", "%s\n", IOPMSleepReasons[reasonIndex]
- );
-#endif /* DEVELOPMENT || DEBUG */
setProperty(kRootDomainSleepReasonKey, IOPMSleepReasons[reasonIndex]);
}
}
@@ -6752,84 +5893,35 @@
_systemStateGeneration++;
systemDarkWake = false;
- DLOG("=== START (%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
- getPowerStateString(currentPowerState),
- getPowerStateString((uint32_t) newPowerState),
- _currentCapability, _pendingCapability,
- *inOutChangeFlags, _systemStateGeneration, _systemMessageClientMask,
- requestTag);
-#if DEVELOPMENT || DEBUG
- if (currentPowerState != (uint32_t) newPowerState) {
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Start Power State Trans.",
- "(%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
- getPowerStateString(currentPowerState),
- getPowerStateString((uint32_t) newPowerState),
- _currentCapability,
- _pendingCapability,
- *inOutChangeFlags,
- _systemStateGeneration,
- _systemMessageClientMask,
- requestTag
- );
- }
-#endif /* DEVELOPMENT || DEBUG */
- }
-
- if ((AOT_STATE == newPowerState) && (SLEEP_STATE != currentPowerState)) {
+ DLOG("=== START (%s->%s, 0x%x) type %u, gen %u, msg %x, "
+ "dcp %x:%x:%x\n",
+ getPowerStateString(currentPowerState), getPowerStateString((uint32_t) powerState), *inOutChangeFlags,
+ _systemTransitionType, _systemStateGeneration,
+ _systemMessageClientMask,
+ _desiredCapability, _currentCapability, _pendingCapability);
+ }
+
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+ if ((AOT_STATE == powerState) && (SLEEP_STATE != currentPowerState)) {
panic("illegal AOT entry from %s", getPowerStateString(currentPowerState));
}
- if (_aotNow && (ON_STATE == newPowerState)) {
- WAKEEVENT_LOCK();
- aotShouldExit(true);
- WAKEEVENT_UNLOCK();
+ if (_aotNow && (ON_STATE == powerState)) {
+ aotShouldExit(false, true);
aotExit(false);
}
-}
-
-void
-IOPMrootDomain::setSystemTransitionTypeGated(SystemTransitionType type)
-{
- assert(gIOPMWorkLoop->inGate());
- _systemTransitionType = type;
- commandGate->commandWakeup(&_systemTransitionType);
-}
-
-void
-IOPMrootDomain::waitForSystemTransitionToMinPowerState(IOPMRootDomainPowerState state)
-{
- while (true) {
- IOReturn ret = gIOPMWorkLoop->runActionBlock(^{
- // Block until all in progress transitions have completed.
- while (_systemTransitionType != kSystemTransitionNone) {
- commandGate->commandSleep(&_systemTransitionType);
- }
-
- // Check the current power state.
- if (getPowerState() >= state) {
- return kIOReturnSuccess;
- }
-
- return kIOReturnError;
- });
-
- if (ret == kIOReturnSuccess) {
- break;
- }
- }
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
}
void
IOPMrootDomain::handleOurPowerChangeDone(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
- IOPMPowerStateIndex oldPowerState,
- IOPMPowerChangeFlags changeFlags )
+ IOPMPowerStateIndex powerState,
+ IOPMPowerChangeFlags changeFlags,
+ IOPMRequestTag requestTag __unused )
{
if (kSystemTransitionNewCapClient == _systemTransitionType) {
- setSystemTransitionTypeGated(kSystemTransitionNone);
+ _systemTransitionType = kSystemTransitionNone;
return;
}
@@ -6841,18 +5933,14 @@
_pendingCapability = _currentCapability;
lastSleepReason = 0;
- // When sleep is cancelled or reverted, don't report
- // the target (lower) power state as the previous state.
- oldPowerState = currentPowerState;
-
if (!CAP_CURRENT(kIOPMSystemCapabilityGraphics) &&
CAP_CURRENT(kIOPMSystemCapabilityCPU)) {
-#if defined(XNU_TARGET_OS_OSX)
+#if !CONFIG_EMBEDDED
pmPowerStateQueue->submitPowerEvent(
kPowerEventPolicyStimulus,
(void *) kStimulusDarkWakeReentry,
_systemStateGeneration );
-#else /* !defined(XNU_TARGET_OS_OSX) */
+#else
// On embedded, there are no factors that can prolong a
// "darkWake" when a power down is vetoed. We need to
// promote to "fullWake" at least once so that factors
@@ -6860,11 +5948,11 @@
pmPowerStateQueue->submitPowerEvent(
kPowerEventPolicyStimulus,
(void *) kStimulusDarkWakeActivityTickle);
-#endif /* !defined(XNU_TARGET_OS_OSX) */
+#endif
}
// Revert device desire to max.
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonPowerDownCancel);
+ changePowerStateToPriv(getRUN_STATE());
} else {
// Send message on dark wake to full wake promotion.
// tellChangeUp() handles the normal SLEEP->ON case.
@@ -6904,7 +5992,7 @@
wrangler->changePowerStateForRootDomain(
kWranglerPowerStateMin );
}
- removeProperty(gIOPMUserTriggeredFullWakeKey.get());
+ removeProperty(gIOPMUserTriggeredFullWakeKey);
}
}
@@ -6923,40 +6011,25 @@
}
}
-#if DEVELOPMENT || DEBUG
- if (currentPowerState != (uint32_t) oldPowerState) {
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Finish Power State Trans.",
- "(%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
- getPowerStateString((uint32_t)oldPowerState),
- getPowerStateString(currentPowerState),
- _currentCapability,
- _pendingCapability,
- changeFlags,
- _systemStateGeneration,
- _systemMessageClientMask,
- request->getTag()
- );
- }
-#endif /* DEVELOPMENT || DEBUG */
-
- DLOG("=== FINISH (%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
- getPowerStateString((uint32_t) oldPowerState), getPowerStateString(currentPowerState),
- _currentCapability, _pendingCapability,
- changeFlags, _systemStateGeneration, _systemMessageClientMask,
- request->getTag());
-
- if ((currentPowerState == ON_STATE) && pmAssertions) {
- pmAssertions->reportCPUBitAccounting();
- }
+ DLOG("=== FINISH (%s->%s, 0x%x) type %u, gen %u, msg %x, "
+ "dcp %x:%x:%x, dbgtimer %u\n",
+ getPowerStateString(currentPowerState), getPowerStateString((uint32_t) powerState), changeFlags,
+ _systemTransitionType, _systemStateGeneration,
+ _systemMessageClientMask,
+ _desiredCapability, _currentCapability, _pendingCapability,
+ _lastDebugWakeSeconds);
if (_pendingCapability & kIOPMSystemCapabilityGraphics) {
displayWakeCnt++;
-#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
- if (clamshellExists && fullWakeThreadCall) {
+#if DARK_TO_FULL_EVALUATE_CLAMSHELL
+ if (clamshellExists && fullWakeThreadCall &&
+ CAP_HIGHEST(kIOPMSystemCapabilityGraphics)) {
+ // Not the initial graphics full power, graphics won't
+ // send a power notification to trigger a lid state
+ // evaluation.
+
AbsoluteTime deadline;
- clock_interval_to_deadline(DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY, kSecondScale, &deadline);
+ clock_interval_to_deadline(45, kSecondScale, &deadline);
thread_call_enter_delayed(fullWakeThreadCall, deadline);
}
#endif
@@ -6975,11 +6048,11 @@
if (darkWakePostTickle &&
(kSystemTransitionWake == _systemTransitionType) &&
- (gDarkWakeFlags & kDarkWakeFlagPromotionMask) ==
- kDarkWakeFlagPromotionLate) {
+ (gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
+ kDarkWakeFlagHIDTickleLate) {
darkWakePostTickle = false;
reportUserInput();
- } else if (darkWakeExit) {
+ } else if (wranglerTickled) {
requestFullWake( kFullWakeReasonLocalUser );
}
@@ -6994,24 +6067,21 @@
tracePoint( kIOPMTracePointSystemUp );
}
- setSystemTransitionTypeGated(kSystemTransitionNone);
-
+ _systemTransitionType = kSystemTransitionNone;
_systemMessageClientMask = 0;
toldPowerdCapWillChange = false;
- darkWakeLogClamp = false;
+ logGraphicsClamp = false;
if (lowBatteryCondition) {
privateSleepSystem(kIOPMSleepReasonLowPower);
- } else if (thermalEmergencyState) {
- privateSleepSystem(kIOPMSleepReasonThermalEmergency);
- } else if ((fullWakeReason == kFullWakeReasonDisplayOn) && !displayPowerOnRequested) {
+ } else if ((fullWakeReason == kFullWakeReasonDisplayOn) && (!displayPowerOnRequested)) {
// Request for full wake is removed while system is waking up to full wake
DLOG("DisplayOn fullwake request is removed\n");
- handleSetDisplayPowerOn(false);
- }
-
- if ((gClamshellFlags & kClamshell_WAR_47715679) && isRTCAlarmWake) {
+ handleDisplayPowerOn();
+ }
+
+ if (isRTCAlarmWake) {
pmPowerStateQueue->submitPowerEvent(
kPowerEventReceivedPowerNotification, (void *)(uintptr_t) kLocalEvalClamshellCommand );
}
@@ -7023,83 +6093,69 @@
//******************************************************************************
void
-IOPMrootDomain::overridePowerChangeForService(
+IOPMrootDomain::overridePowerChangeForUIService(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
IOPMPowerStateIndex * inOutPowerState,
IOPMPowerChangeFlags * inOutChangeFlags )
{
uint32_t powerState = (uint32_t) *inOutPowerState;
uint32_t changeFlags = (uint32_t) *inOutChangeFlags;
- const uint32_t actionFlags = actions->flags;
if (kSystemTransitionNone == _systemTransitionType) {
// Not in midst of a system transition.
- // Do not set kPMActionsStatePowerClamped.
- } else if ((actions->state & kPMActionsStatePowerClamped) == 0) {
- bool enableClamp = false;
-
- // For most drivers, enable the clamp during ON->Dark transition
- // which has the kIOPMSynchronize flag set in changeFlags.
- if ((actionFlags & kPMActionsFlagIsDisplayWrangler) &&
+ // Do not modify power limit enable state.
+ } else if ((actions->parameter & kPMActionsFlagLimitPower) == 0) {
+ // Activate power limiter.
+
+ if ((actions->parameter & kPMActionsFlagIsDisplayWrangler) &&
((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
(changeFlags & kIOPMSynchronize)) {
- enableClamp = true;
- } else if ((actionFlags & kPMActionsFlagIsAudioDriver) &&
+ actions->parameter |= kPMActionsFlagLimitPower;
+ } else if ((actions->parameter & kPMActionsFlagIsAudioDevice) &&
((gDarkWakeFlags & kDarkWakeFlagAudioNotSuppressed) == 0) &&
((_pendingCapability & kIOPMSystemCapabilityAudio) == 0) &&
(changeFlags & kIOPMSynchronize)) {
- enableClamp = true;
- } else if ((actionFlags & kPMActionsFlagHasDarkWakePowerState) &&
- ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
- (changeFlags & kIOPMSynchronize)) {
- enableClamp = true;
- } else if ((actionFlags & kPMActionsFlagIsGraphicsDriver) &&
+ actions->parameter |= kPMActionsFlagLimitPower;
+ } else if ((actions->parameter & kPMActionsFlagIsGraphicsDevice) &&
(_systemTransitionType == kSystemTransitionSleep)) {
- // For graphics drivers, clamp power when entering
+ // For graphics devices, arm the limiter when entering
// system sleep. Not when dropping to dark wake.
- enableClamp = true;
- }
-
- if (enableClamp) {
- actions->state |= kPMActionsStatePowerClamped;
- DLOG("power clamp enabled %s %qx, pendingCap 0x%x, ps %d, cflags 0x%x\n",
- service->getName(), service->getRegistryEntryID(),
- _pendingCapability, powerState, changeFlags);
- }
- } else if ((actions->state & kPMActionsStatePowerClamped) != 0) {
- bool disableClamp = false;
-
- if ((actionFlags & (
+ actions->parameter |= kPMActionsFlagLimitPower;
+ }
+
+ if (actions->parameter & kPMActionsFlagLimitPower) {
+ DLOG("+ plimit %s %p\n",
+ service->getName(), OBFUSCATE(service));
+ }
+ } else {
+ // Remove power limit.
+
+ if ((actions->parameter & (
kPMActionsFlagIsDisplayWrangler |
- kPMActionsFlagIsGraphicsDriver)) &&
+ kPMActionsFlagIsGraphicsDevice)) &&
(_pendingCapability & kIOPMSystemCapabilityGraphics)) {
- disableClamp = true;
- } else if ((actionFlags & kPMActionsFlagIsAudioDriver) &&
+ actions->parameter &= ~kPMActionsFlagLimitPower;
+ } else if ((actions->parameter & kPMActionsFlagIsAudioDevice) &&
(_pendingCapability & kIOPMSystemCapabilityAudio)) {
- disableClamp = true;
- } else if ((actionFlags & kPMActionsFlagHasDarkWakePowerState) &&
- (_pendingCapability & kIOPMSystemCapabilityGraphics)) {
- disableClamp = true;
- }
-
- if (disableClamp) {
- actions->state &= ~kPMActionsStatePowerClamped;
- DLOG("power clamp removed %s %qx, pendingCap 0x%x, ps %d, cflags 0x%x\n",
- service->getName(), service->getRegistryEntryID(),
- _pendingCapability, powerState, changeFlags);
- }
- }
-
- if (actions->state & kPMActionsStatePowerClamped) {
- uint32_t maxPowerState = 0;
-
- // Determine the max power state allowed when clamp is enabled
+ actions->parameter &= ~kPMActionsFlagLimitPower;
+ }
+
+ if ((actions->parameter & kPMActionsFlagLimitPower) == 0) {
+ DLOG("- plimit %s %p\n",
+ service->getName(), OBFUSCATE(service));
+ }
+ }
+
+ if (actions->parameter & kPMActionsFlagLimitPower) {
+ uint32_t maxPowerState = (uint32_t)(-1);
+
if (changeFlags & (kIOPMDomainDidChange | kIOPMDomainWillChange)) {
- // Parent intiated power state changes
+ // Enforce limit for system power/cap transitions.
+
+ maxPowerState = 0;
if ((service->getPowerState() > maxPowerState) &&
- (actionFlags & kPMActionsFlagIsDisplayWrangler)) {
+ (actions->parameter & kPMActionsFlagIsDisplayWrangler)) {
maxPowerState++;
// Remove lingering effects of any tickle before entering
@@ -7109,45 +6165,46 @@
if (changeFlags & kIOPMDomainDidChange) {
*inOutChangeFlags |= kIOPMExpireIdleTimer;
}
- } else if (actionFlags & kPMActionsFlagIsGraphicsDriver) {
+ } else if (actions->parameter & kPMActionsFlagIsGraphicsDevice) {
maxPowerState++;
- } else if (actionFlags & kPMActionsFlagHasDarkWakePowerState) {
- maxPowerState = actions->darkWakePowerState;
}
} else {
// Deny all self-initiated changes when power is limited.
// Wrangler tickle should never defeat the limiter.
+
maxPowerState = service->getPowerState();
}
if (powerState > maxPowerState) {
- DLOG("power clamped %s %qx, ps %u->%u, cflags 0x%x)\n",
- service->getName(), service->getRegistryEntryID(),
- powerState, maxPowerState, changeFlags);
+ DLOG("> plimit %s %p (%u->%u, 0x%x)\n",
+ service->getName(), OBFUSCATE(service), powerState, maxPowerState,
+ changeFlags);
*inOutPowerState = maxPowerState;
if (darkWakePostTickle &&
- (actionFlags & kPMActionsFlagIsDisplayWrangler) &&
+ (actions->parameter & kPMActionsFlagIsDisplayWrangler) &&
(changeFlags & kIOPMDomainWillChange) &&
- ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) ==
- kDarkWakeFlagPromotionEarly)) {
+ ((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) ==
+ kDarkWakeFlagHIDTickleEarly)) {
darkWakePostTickle = false;
reportUserInput();
}
}
- if (!darkWakePowerClamped && (changeFlags & kIOPMDomainDidChange)) {
- if (darkWakeLogClamp) {
+ if (!graphicsSuppressed && (changeFlags & kIOPMDomainDidChange)) {
+ if (logGraphicsClamp) {
AbsoluteTime now;
uint64_t nsec;
clock_get_uptime(&now);
SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
absolutetime_to_nanoseconds(now, &nsec);
- DLOG("dark wake power clamped after %u ms\n",
- ((int)((nsec) / NSEC_PER_MSEC)));
- }
- darkWakePowerClamped = true;
+ if (kIOLogPMRootDomain & gIOKitDebug) {
+ MSG("Graphics suppressed %u ms\n",
+ ((int)((nsec) / NSEC_PER_MSEC)));
+ }
+ }
+ graphicsSuppressed = true;
}
}
}
@@ -7157,7 +6214,7 @@
IOService * service,
IOPMActions * actions )
{
-#if DISPLAY_WRANGLER_PRESENT
+#if !NO_KERNEL_HID
// Warning: Not running in PM work loop context - don't modify state !!!
// Trap tickle directed to IODisplayWrangler while running with graphics
// capability suppressed.
@@ -7174,7 +6231,8 @@
userActivityCount, lastSleepReason);
}
- if (!darkWakeExit && ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0)) {
+ if (!wranglerTickled &&
+ ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0)) {
DLOG("display wrangler tickled\n");
if (kIOLogPMRootDomain & gIOKitDebug) {
OSReportWithBacktrace("Dark wake display tickle");
@@ -7186,7 +6244,7 @@
true /* set wake type */ );
}
}
-#endif /* DISPLAY_WRANGLER_PRESENT */
+#endif
}
void
@@ -7197,7 +6255,7 @@
IOPMPowerStateIndex oldPowerState,
IOPMPowerStateIndex newPowerState )
{
-#if DISPLAY_WRANGLER_PRESENT
+#if !NO_KERNEL_HID
assert(service == wrangler);
// This function implements half of the user active detection
@@ -7235,7 +6293,7 @@
} else if (newPowerState == kWranglerPowerStateMax) {
evaluatePolicy( kStimulusDisplayWranglerWake );
}
-#endif /* DISPLAY_WRANGLER_PRESENT */
+#endif
}
//******************************************************************************
@@ -7245,7 +6303,7 @@
void
IOPMrootDomain::preventTransitionToUserActive( bool prevent )
{
-#if DISPLAY_WRANGLER_PRESENT
+#if !NO_KERNEL_HID
_preventUserActive = prevent;
if (wrangler && !_preventUserActive) {
// Allowing transition to user active, but the wrangler may have
@@ -7259,7 +6317,7 @@
evaluatePolicy( kStimulusEnterUserActiveState );
}
}
-#endif /* DISPLAY_WRANGLER_PRESENT */
+#endif
}
//******************************************************************************
@@ -7270,7 +6328,8 @@
IOPMrootDomain::shouldDelayChildNotification(
IOService * service )
{
- if ((kFullWakeReasonNone == fullWakeReason) &&
+ if (((gDarkWakeFlags & kDarkWakeFlagHIDTickleMask) != 0) &&
+ (kFullWakeReasonNone == fullWakeReason) &&
(kSystemTransitionWake == _systemTransitionType)) {
DLOG("%s: delay child notify\n", service->getName());
return true;
@@ -7286,34 +6345,32 @@
IOPMrootDomain::handlePowerChangeStartForPCIDevice(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
IOPMPowerStateIndex powerState,
IOPMPowerChangeFlags * inOutChangeFlags )
{
pmTracer->tracePCIPowerChange(
PMTraceWorker::kPowerChangeStart,
service, *inOutChangeFlags,
- (actions->flags & kPMActionsPCIBitNumberMask));
+ (actions->parameter & kPMActionsPCIBitNumberMask));
}
void
IOPMrootDomain::handlePowerChangeDoneForPCIDevice(
IOService * service,
IOPMActions * actions,
- const IOPMRequest * request,
IOPMPowerStateIndex powerState,
IOPMPowerChangeFlags changeFlags )
{
pmTracer->tracePCIPowerChange(
PMTraceWorker::kPowerChangeCompleted,
service, changeFlags,
- (actions->flags & kPMActionsPCIBitNumberMask));
+ (actions->parameter & kPMActionsPCIBitNumberMask));
}
//******************************************************************************
// registerInterest
//
-// Override IOService::registerInterest() for root domain clients.
+// Override IOService::registerInterest() to intercept special clients.
//******************************************************************************
class IOPMServiceInterestNotifier : public _IOServiceInterestNotifier
@@ -7322,36 +6379,32 @@
OSDeclareDefaultStructors(IOPMServiceInterestNotifier);
protected:
- uint32_t ackTimeoutCnt;
- uint32_t msgType; // Last type seen by the message filter
- uint32_t lastSleepWakeMsgType;
- uint32_t msgIndex;
- uint32_t maxMsgDelayMS;
- uint32_t maxAckDelayMS;
- uint64_t msgAbsTime;
- uint64_t uuid0;
- uint64_t uuid1;
- OSSharedPtr<const OSSymbol> identifier;
- OSSharedPtr<const OSSymbol> clientName;
+ uint32_t ackTimeoutCnt;
+ uint32_t msgType;// Message pending ack
+
+ uint64_t uuid0;
+ uint64_t uuid1;
+ const OSSymbol *identifier;
};
OSDefineMetaClassAndStructors(IOPMServiceInterestNotifier, _IOServiceInterestNotifier)
-OSSharedPtr<IONotifier>
-IOPMrootDomain::registerInterest(
+IONotifier * IOPMrootDomain::registerInterest(
const OSSymbol * typeOfInterest,
IOServiceInterestHandler handler,
void * target, void * ref )
{
- IOPMServiceInterestNotifier* notifier;
+ IOPMServiceInterestNotifier *notifier = NULL;
bool isSystemCapabilityClient;
bool isKernelCapabilityClient;
- IOReturn rc = kIOReturnError;
-
- isSystemCapabilityClient = typeOfInterest &&
+ IOReturn rc = kIOReturnError;;
+
+ isSystemCapabilityClient =
+ typeOfInterest &&
typeOfInterest->isEqualTo(kIOPMSystemCapabilityInterest);
- isKernelCapabilityClient = typeOfInterest &&
+ isKernelCapabilityClient =
+ typeOfInterest &&
typeOfInterest->isEqualTo(gIOPriorityPowerStateInterest);
if (isSystemCapabilityClient) {
@@ -7367,13 +6420,13 @@
rc = super::registerInterestForNotifier(notifier, typeOfInterest, handler, target, ref);
}
if (rc != kIOReturnSuccess) {
- OSSafeReleaseNULL(notifier);
+ notifier->release();
+ notifier = NULL;
+
return NULL;
}
-
- notifier->ackTimeoutCnt = 0;
-
if (pmPowerStateQueue) {
+ notifier->ackTimeoutCnt = 0;
if (isSystemCapabilityClient) {
notifier->retain();
if (pmPowerStateQueue->submitPowerEvent(
@@ -7391,9 +6444,9 @@
}
}
- OSSharedPtr<OSData> data;
+ OSData *data = NULL;
uint8_t *uuid = NULL;
- OSSharedPtr<OSKext> kext = OSKext::lookupKextWithAddress((vm_address_t)handler);
+ OSKext *kext = OSKext::lookupKextWithAddress((vm_address_t)handler);
if (kext) {
data = kext->copyUUID();
}
@@ -7407,9 +6460,16 @@
((uint64_t)(uuid[11]) << 32) | ((uint64_t)(uuid[12]) << 24) | ((uint64_t)(uuid[13]) << 16) |
((uint64_t)(uuid[14]) << 8) | (uuid[15]);
- notifier->identifier = copyKextIdentifierWithAddress((vm_address_t) handler);
- }
- return OSSharedPtr<IOPMServiceInterestNotifier>(notifier, OSNoRetain);
+ notifier->identifier = kext->getIdentifier();
+ }
+ if (kext) {
+ kext->release();
+ }
+ if (data) {
+ data->release();
+ }
+
+ return notifier;
}
//******************************************************************************
@@ -7423,36 +6483,29 @@
{
const IOPMInterestContext * context = (const IOPMInterestContext *) arg1;
bool isCapMsg = (context->messageType == kIOMessageSystemCapabilityChange);
- bool isCapPowerd = (object == (void *) systemCapabilityNotifier.get());
bool isCapClient = false;
bool allow = false;
- OSBoolean **waitForReply = (typeof(waitForReply))arg3;
IOPMServiceInterestNotifier *notifier;
notifier = OSDynamicCast(IOPMServiceInterestNotifier, (OSObject *)object);
do {
- // When powerd and kernel priority clients register capability interest,
- // the power tree is sync'ed to inform those clients about the current
- // system capability. Only allow capability change messages during sync.
if ((kSystemTransitionNewCapClient == _systemTransitionType) &&
(!isCapMsg || !_joinedCapabilityClients ||
!_joinedCapabilityClients->containsObject((OSObject *) object))) {
break;
}
- // Capability change message for powerd and kernel clients
+ // Capability change message for app and kernel clients.
+
if (isCapMsg) {
- // Kernel priority clients
if ((context->notifyType == kNotifyPriority) ||
(context->notifyType == kNotifyCapabilityChangePriority)) {
isCapClient = true;
}
- // powerd will maintain two client registrations with root domain.
- // isCapPowerd will be TRUE for any message targeting the powerd
- // exclusive (capability change) interest registration.
- if (isCapPowerd && (context->notifyType == kNotifyCapabilityChangeApps)) {
+ if ((context->notifyType == kNotifyCapabilityChangeApps) &&
+ (object == (void *) systemCapabilityNotifier)) {
isCapClient = true;
}
}
@@ -7475,105 +6528,92 @@
capArgs->changeFlags = kIOPMSystemCapabilityDidChange;
}
- if (isCapPowerd && context->isPreChange) {
+ if ((object == (void *) systemCapabilityNotifier) &&
+ context->isPreChange) {
toldPowerdCapWillChange = true;
}
}
- // App level capability change messages must only go to powerd.
+ // Capability change messages only go to the PM configd plugin.
// Wait for response post-change if capabilitiy is increasing.
// Wait for response pre-change if capability is decreasing.
- if ((context->notifyType == kNotifyCapabilityChangeApps) && waitForReply &&
+ if ((context->notifyType == kNotifyCapabilityChangeApps) && arg3 &&
((capabilityLoss && context->isPreChange) ||
(!capabilityLoss && !context->isPreChange))) {
- *waitForReply = kOSBooleanTrue;
+ // app has not replied yet, wait for it
+ *((OSObject **) arg3) = kOSBooleanFalse;
}
allow = true;
break;
}
- // powerd will always receive CanSystemSleep, even for a demand sleep.
- // It will also have a final chance to veto sleep after all clients
- // have responded to SystemWillSleep
+ // Capability client will always see kIOMessageCanSystemSleep,
+ // even for demand sleep. It will also have a chance to veto
+ // sleep one last time after all clients have responded to
+ // kIOMessageSystemWillSleep
if ((kIOMessageCanSystemSleep == context->messageType) ||
(kIOMessageSystemWillNotSleep == context->messageType)) {
- if (isCapPowerd) {
+ if (object == (OSObject *) systemCapabilityNotifier) {
allow = true;
break;
}
- // Demand sleep, don't ask apps for permission
+ // Not idle sleep, don't ask apps.
if (context->changeFlags & kIOPMSkipAskPowerDown) {
break;
}
}
if (kIOPMMessageLastCallBeforeSleep == context->messageType) {
- if (isCapPowerd && CAP_HIGHEST(kIOPMSystemCapabilityGraphics) &&
+ if ((object == (OSObject *) systemCapabilityNotifier) &&
+ CAP_HIGHEST(kIOPMSystemCapabilityGraphics) &&
(fullToDarkReason == kIOPMSleepReasonIdle)) {
allow = true;
}
break;
}
- // Drop capability change messages for legacy clients.
- // Drop legacy system sleep messages for powerd capability interest.
- if (isCapMsg || isCapPowerd) {
+ // Reject capability change messages for legacy clients.
+ // Reject legacy system sleep messages for capability client.
+
+ if (isCapMsg || (object == (OSObject *) systemCapabilityNotifier)) {
break;
}
- // Not a capability change message.
- // Perform message filtering based on _systemMessageClientMask.
+ // Filter system sleep messages.
if ((context->notifyType == kNotifyApps) &&
(_systemMessageClientMask & kSystemMessageClientLegacyApp)) {
- if (!notifier) {
- break;
- }
-
- if ((notifier->lastSleepWakeMsgType == context->messageType) &&
- (notifier->lastSleepWakeMsgType == kIOMessageSystemWillPowerOn)) {
- break; // drop any duplicate WillPowerOn for AOT devices
- }
-
allow = true;
- if (waitForReply) {
- if (notifier->ackTimeoutCnt >= 3) {
- *waitForReply = kOSBooleanFalse;
- } else {
- *waitForReply = kOSBooleanTrue;
+ if (notifier) {
+ if (arg3) {
+ if (notifier->ackTimeoutCnt >= 3) {
+ *((OSObject **) arg3) = kOSBooleanFalse;
+ } else {
+ *((OSObject **) arg3) = kOSBooleanTrue;
+ }
}
}
} else if ((context->notifyType == kNotifyPriority) &&
(_systemMessageClientMask & kSystemMessageClientKernel)) {
allow = true;
}
-
- // Check sleep/wake message ordering
- if (allow) {
- if (context->messageType == kIOMessageSystemWillSleep ||
- context->messageType == kIOMessageSystemWillPowerOn ||
- context->messageType == kIOMessageSystemHasPoweredOn) {
- notifier->lastSleepWakeMsgType = context->messageType;
- }
- }
- } while (false);
+ }while (false);
if (allow && isCapMsg && _joinedCapabilityClients) {
_joinedCapabilityClients->removeObject((OSObject *) object);
if (_joinedCapabilityClients->getCount() == 0) {
- DMSG("destroyed capability client set %p\n",
- OBFUSCATE(_joinedCapabilityClients.get()));
- _joinedCapabilityClients.reset();
+ DLOG("destroyed capability client set %p\n",
+ OBFUSCATE(_joinedCapabilityClients));
+ _joinedCapabilityClients->release();
+ _joinedCapabilityClients = NULL;
}
}
if (notifier) {
- // Record the last seen message type even if the message is dropped
- // for traceFilteredNotification().
notifier->msgType = context->messageType;
}
@@ -7589,24 +6629,32 @@
IOPMrootDomain::setMaintenanceWakeCalendar(
const IOPMCalendarStruct * calendar )
{
- OSSharedPtr<OSData> data;
+ OSData * data;
IOReturn ret = 0;
if (!calendar) {
return kIOReturnBadArgument;
}
- data = OSData::withValue(*calendar);
+ data = OSData::withBytes((void *) calendar, sizeof(*calendar));
if (!data) {
return kIOReturnNoMemory;
}
if (kPMCalendarTypeMaintenance == calendar->selector) {
- ret = setPMSetting(gIOPMSettingMaintenanceWakeCalendarKey.get(), data.get());
+ ret = setPMSetting(gIOPMSettingMaintenanceWakeCalendarKey, data);
+ if (kIOReturnSuccess == ret) {
+ OSBitOrAtomic(kIOPMAlarmBitMaintenanceWake, &_scheduledAlarms);
+ }
} else if (kPMCalendarTypeSleepService == calendar->selector) {
- ret = setPMSetting(gIOPMSettingSleepServiceWakeCalendarKey.get(), data.get());
- }
-
+ ret = setPMSetting(gIOPMSettingSleepServiceWakeCalendarKey, data);
+ if (kIOReturnSuccess == ret) {
+ OSBitOrAtomic(kIOPMAlarmBitSleepServiceWake, &_scheduledAlarms);
+ }
+ }
+ DLOG("_scheduledAlarms = 0x%x\n", (uint32_t) _scheduledAlarms);
+
+ data->release();
return ret;
}
@@ -7625,8 +6673,8 @@
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize )
{
-#if DISPLAY_WRANGLER_PRESENT
- IOPMPowerStateIndex displayPowerState;
+#if !NO_KERNEL_HID
+ int displayPowerState;
IOPowerStateChangeNotification * params =
(IOPowerStateChangeNotification *) messageArgument;
@@ -7642,7 +6690,7 @@
displayPowerState = params->stateNumber;
DLOG("wrangler %s ps %d\n",
- getIOMessageString(messageType), (uint32_t) displayPowerState);
+ getIOMessageString(messageType), displayPowerState);
switch (messageType) {
case kIOMessageDeviceWillPowerOff:
@@ -7675,8 +6723,32 @@
}
break;
}
-#endif /* DISPLAY_WRANGLER_PRESENT */
+#endif
return kIOReturnUnsupported;
+}
+
+//******************************************************************************
+// displayWranglerMatchPublished
+//
+// Receives a notification when the IODisplayWrangler is published.
+// When it's published we install a power state change handler.
+//******************************************************************************
+
+bool
+IOPMrootDomain::displayWranglerMatchPublished(
+ void * target,
+ void * refCon,
+ IOService * newService,
+ IONotifier * notifier __unused)
+{
+#if !NO_KERNEL_HID
+ // install a handler
+ if (!newService->registerInterest( gIOGeneralInterest,
+ &displayWranglerNotification, target, NULL)) {
+ return false;
+ }
+#endif
+ return true;
}
//******************************************************************************
@@ -7685,64 +6757,27 @@
//******************************************************************************
void
-IOPMrootDomain::updateUserActivity( void )
-{
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- clock_get_uptime(&userActivityTime);
- bool aborting = ((lastSleepReason == kIOPMSleepReasonSoftware)
- || (lastSleepReason == kIOPMSleepReasonIdle)
- || (lastSleepReason == kIOPMSleepReasonMaintenance));
- if (aborting) {
- userActivityCount++;
- DLOG("user activity reported %d lastSleepReason %d\n", userActivityCount, lastSleepReason);
- }
-#endif
-}
-void
IOPMrootDomain::reportUserInput( void )
{
+#if !NO_KERNEL_HID
+ OSIterator * iter;
+ OSDictionary * matching;
+
+ if (!wrangler) {
+ matching = serviceMatching("IODisplayWrangler");
+ iter = getMatchingServices(matching);
+ if (matching) {
+ matching->release();
+ }
+ if (iter) {
+ wrangler = OSDynamicCast(IOService, iter->getNextObject());
+ iter->release();
+ }
+ }
+
if (wrangler) {
wrangler->activityTickle(0, 0);
}
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- // Update user activity
- updateUserActivity();
-
- if (!darkWakeExit && ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0)) {
- // update user active abs time
- clock_get_uptime(&gUserActiveAbsTime);
- pmPowerStateQueue->submitPowerEvent(
- kPowerEventPolicyStimulus,
- (void *) kStimulusDarkWakeActivityTickle,
- true /* set wake type */ );
- }
-#endif
-}
-
-void
-IOPMrootDomain::requestUserActive(IOService *device, const char *reason)
-{
-#if DISPLAY_WRANGLER_PRESENT
- if (wrangler) {
- wrangler->activityTickle(0, 0);
- }
-#else
- if (!device) {
- DLOG("requestUserActive: device is null\n");
- return;
- }
- OSSharedPtr<const OSSymbol> deviceName = device->copyName();
- uint64_t registryID = device->getRegistryEntryID();
-
- if (!deviceName || !registryID) {
- DLOG("requestUserActive: no device name or registry entry\n");
- return;
- }
- const char *name = deviceName->getCStringNoCopy();
- char payload[128];
- snprintf(payload, sizeof(payload), "%s:%s", name, reason);
- DLOG("requestUserActive from %s (0x%llx) for %s\n", name, registryID, reason);
- messageClient(kIOPMMessageRequestUserActive, systemCapabilityNotifier.get(), (void *)payload, sizeof(payload));
#endif
}
@@ -7753,7 +6788,7 @@
bool
IOPMrootDomain::latchDisplayWranglerTickle( bool latch )
{
-#if DISPLAY_WRANGLER_PRESENT
+#if !NO_KERNEL_HID
if (latch) {
if (!(_currentCapability & kIOPMSystemCapabilityGraphics) &&
!(_pendingCapability & kIOPMSystemCapabilityGraphics) &&
@@ -7761,22 +6796,22 @@
// Currently in dark wake, and not transitioning to full wake.
// Full wake is unsustainable, so latch the tickle to prevent
// the display from lighting up momentarily.
- wranglerTickled = true;
+ wranglerTickleLatched = true;
} else {
- wranglerTickled = false;
- }
- } else if (wranglerTickled && checkSystemCanSustainFullWake()) {
- wranglerTickled = false;
+ wranglerTickleLatched = false;
+ }
+ } else if (wranglerTickleLatched && checkSystemCanSustainFullWake()) {
+ wranglerTickleLatched = false;
pmPowerStateQueue->submitPowerEvent(
kPowerEventPolicyStimulus,
(void *) kStimulusDarkWakeActivityTickle );
}
- return wranglerTickled;
-#else /* ! DISPLAY_WRANGLER_PRESENT */
+ return wranglerTickleLatched;
+#else
return false;
-#endif /* ! DISPLAY_WRANGLER_PRESENT */
+#endif
}
//******************************************************************************
@@ -7793,6 +6828,32 @@
}
// MARK: -
+// MARK: Battery
+
+//******************************************************************************
+// batteryPublished
+//
+// Notification on battery class IOPowerSource appearance
+//******************************************************************************
+
+bool
+IOPMrootDomain::batteryPublished(
+ void * target,
+ void * root_domain,
+ IOService * resourceService,
+ IONotifier * notifier __unused )
+{
+ // rdar://2936060&4435589
+ // All laptops have dimmable LCD displays
+ // All laptops have batteries
+ // So if this machine has a battery, publish the fact that the backlight
+ // supports dimming.
+ ((IOPMrootDomain *)root_domain)->publishFeature("DisplayDims");
+
+ return true;
+}
+
+// MARK: -
// MARK: System PM Policy
//******************************************************************************
@@ -7809,11 +6870,6 @@
// Conditions that prevent idle and demand system sleep.
do {
- if (gSleepDisabledFlag) {
- err = kPMConfigPreventSystemSleep;
- break;
- }
-
if (userDisabledAllSleep) {
err = kPMUserDisabledAllSleep; // 1. user-space sleep kill switch
break;
@@ -7837,31 +6893,8 @@
break;
#endif
- if (_driverKitMatchingAssertionCount != 0 || _driverKitSyncedAssertionCount != 0) {
- err = kPMCPUAssertion;
- break;
- }
-
- // Check for any dexts currently being added to the PM tree. Sleeping while
- // this is in flight can cause IOServicePH to timeout.
- if (!IOServicePH::checkPMReady()) {
-#if !defined(XNU_TARGET_OS_OSX)
- if (!(lowBatteryCondition || thermalWarningState || thermalEmergencyState)) {
- // 116893363: kPMDKNotReady sleep cancellations often leaves embedded devices
- // in dark wake for long periods of time, which causes issues as apps were
- // already informed of sleep during the f->9 transition. As a temporary
- // measure, always full wake if we hit this specific condition.
- pmPowerStateQueue->submitPowerEvent(
- kPowerEventPolicyStimulus,
- (void *) kStimulusDarkWakeActivityTickle);
- }
-#endif
- err = kPMDKNotReady;
- break;
- }
-
- if (lowBatteryCondition || thermalWarningState || thermalEmergencyState) {
- break; // always sleep on low battery or when in thermal warning/emergency state
+ if (lowBatteryCondition || thermalWarningState) {
+ break; // always sleep on low battery or when in thermal warning state
}
if (sleepReason == kIOPMSleepReasonDarkWakeThermalEmergency) {
@@ -7872,7 +6905,6 @@
err = kPMChildPreventSystemSleep; // 4. child prevent system sleep clamp
break;
}
-
if (getPMAssertionLevel( kIOPMDriverAssertionCPUBit ) ==
kIOPMDriverAssertionLevelOn) {
@@ -7890,7 +6922,7 @@
IOReturn ret;
OSBitAndAtomic(~kPCICantSleep, &platformSleepSupport);
ret = getPlatform()->callPlatformFunction(
- sleepSupportedPEFunction.get(), false,
+ sleepSupportedPEFunction, false,
NULL, NULL, NULL, NULL);
pciCantSleepValid = true;
pciCantSleepFlag = false;
@@ -7930,14 +6962,15 @@
bool
IOPMrootDomain::checkSystemCanSustainFullWake( void )
{
- if (lowBatteryCondition || thermalWarningState || thermalEmergencyState) {
+#if !NO_KERNEL_HID
+ if (lowBatteryCondition || thermalWarningState) {
// Low battery wake, or received a low battery notification
// while system is awake. This condition will persist until
// the following wake.
return false;
}
- if (clamshellExists && clamshellClosed && !clamshellSleepDisableMask) {
+ if (clamshellExists && clamshellClosed && !clamshellSleepDisabled) {
// Graphics state is unknown and external display might not be probed.
// Do not incorporate state that requires graphics to be in max power
// such as desktopMode or clamshellDisabled.
@@ -7947,107 +6980,8 @@
return false;
}
}
+#endif
return true;
-}
-
-//******************************************************************************
-// checkSystemCanAbortIdleSleep
-//******************************************************************************
-
-bool
-IOPMrootDomain::checkSystemCanAbortIdleSleep( void )
-{
- bool abortableSleepType = ((lastSleepReason == kIOPMSleepReasonIdle)
- || (lastSleepReason == 0));
- return idleSleepRevertible && abortableSleepType;
-}
-
-//******************************************************************************
-// considerRunMode
-// consider the driver for AOT power on via the runmode mask
-//******************************************************************************
-
-int32_t
-IOPMrootDomain::considerRunMode(IOService * service, uint64_t pmDriverClass)
-{
- int32_t promote;
-
- if ((0 == _aotRunMode) || (service == this)) {
- // neutral
- return 0;
- }
- if (pmDriverClass) {
- IOLog("considerRunMode: %s 0x%llx 0x%llx\n", service->getName(), pmDriverClass, _aotRunMode);
- }
- promote = (0 != (_aotRunMode & pmDriverClass)) ? 1 : -1;
- if (promote > 0) {
- IOLog("IOPMRD: %s 0x%llx runmode to %s\n", service->getName(), pmDriverClass, (promote < 0) ? "OFF" : "ON");
- }
- return promote;
-}
-
-void
-IOPMrootDomain::handleRegisterPowerDriver(IOService * child)
-{
- OSNumber * num;
- IOService * userServer;
- uint64_t driverClassFlags;
- OSSharedPtr<OSObject> prop = child->copyProperty(kIOPMAOTAllowKey);
-
- if (!prop || (NULL == (num = OSDynamicCast(OSNumber, prop.get())))) {
- return;
- }
- driverClassFlags = num->unsigned64BitValue();
-
- userServer = NULL;
- if (child->reserved->uvars && (userServer = child->reserved->uvars->userServer)) {
- WAKEEVENT_LOCK();
- _aotWakeEventRunModeImpliesStorage |= driverClassFlags;
- WAKEEVENT_UNLOCK();
- }
-
- IOLog("addPMDriverClass %s %llx\n", child->getName(), driverClassFlags);
- if (driverClassFlags) {
- child->addPMDriverClass(driverClassFlags);
- if (userServer) {
- userServer->addPMDriverClass(driverClassFlags);
- }
- }
-}
-
-//******************************************************************************
-// attemptIdleSleepAbort
-//******************************************************************************
-
-bool
-IOPMrootDomain::attemptIdleSleepAbort( void )
-{
- if (!gIOPMWorkLoop->inGate()) {
- bool ret = gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::attemptIdleSleepAbort),
- this);
- return ret;
- }
-
- bool canAbort = checkSystemCanAbortIdleSleep();
- if (canAbort) {
- cancelIdlePowerDownSync();
- } else if (lastSleepReason == kIOPMSleepReasonIdle) {
- scheduleImmediateDebugWake();
- }
-
- return canAbort;
-}
-
-//******************************************************************************
-// setIdleSleepRevertible
-//******************************************************************************
-
-void
-IOPMrootDomain::setIdleSleepRevertible( bool revertible )
-{
- idleSleepRevertible = revertible;
}
//******************************************************************************
@@ -8070,17 +7004,21 @@
// Tables for accumulated days in year by month, latter used for leap years
-static const unsigned int daysbymonth[] =
+static const int daysbymonth[] =
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
-static const unsigned int lydaysbymonth[] =
+static const int lydaysbymonth[] =
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };
static int __unused
-IOPMConvertSecondsToCalendar(clock_sec_t secs, IOPMCalendarStruct * dt)
-{
- const unsigned int * dbm = daysbymonth;
- clock_sec_t n, x, y, z;
+IOPMConvertSecondsToCalendar(long secs, IOPMCalendarStruct * dt)
+{
+ const int * dbm = daysbymonth;
+ long n, x, y, z;
+
+ if (secs < 0) {
+ return 0;
+ }
// Calculate seconds, minutes and hours
@@ -8088,7 +7026,7 @@
dt->second = n % 60;
n /= 60;
dt->minute = n % 60;
- dt->hour = (typeof(dt->hour))(n / 60);
+ dt->hour = n / 60;
// Calculate day of week
@@ -8123,7 +7061,7 @@
return 0;
}
- dt->year = (typeof(dt->year))z;
+ dt->year = z;
// Adjust remaining days value to start at 1
@@ -8131,25 +7069,25 @@
// Calculate month
- for (x = 1; (n > dbm[x]) && (x < 12); x++) {
+ for (x = 1; n > dbm[x]; x++) {
continue;
}
- dt->month = (typeof(dt->month))x;
+ dt->month = x;
// Calculate day of month
- dt->day = (typeof(dt->day))(n - dbm[x - 1]);
+ dt->day = n - dbm[x - 1];
return 1;
}
-static clock_sec_t
+static long
IOPMConvertCalendarToSeconds(const IOPMCalendarStruct * dt)
{
- const unsigned int * dbm = daysbymonth;
+ const int * dbm = daysbymonth;
long y, secs, days;
- if (dt->year < 1970 || dt->month > 12) {
+ if (dt->year < 1970) {
return 0;
}
@@ -8180,10 +7118,12 @@
return secs;
}
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+
unsigned long
IOPMrootDomain::getRUN_STATE(void)
{
- return (_aotNow && !(kIOPMWakeEventAOTExitFlags & _aotPendingFlags)) ? AOT_STATE : ON_STATE;
+ return _aotNow ? AOT_STATE : ON_STATE;
}
bool
@@ -8192,50 +7132,12 @@
return _aotNow;
}
-bool
-IOPMrootDomain::isLPWMode()
-{
- return gLPWFlags && currentOrPendingPowerState(AOT_STATE);
-}
-
-bool
-IOPMIsAOTMode(void)
-{
- return gIOPMRootDomain && gIOPMRootDomain->isAOTMode();
-}
-bool
-IOPMIsLPWMode(void)
-{
- return gIOPMRootDomain && gIOPMRootDomain->isLPWMode();
-}
-
-void
-IOPMNetworkStackFullWake(uint64_t flags, const char * reason)
-{
- assert(kIOPMNetworkStackFullWakeFlag == flags);
- assert(gIOPMRootDomain);
- gIOPMRootDomain->claimSystemWakeEvent(gIOPMRootDomain, kIOPMWakeEventAOTExit, reason, NULL);
-}
-
IOReturn
IOPMrootDomain::setWakeTime(uint64_t wakeContinuousTime)
-{
- if (kIOPMAOTModeCycle & _aotMode) {
- return kIOReturnSuccess;
- }
- return _setWakeTime(wakeContinuousTime);
-}
-
-IOReturn
-IOPMrootDomain::_setWakeTime(uint64_t wakeContinuousTime)
{
clock_sec_t nowsecs, wakesecs;
clock_usec_t nowmicrosecs, wakemicrosecs;
uint64_t nowAbs, wakeAbs;
-
- if (!_aotMode) {
- return kIOReturnNotReady;
- }
clock_gettimeofday_and_absolute_time(&nowsecs, &nowmicrosecs, &nowAbs);
wakeAbs = continuoustime_to_absolutetime(wakeContinuousTime);
@@ -8270,34 +7172,35 @@
// assumes WAKEEVENT_LOCK
bool
-IOPMrootDomain::aotShouldExit(bool software)
-{
- bool exitNow = false;
+IOPMrootDomain::aotShouldExit(bool checkTimeSet, bool software)
+{
+ bool exitNow;
const char * reason = "";
- if (!_aotNow) {
- return false;
- }
-
if (software) {
- exitNow = true;
+ _aotExit = true;
_aotMetrics->softwareRequestCount++;
reason = "software request";
} else if (kIOPMWakeEventAOTExitFlags & _aotPendingFlags) {
- exitNow = true;
+ _aotExit = true;
reason = gWakeReasonString;
- } else if ((kIOPMAOTModeRespectTimers & _aotMode) && _calendarWakeAlarmUTC) {
+ } else if (checkTimeSet && (kPMCalendarTypeInvalid == _aotWakeTimeCalendar.selector)) {
+ _aotExit = true;
+ _aotMetrics->noTimeSetCount++;
+ reason = "flipbook expired";
+ } else if ((kIOPMAOTModeRespectTimers & _aotMode) && _scheduledAlarmUTC) {
clock_sec_t sec;
clock_usec_t usec;
clock_get_calendar_microtime(&sec, &usec);
- if (_calendarWakeAlarmUTC <= sec) {
- exitNow = true;
+ if (_scheduledAlarmUTC <= sec) {
+ _aotExit = true;
_aotMetrics->rtcAlarmsCount++;
reason = "user alarm";
}
}
+ exitNow = (_aotNow && _aotExit);
if (exitNow) {
- _aotPendingFlags |= kIOPMWakeEventAOTExit;
+ _aotNow = false;
IOLog(LOG_PREFIX "AOT exit for %s, sc %d po %d, cp %d, rj %d, ex %d, nt %d, rt %d\n",
reason,
_aotMetrics->sleepCount,
@@ -8314,39 +7217,29 @@
void
IOPMrootDomain::aotExit(bool cps)
{
- uint32_t savedMessageMask;
-
- ASSERT_GATED();
- _aotNow = false;
- _aotRunMode = 0;
+ _aotTasksSuspended = false;
_aotReadyToFullWake = false;
if (_aotTimerScheduled) {
_aotTimerES->cancelTimeout();
_aotTimerScheduled = false;
}
- updateTasksSuspend(kTasksSuspendNoChange, kTasksSuspendUnsuspended);
+ updateTasksSuspend();
_aotMetrics->totalTime += mach_absolute_time() - _aotLastWakeTime;
_aotLastWakeTime = 0;
if (_aotMetrics->sleepCount && (_aotMetrics->sleepCount <= kIOPMAOTMetricsKernelWakeCountMax)) {
- WAKEEVENT_LOCK();
strlcpy(&_aotMetrics->kernelWakeReason[_aotMetrics->sleepCount - 1][0],
gWakeReasonString,
sizeof(_aotMetrics->kernelWakeReason[_aotMetrics->sleepCount]));
- WAKEEVENT_UNLOCK();
}
_aotWakeTimeCalendar.selector = kPMCalendarTypeInvalid;
- // Preserve the message mask since a system wake transition
- // may have already started and initialized the mask.
- savedMessageMask = _systemMessageClientMask;
_systemMessageClientMask = kSystemMessageClientLegacyApp;
tellClients(kIOMessageSystemWillPowerOn);
- _systemMessageClientMask = savedMessageMask | kSystemMessageClientLegacyApp;
if (cps) {
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonAOTExit);
+ changePowerStateToPriv(getRUN_STATE());
}
}
@@ -8358,7 +7251,7 @@
IOLog("aotEvaluate(%d) 0x%x\n", (timer != NULL), _aotPendingFlags);
WAKEEVENT_LOCK();
- exitNow = aotShouldExit(false);
+ exitNow = aotShouldExit(false, false);
if (timer != NULL) {
_aotTimerScheduled = false;
}
@@ -8378,6 +7271,22 @@
}
}
+#else /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+
+unsigned long
+IOPMrootDomain::getRUN_STATE(void)
+{
+ return ON_STATE;
+}
+
+IOReturn
+IOPMrootDomain::setWakeTime(uint64_t wakeContinuousTime)
+{
+ return kIOReturnUnsupported;
+}
+
+#endif /* (defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+
//******************************************************************************
// adjustPowerState
//
@@ -8391,11 +7300,12 @@
void
IOPMrootDomain::adjustPowerState( bool sleepASAP )
{
- DEBUG_LOG("adjustPowerState %s, asap %d, idleSleepEnabled %d, _aotNow %d\n",
- getPowerStateString((uint32_t) getPowerState()), sleepASAP, idleSleepEnabled, _aotNow);
+ DEBUG_LOG("adjustPowerState ps %s, asap %d, idleSleepEnabled %d\n",
+ getPowerStateString((uint32_t) getPowerState()), sleepASAP, idleSleepEnabled);
ASSERT_GATED();
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (_aotNow) {
bool exitNow;
@@ -8403,12 +7313,16 @@
return;
}
WAKEEVENT_LOCK();
- exitNow = aotShouldExit(false);
+ exitNow = aotShouldExit(true, false);
if (!exitNow
&& !_aotTimerScheduled
&& (kIOPMWakeEventAOTPossibleExit == (kIOPMWakeEventAOTPossibleFlags & _aotPendingFlags))) {
_aotTimerScheduled = true;
- _aotTimerES->setTimeout(_aotLingerTime, kMillisecondScale);
+ if (_aotLingerTime) {
+ _aotTimerES->setTimeout(_aotLingerTime);
+ } else {
+ _aotTimerES->setTimeout(800, kMillisecondScale);
+ }
}
WAKEEVENT_UNLOCK();
if (exitNow) {
@@ -8416,39 +7330,35 @@
} else {
_aotReadyToFullWake = true;
if (!_aotTimerScheduled) {
- if (kIOPMDriverAssertionLevelOn == getPMAssertionLevel(kIOPMDriverAssertionCPUBit)) {
- // Don't try to force sleep during AOT while IOMobileFramebuffer is holding a power assertion.
- // Doing so will result in the sleep being cancelled anyway,
- // but this check avoids unnecessary thrashing in the power state engine.
- return;
- }
privateSleepSystem(kIOPMSleepReasonSoftware);
}
}
return;
}
+#endif /* (defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
if ((!idleSleepEnabled) || !checkSystemSleepEnabled()) {
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonAdjustPowerState);
+ changePowerStateToPriv(getRUN_STATE());
} else if (sleepASAP) {
- changePowerStateWithTagToPriv(SLEEP_STATE, kCPSReasonAdjustPowerState);
+ changePowerStateToPriv(SLEEP_STATE);
}
}
void
-IOPMrootDomain::handleSetDisplayPowerOn(bool powerOn)
-{
- if (powerOn) {
+IOPMrootDomain::handleDisplayPowerOn()
+{
+ if (!wrangler) {
+ return;
+ }
+ if (displayPowerOnRequested) {
if (!checkSystemCanSustainFullWake()) {
- DLOG("System cannot sustain full wake\n");
return;
}
// Force wrangler to max power state. If system is in dark wake
// this alone won't raise the wrangler's power state.
- if (wrangler) {
- wrangler->changePowerStateForRootDomain(kWranglerPowerStateMax);
- }
+
+ wrangler->changePowerStateForRootDomain(kWranglerPowerStateMax);
// System in dark wake, always requesting full wake should
// not have any bad side-effects, even if the request fails.
@@ -8462,14 +7372,11 @@
// Must first transition to state 1 since wrangler doesn't
// power off the displays at state 0. At state 0 the root
// domain is removed from the wrangler's power client list.
- if (wrangler) {
- wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin + 1);
- wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin);
- }
- }
-}
-
-TUNABLE(bool, test_sleep_in_vm, "test_sleep_in_vm", false);
+
+ wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin + 1);
+ wrangler->changePowerStateForRootDomain(kWranglerPowerStateMin);
+ }
+}
//******************************************************************************
// dispatchPowerEvent
@@ -8499,20 +7406,19 @@
if (systemBooting) {
systemBooting = false;
- if (PE_get_default("sleep-disabled", &gSleepDisabledFlag, sizeof(gSleepDisabledFlag))) {
- DLOG("Setting gSleepDisabledFlag to %u from device tree\n", gSleepDisabledFlag);
- if (test_sleep_in_vm && gSleepDisabledFlag) {
- DLOG("Clearing gSleepDisabledFlag due to test_sleep_in_vm boot-arg\n");
- gSleepDisabledFlag = 0;
+ // read noidle setting from Device Tree
+ IORegistryEntry *defaults = IORegistryEntry::fromPath("IODeviceTree:/defaults");
+ if (defaults != NULL) {
+ OSData *data = OSDynamicCast(OSData, defaults->getProperty("no-idle"));
+ if ((data != NULL) && (data->getLength() == 4)) {
+ gNoIdleFlag = *(uint32_t*)data->getBytesNoCopy();
+ DLOG("Setting gNoIdleFlag to %u from device tree\n", gNoIdleFlag);
}
- }
-
- if (lowBatteryCondition || thermalEmergencyState) {
- if (lowBatteryCondition) {
- privateSleepSystem(kIOPMSleepReasonLowPower);
- } else {
- privateSleepSystem(kIOPMSleepReasonThermalEmergency);
- }
+ defaults->release();
+ }
+ if (lowBatteryCondition) {
+ privateSleepSystem(kIOPMSleepReasonLowPower);
+
// The rest is unnecessary since the system is expected
// to sleep immediately. The following wake will update
// everything.
@@ -8560,9 +7466,14 @@
case kPowerEventRegisterSystemCapabilityClient:
DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
-
- // reset() handles the arg0 == nullptr case for us
- systemCapabilityNotifier.reset((IONotifier *) arg0, OSRetain);
+ if (systemCapabilityNotifier) {
+ systemCapabilityNotifier->release();
+ systemCapabilityNotifier = NULL;
+ }
+ if (arg0) {
+ systemCapabilityNotifier = (IONotifier *) arg0;
+ systemCapabilityNotifier->retain();
+ }
/* intentional fall-through */
[[clang::fallthrough]];
@@ -8572,26 +7483,27 @@
_joinedCapabilityClients = OSSet::withCapacity(8);
}
if (arg0) {
- OSSharedPtr<IONotifier> notify((IONotifier *) arg0, OSNoRetain);
+ IONotifier * notify = (IONotifier *) arg0;
if (_joinedCapabilityClients) {
- _joinedCapabilityClients->setObject(notify.get());
+ _joinedCapabilityClients->setObject(notify);
synchronizePowerTree( kIOPMSyncNoChildNotify );
}
+ notify->release();
}
break;
case kPowerEventPolicyStimulus:
DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
if (arg0) {
- int stimulus = (int)(uintptr_t) arg0;
- evaluatePolicy(stimulus, (uint32_t) arg1);
+ int stimulus = (uintptr_t) arg0;
+ evaluatePolicy( stimulus, (uint32_t) arg1 );
}
break;
case kPowerEventAssertionCreate:
DMSG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
if (pmAssertions) {
- pmAssertions->handleCreateAssertion((OSValueObject<PMAssertStruct> *)arg0);
+ pmAssertions->handleCreateAssertion((OSData *)arg0);
}
break;
@@ -8621,53 +7533,15 @@
case kPowerEventSetDisplayPowerOn:
DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
+ if (!wrangler) {
+ break;
+ }
if (arg1 != 0) {
displayPowerOnRequested = true;
} else {
displayPowerOnRequested = false;
}
- handleSetDisplayPowerOn(displayPowerOnRequested);
- break;
-
- case kPowerEventPublishWakeType:
- DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
-
- // Don't replace wake type property if already set
- if ((arg0 == gIOPMWakeTypeUserKey) ||
- !propertyExists(kIOPMRootDomainWakeTypeKey)) {
- const char * wakeType = NULL;
-
- if (arg0 == gIOPMWakeTypeUserKey) {
- requestUserActive(this, "WakeTypeUser");
- wakeType = kIOPMRootDomainWakeTypeUser;
- } else if (arg0 == gIOPMSettingDebugWakeRelativeKey) {
- if (!(gDarkWakeFlags & kDarkWakeFlagAlarmIsDark)) {
- requestUserActive(this, "WakeTypeAlarm");
- }
- wakeType = kIOPMRootDomainWakeTypeAlarm;
- } else if (arg0 == gIOPMSettingSleepServiceWakeCalendarKey) {
- darkWakeSleepService = true;
- wakeType = kIOPMRootDomainWakeTypeSleepService;
- } else if (arg0 == gIOPMSettingMaintenanceWakeCalendarKey) {
- wakeType = kIOPMRootDomainWakeTypeMaintenance;
- }
-
- if (wakeType) {
- setProperty(kIOPMRootDomainWakeTypeKey, wakeType);
- }
- }
- break;
-
- case kPowerEventAOTEvaluate:
- DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
- if (_aotReadyToFullWake) {
- aotEvaluate(NULL);
- }
- break;
- case kPowerEventRunModeRequest:
- DLOG("power event %u args %p 0x%llx\n", event, OBFUSCATE(arg0), arg1);
- // arg1 == runModeMask
- handleRequestRunMode(arg1);
+ handleDisplayPowerOn();
break;
}
}
@@ -8689,7 +7563,7 @@
uint32_t intValue)
{
IOReturn attempt = kIOReturnSuccess;
- OSSharedPtr<OSNumber> newNumber;
+ OSNumber *newNumber = NULL;
if (!event) {
return kIOReturnBadArgument;
@@ -8700,7 +7574,9 @@
return kIOReturnInternalError;
}
- attempt = systemPowerEventOccurred(event, static_cast<OSObject *>(newNumber.get()));
+ attempt = systemPowerEventOccurred(event, (OSObject *)newNumber);
+
+ newNumber->release();
return attempt;
}
@@ -8729,7 +7605,7 @@
const OSSymbol *event,
OSObject *value)
{
- OSSharedPtr<OSDictionary> thermalsDict;
+ OSDictionary *thermalsDict = NULL;
bool shouldUpdate = true;
if (!event || !value) {
@@ -8744,11 +7620,10 @@
IOLockLock(featuresDictLock);
}
- OSSharedPtr<OSObject> origThermalsProp = copyProperty(kIOPMRootDomainPowerStatusKey);
- OSDictionary * origThermalsDict = OSDynamicCast(OSDictionary, origThermalsProp.get());
-
- if (origThermalsDict) {
- thermalsDict = OSDictionary::withDictionary(origThermalsDict);
+ thermalsDict = (OSDictionary *)getProperty(kIOPMRootDomainPowerStatusKey);
+
+ if (thermalsDict && OSDynamicCast(OSDictionary, thermalsDict)) {
+ thermalsDict = OSDictionary::withDictionary(thermalsDict);
} else {
thermalsDict = OSDictionary::withCapacity(1);
}
@@ -8760,7 +7635,9 @@
thermalsDict->setObject(event, value);
- setProperty(kIOPMRootDomainPowerStatusKey, thermalsDict.get());
+ setProperty(kIOPMRootDomainPowerStatusKey, thermalsDict);
+
+ thermalsDict->release();
exit:
// UNLOCK
@@ -8823,7 +7700,7 @@
* Local (IOPMrootDomain only) eval clamshell command
*/
if (msg & kLocalEvalClamshellCommand) {
- if ((gClamshellFlags & kClamshell_WAR_47715679) && isRTCAlarmWake) {
+ if (isRTCAlarmWake) {
eval_clamshell_alarm = true;
// reset isRTCAlarmWake. This evaluation should happen only once
@@ -8839,8 +7716,7 @@
* Overtemp
*/
if (msg & kIOPMOverTemp) {
- DLOG("Thermal overtemp message received!\n");
- thermalEmergencyState = true;
+ MSG("PowerManagement emergency overtemp signal. Going to sleep!");
privateSleepSystem(kIOPMSleepReasonThermalEmergency);
}
@@ -8849,6 +7725,7 @@
*/
if ((msg & kIOPMDWOverTemp) && (_systemTransitionType != kSystemTransitionSleep)) {
DLOG("DarkWake thermal limits message received!\n");
+
messageClients(kIOPMMessageDarkWakeThermalEmergency);
}
@@ -8863,29 +7740,8 @@
* Power Emergency
*/
if (msg & kIOPMPowerEmergency) {
- DLOG("Received kIOPMPowerEmergency");
-#if HIBERNATION && defined(__arm64__)
- if (!ml_is_secure_hib_supported() || ldmHibernateDisable) {
- // Wait for the next low battery notification if the system state is
- // in transition.
- if ((_systemTransitionType == kSystemTransitionNone) &&
- CAP_CURRENT(kIOPMSystemCapabilityCPU) &&
- !systemBooting && !systemShutdown && !gWillShutdown) {
- // Setting lowBatteryCondition will prevent system sleep
- lowBatteryCondition = true;
-
- // Notify userspace to initiate system shutdown
- DLOG("Initiating userspace shutdown ml_is_secure_hib_supported %d lockdownMode %d", ml_is_secure_hib_supported(), ldmHibernateDisable);
- messageClients(kIOPMMessageRequestSystemShutdown);
- }
- } else {
- lowBatteryCondition = true;
- privateSleepSystem(kIOPMSleepReasonLowPower);
- }
-#else /* HIBERNATION && defined(__arm64__) */
lowBatteryCondition = true;
privateSleepSystem(kIOPMSleepReasonLowPower);
-#endif /* HIBERNATION && defined(__arm64__) */
}
/*
@@ -8924,8 +7780,7 @@
* Send the clamshell interest notification since the lid is closing.
*/
if (msg & kIOPMClamshellClosed) {
- if ((clamshellIgnoreClose || (gClamshellFlags & kClamshell_WAR_38378787)) &&
- clamshellClosed && clamshellExists) {
+ if (clamshellClosed && clamshellExists) {
DLOG("Ignoring redundant Clamshell close event\n");
} else {
DLOG("Clamshell closed\n");
@@ -8934,13 +7789,6 @@
clamshellClosed = true;
clamshellExists = true;
- // Ignore all following clamshell close events until the clamshell
- // is opened or the system sleeps. When a clamshell close triggers
- // a system wake, the lid driver may send us two clamshell close
- // events, one for the clamshell close event itself, and a second
- // close event when the driver polls the lid state on wake.
- clamshellIgnoreClose = true;
-
// Tell PMCPU
informCPUStateChange(kInformLid, 1);
@@ -8958,9 +7806,9 @@
* -> reevaluate lid state
*/
if (msg & kIOPMSetDesktopMode) {
+ DLOG("Desktop mode\n");
desktopMode = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetDesktopMode | kIOPMSetValue);
- DLOG("Desktop mode %d\n", desktopMode);
sendClientClamshellNotification();
@@ -8986,8 +7834,6 @@
sendClientClamshellNotification();
- IOUserServer::powerSourceChanged(acAdaptorConnected);
-
// Re-evaluate the lid state
eval_clamshell = true;
@@ -9013,28 +7859,11 @@
*/
if (msg & kIOPMEnableClamshell) {
DLOG("Clamshell enabled\n");
-
// Re-evaluate the lid state
// System should sleep on external display disappearance
// in lid closed operation.
if (true == clamshellDisabled) {
eval_clamshell = true;
-
-#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
- // Also clear kClamshellSleepDisableInternal when graphics enables
- // the clamshell during a full wake. When graphics is behaving as
- // expected, this will allow clamshell close to be honored earlier
- // rather than waiting for the delayed evaluation.
- if ((clamshellSleepDisableMask & kClamshellSleepDisableInternal) &&
- (CAP_PENDING(kIOPMSystemCapabilityGraphics) ||
- CAP_CURRENT(kIOPMSystemCapabilityGraphics))) {
- setClamShellSleepDisable(false, kClamshellSleepDisableInternal);
-
- // Cancel the TC to avoid an extra kLocalEvalClamshellCommand
- // when timer expires which is harmless but useless.
- thread_call_cancel(fullWakeThreadCall);
- }
-#endif
}
clamshellDisabled = false;
@@ -9053,7 +7882,7 @@
}
/*
- * Evaluate clamshell and SLEEP if appropriate
+ * Evaluate clamshell and SLEEP if appropiate
*/
if (eval_clamshell_alarm && clamshellClosed) {
if (shouldSleepOnRTCAlarmWake()) {
@@ -9070,13 +7899,13 @@
if (msg & kIOPMProModeEngaged) {
int newState = 1;
DLOG("ProModeEngaged\n");
- messageClient(kIOPMMessageProModeStateChange, systemCapabilityNotifier.get(), &newState, sizeof(newState));
+ messageClient(kIOPMMessageProModeStateChange, systemCapabilityNotifier, &newState, sizeof(newState));
}
if (msg & kIOPMProModeDisengaged) {
int newState = 0;
DLOG("ProModeDisengaged\n");
- messageClient(kIOPMMessageProModeStateChange, systemCapabilityNotifier.get(), &newState, sizeof(newState));
+ messageClient(kIOPMMessageProModeStateChange, systemCapabilityNotifier, &newState, sizeof(newState));
}
}
@@ -9098,7 +7927,6 @@
int evaluateDarkWake : 1;
int adjustPowerState : 1;
int userBecameInactive : 1;
- int displaySleepEntry : 1;
} bit;
uint32_t u32;
} flags;
@@ -9110,21 +7938,15 @@
switch (stimulus) {
case kStimulusDisplayWranglerSleep:
DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
- if (!wranglerPowerOff) {
- // wrangler is in sleep state or lower
+ if (!wranglerAsleep) {
+ // first transition to wrangler sleep or lower
flags.bit.displaySleep = true;
- }
- if (!wranglerAsleep) {
- // transition from wrangler wake to wrangler sleep
- flags.bit.displaySleepEntry = true;
- wranglerAsleep = true;
}
break;
case kStimulusDisplayWranglerWake:
DLOG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
displayIdleForDemandSleep = false;
- wranglerPowerOff = false;
wranglerAsleep = false;
break;
@@ -9147,7 +7969,7 @@
}
kdebugTrace(kPMLogUserActiveState, 0, 1, 0);
- setProperty(gIOPMUserIsActiveKey.get(), kOSBooleanTrue);
+ setProperty(gIOPMUserIsActiveKey, kOSBooleanTrue);
messageClients(kIOPMMessageUserIsActiveChanged);
}
flags.bit.idleSleepDisabled = true;
@@ -9162,7 +7984,7 @@
flags.bit.userBecameInactive = true;
kdebugTrace(kPMLogUserActiveState, 0, 0, 0);
- setProperty(gIOPMUserIsActiveKey.get(), kOSBooleanFalse);
+ setProperty(gIOPMUserIsActiveKey, kOSBooleanFalse);
messageClients(kIOPMMessageUserIsActiveChanged);
}
break;
@@ -9170,24 +7992,21 @@
case kStimulusAggressivenessChanged:
{
DMSG("evaluatePolicy( %d, 0x%x )\n", stimulus, arg);
- unsigned long aggressiveValue;
- uint32_t minutesToIdleSleep = 0;
- uint32_t minutesToDisplayDim = 0;
- uint32_t minutesDelta = 0;
+ unsigned long minutesToIdleSleep = 0;
+ unsigned long minutesToDisplayDim = 0;
+ unsigned long minutesDelta = 0;
// Fetch latest display and system sleep slider values.
- aggressiveValue = 0;
- getAggressiveness(kPMMinutesToSleep, &aggressiveValue);
- minutesToIdleSleep = (uint32_t) aggressiveValue;
-
- aggressiveValue = 0;
- getAggressiveness(kPMMinutesToDim, &aggressiveValue);
- minutesToDisplayDim = (uint32_t) aggressiveValue;
+ getAggressiveness(kPMMinutesToSleep, &minutesToIdleSleep);
+ getAggressiveness(kPMMinutesToDim, &minutesToDisplayDim);
DLOG("aggressiveness changed: system %u->%u, display %u\n",
- sleepSlider, minutesToIdleSleep, minutesToDisplayDim);
-
- DLOG("idle time -> %d ms (ena %d)\n",
- idleMilliSeconds, (minutesToIdleSleep != 0));
+ (uint32_t) sleepSlider,
+ (uint32_t) minutesToIdleSleep,
+ (uint32_t) minutesToDisplayDim);
+
+ DLOG("idle time -> %ld secs (ena %d)\n",
+ idleSeconds, (minutesToIdleSleep != 0));
+
// How long to wait before sleeping the system once
// the displays turns off is indicated by 'extraSleepDelay'.
@@ -9206,11 +8025,9 @@
flags.bit.idleSleepDisabled = true;
idleSleepEnabled = false;
}
-#if !defined(XNU_TARGET_OS_OSX)
if (0x7fffffff == minutesToIdleSleep) {
- minutesToIdleSleep = idleMilliSeconds / 1000;
- }
-#endif /* !defined(XNU_TARGET_OS_OSX) */
+ minutesToIdleSleep = idleSeconds;
+ }
if (((minutesDelta != extraSleepDelay) ||
(userActivityTime != userActivityTime_prev)) &&
@@ -9236,7 +8053,7 @@
// Request wrangler idle only when demand sleep is triggered
// from full wake.
if (CAP_CURRENT(kIOPMSystemCapabilityGraphics)) {
- wrangler->setProperties(wranglerIdleSettings.get());
+ wrangler->setProperties(wranglerIdleSettings);
DLOG("Requested wrangler idle\n");
}
}
@@ -9259,14 +8076,14 @@
setProperty(kIOPMRootDomainWakeTypeKey, kIOPMRootDomainWakeTypeHIDActivity);
}
- if (!darkWakeExit) {
+ if (false == wranglerTickled) {
if (latchDisplayWranglerTickle(true)) {
DLOG("latched tickle\n");
break;
}
- darkWakeExit = true;
- DLOG("Requesting full wake due to dark wake activity tickle\n");
+ wranglerTickled = true;
+ DLOG("Requesting full wake after dark wake activity tickle\n");
requestFullWake( kFullWakeReasonLocalUser );
}
break;
@@ -9281,9 +8098,9 @@
DLOG("dark wake entry\n");
systemDarkWake = true;
- // Keep wranglerPowerOff an invariant when wrangler is absent
+ // Keep wranglerAsleep an invariant when wrangler is absent
if (wrangler) {
- wranglerPowerOff = true;
+ wranglerAsleep = true;
}
if (kStimulusDarkWakeEntry == stimulus) {
@@ -9317,8 +8134,6 @@
} /* switch(stimulus) */
if (flags.bit.evaluateDarkWake && (kFullWakeReasonNone == fullWakeReason)) {
- DLOG("DarkWake: sleepASAP %d, clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
- darkWakeToSleepASAP, clamshellClosed, clamshellDisabled, clamshellSleepDisableMask, desktopMode, acAdaptorConnected);
if (darkWakeToSleepASAP ||
(clamshellClosed && !(desktopMode && acAdaptorConnected))) {
uint32_t newSleepReason;
@@ -9329,8 +8144,6 @@
if (lowBatteryCondition) {
newSleepReason = kIOPMSleepReasonLowPower;
- } else if (thermalEmergencyState) {
- newSleepReason = kIOPMSleepReasonThermalEmergency;
} else {
newSleepReason = fullToDarkReason;
}
@@ -9352,7 +8165,7 @@
// Release power clamp, and wait for children idle.
adjustPowerState(true);
} else {
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonDarkWakeCannotSleep);
+ changePowerStateToPriv(getRUN_STATE());
}
}
}
@@ -9362,11 +8175,11 @@
flags.u32 = 0;
}
- if ((flags.bit.displaySleepEntry) &&
+ if ((flags.bit.displaySleep) &&
(kFullWakeReasonDisplayOn == fullWakeReason)) {
- // kIOPMSleepReasonNotificationWakeExit
+ // kIOPMSleepReasonMaintenance?
DLOG("Display sleep while in notification wake\n");
- changePowerStateWithOverrideTo(SLEEP_STATE, kIOPMSleepReasonNotificationWakeExit);
+ changePowerStateWithOverrideTo( SLEEP_STATE, kIOPMSleepReasonMaintenance );
}
if (flags.bit.userBecameInactive || flags.bit.sleepDelayChanged) {
@@ -9396,12 +8209,8 @@
if (flags.bit.idleSleepEnabled) {
DLOG("idle sleep timer enabled\n");
if (!wrangler) {
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- startIdleSleepTimer(getTimeToIdleSleep());
-#else
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonIdleSleepEnabled);
- startIdleSleepTimer( idleMilliSeconds );
-#endif
+ changePowerStateToPriv(getRUN_STATE());
+ startIdleSleepTimer( idleSeconds );
} else {
// Start idle timer if prefs now allow system sleep
// and user is already inactive. Disk spindown is
@@ -9425,20 +8234,12 @@
if (!systemBooting && (0 == idleSleepPreventersCount())) {
if (!wrangler) {
- if (kStimulusNoIdleSleepPreventers != stimulus) {
- changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonEvaluatePolicy);
+ changePowerStateToPriv(getRUN_STATE());
+ if (idleSleepEnabled) {
+ // stay awake for at least idleSeconds
+ startIdleSleepTimer(idleSeconds);
}
- if (idleSleepEnabled) {
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- if (!extraSleepDelay && !idleSleepTimerPending && !gNoIdleFlag) {
- sleepASAP = true;
- }
-#else
- // stay awake for at least idleMilliSeconds
- startIdleSleepTimer(idleMilliSeconds);
-#endif
- }
- } else if (!extraSleepDelay && !idleSleepTimerPending && !systemDarkWake && !gNoIdleFlag) {
+ } else if (!extraSleepDelay && !idleSleepTimerPending && !systemDarkWake) {
sleepASAP = true;
}
}
@@ -9452,6 +8253,7 @@
unsigned int
IOPMrootDomain::idleSleepPreventersCount()
{
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (_aotMode) {
unsigned int count __block;
count = 0;
@@ -9462,6 +8264,7 @@
});
return count;
}
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
return preventIdleSleepList->getCount();
}
@@ -9495,20 +8298,21 @@
if ((kSystemTransitionWake == _systemTransitionType) &&
!(_pendingCapability & kIOPMSystemCapabilityGraphics) &&
- !darkWakePowerClamped) {
+ !graphicsSuppressed) {
// Promote to full wake while waking up to dark wake due to tickle.
// PM will hold off notifying the graphics subsystem about system wake
// as late as possible, so if a HID tickle does arrive, graphics can
- // power up from this same wake transition. Otherwise, the latency to
- // power up graphics on the following transition can be huge on certain
- // systems. However, once any power clamping has taken effect, it is
- // too late to promote the current dark wake transition to a full wake.
+ // power up on this same wake cycle. The latency to power up graphics
+ // on the next cycle can be huge on some systems. However, once any
+ // graphics suppression has taken effect, it is too late. All other
+ // graphics devices must be similarly suppressed. But the delay till
+ // the following cycle should be short.
+
_pendingCapability |= (kIOPMSystemCapabilityGraphics |
kIOPMSystemCapabilityAudio);
- // Tell the PCI parent of audio and graphics drivers to stop
- // delaying the child notifications. Same for root domain.
- pciRoot = pciHostBridgeDriver.get();
+ // Immediately bring up audio and graphics
+ pciRoot = pciHostBridgeDriver;
willEnterFullWake();
promotion = true;
}
@@ -9516,7 +8320,7 @@
// Unsafe to cancel once graphics was powered.
// If system woke from dark wake, the return to sleep can
// be cancelled. "awake -> dark -> sleep" transition
- // can be cancelled also, during the "dark -> sleep" phase
+ // can be canceled also, during the "dark --> sleep" phase
// *prior* to driver power down.
if (!CAP_HIGHEST(kIOPMSystemCapabilityGraphics) ||
_pendingCapability == 0) {
@@ -9524,7 +8328,6 @@
}
synchronizePowerTree(options, pciRoot);
-
if (kFullWakeReasonLocalUser == fullWakeReason) {
// IOGraphics doesn't light the display even though graphics is
// enabled in kIOMessageSystemCapabilityChange message(radar 9502104)
@@ -9568,17 +8371,15 @@
resetTimers = false;
sleepTimerMaintenance = false;
- assert(!CAP_CURRENT(kIOPMSystemCapabilityGraphics));
-
_systemMessageClientMask = kSystemMessageClientPowerd |
kSystemMessageClientLegacyApp;
if ((_highestCapability & kIOPMSystemCapabilityGraphics) == 0) {
- // First time to attain full wake capability since the last wake
+ // Initial graphics full power
_systemMessageClientMask |= kSystemMessageClientKernel;
// Set kIOPMUserTriggeredFullWakeKey before full wake for IOGraphics
- setProperty(gIOPMUserTriggeredFullWakeKey.get(),
+ setProperty(gIOPMUserTriggeredFullWakeKey,
(kFullWakeReasonLocalUser == fullWakeReason) ?
kOSBooleanTrue : kOSBooleanFalse);
}
@@ -9600,28 +8401,11 @@
void
IOPMrootDomain::fullWakeDelayedWork( void )
{
-#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
- if (!gIOPMWorkLoop->inGate()) {
- gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this,
- &IOPMrootDomain::fullWakeDelayedWork), this);
- return;
- }
-
- DLOG("fullWakeDelayedWork cap cur %x pend %x high %x, clamshell disable %x/%x\n",
- _currentCapability, _pendingCapability, _highestCapability,
- clamshellDisabled, clamshellSleepDisableMask);
-
- if (clamshellExists &&
- CAP_CURRENT(kIOPMSystemCapabilityGraphics) &&
- !CAP_CHANGE(kIOPMSystemCapabilityGraphics)) {
- if (clamshellSleepDisableMask & kClamshellSleepDisableInternal) {
- setClamShellSleepDisable(false, kClamshellSleepDisableInternal);
- } else {
- // Not the initial full wake after waking from sleep.
- // Evaluate the clamshell for rdar://problem/9157444.
- receivePowerNotification(kLocalEvalClamshellCommand);
- }
+#if DARK_TO_FULL_EVALUATE_CLAMSHELL
+ // Not gated, don't modify state
+ if ((kSystemTransitionNone == _systemTransitionType) &&
+ CAP_CURRENT(kIOPMSystemCapabilityGraphics)) {
+ receivePowerNotification( kLocalEvalClamshellCommand );
}
#endif
}
@@ -9654,10 +8438,14 @@
}
if (changedBits & kIOPMDriverAssertionCPUBit) {
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (_aotNow) {
IOLog("CPU assertions %d\n", (0 != (kIOPMDriverAssertionCPUBit & newAssertions)));
}
evaluatePolicy(_aotNow ? kStimulusNoIdleSleepPreventers : kStimulusDarkWakeEvaluate);
+#else
+ evaluatePolicy(kStimulusDarkWakeEvaluate);
+#endif
if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
AbsoluteTime now;
clock_usec_t microsecs;
@@ -9705,7 +8493,7 @@
bool stopping = eventIndex & kIOPMStatsEventStopFlag ? true:false;
uint64_t delta;
uint64_t nsec;
- OSSharedPtr<OSData> publishPMStats;
+ OSData *publishPMStats = NULL;
eventIndex &= ~(kIOPMStatsEventStartFlag | kIOPMStatsEventStopFlag);
@@ -9735,8 +8523,9 @@
delta = gPMStats.hibRead.stop - gPMStats.hibRead.start;
IOLog("PMStats: Hibernate read took %qd ms\n", delta / NSEC_PER_MSEC);
- publishPMStats = OSData::withValue(gPMStats);
- setProperty(kIOPMSleepStatisticsKey, publishPMStats.get());
+ publishPMStats = OSData::withBytes(&gPMStats, sizeof(gPMStats));
+ setProperty(kIOPMSleepStatisticsKey, publishPMStats);
+ publishPMStats->release();
bzero(&gPMStats, sizeof(gPMStats));
}
break;
@@ -9755,34 +8544,32 @@
uint32_t delay_ms,
uint64_t id,
OSObject *object,
- IOPMPowerStateIndex powerState,
- bool async)
-{
- OSSharedPtr<OSDictionary> responseDescription;
- OSSharedPtr<OSNumber> delayNum;
- OSSharedPtr<OSNumber> powerCaps;
- OSSharedPtr<OSNumber> pidNum;
- OSSharedPtr<OSNumber> msgNum;
- OSSharedPtr<const OSSymbol> appname;
- OSSharedPtr<const OSSymbol> sleep;
- OSSharedPtr<const OSSymbol> wake;
+ IOPMPowerStateIndex powerState)
+{
+ OSDictionary *responseDescription = NULL;
+ OSNumber *delayNum = NULL;
+ OSNumber *powerCaps = NULL;
+ OSNumber *pidNum = NULL;
+ OSNumber *msgNum = NULL;
+ const OSSymbol *appname;
+ const OSSymbol *sleep = NULL, *wake = NULL;
IOPMServiceInterestNotifier *notify = NULL;
if (object && (notify = OSDynamicCast(IOPMServiceInterestNotifier, object))) {
- if (response->isEqualTo(gIOPMStatsResponseTimedOut.get())) {
+ if (response->isEqualTo(gIOPMStatsResponseTimedOut)) {
notify->ackTimeoutCnt++;
} else {
notify->ackTimeoutCnt = 0;
}
}
- if (response->isEqualTo(gIOPMStatsResponsePrompt.get()) ||
+ if (response->isEqualTo(gIOPMStatsResponsePrompt) ||
(_systemTransitionType == kSystemTransitionNone) || (_systemTransitionType == kSystemTransitionNewCapClient)) {
return;
}
- if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow.get())) {
+ if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow)) {
kdebugTrace(kPMLogDrvPSChangeDelay, id, messageType, delay_ms);
} else if (notify) {
// User space app or kernel capability client
@@ -9797,12 +8584,13 @@
responseDescription = OSDictionary::withCapacity(5);
if (responseDescription) {
if (response) {
- responseDescription->setObject(_statsResponseTypeKey.get(), response);
+ responseDescription->setObject(_statsResponseTypeKey, response);
}
msgNum = OSNumber::withNumber(messageType, 32);
if (msgNum) {
- responseDescription->setObject(_statsMessageTypeKey.get(), msgNum.get());
+ responseDescription->setObject(_statsMessageTypeKey, msgNum);
+ msgNum->release();
}
if (!name && notify && notify->identifier) {
@@ -9812,65 +8600,73 @@
if (name && (strlen(name) > 0)) {
appname = OSSymbol::withCString(name);
if (appname) {
- responseDescription->setObject(_statsNameKey.get(), appname.get());
+ responseDescription->setObject(_statsNameKey, appname);
+ appname->release();
}
}
if (!id && notify) {
id = notify->uuid0;
}
- pidNum = OSNumber::withNumber(id, 64);
- if (pidNum) {
- responseDescription->setObject(_statsPIDKey.get(), pidNum.get());
+ if (id != 0) {
+ pidNum = OSNumber::withNumber(id, 64);
+ if (pidNum) {
+ responseDescription->setObject(_statsPIDKey, pidNum);
+ pidNum->release();
+ }
}
delayNum = OSNumber::withNumber(delay_ms, 32);
if (delayNum) {
- responseDescription->setObject(_statsTimeMSKey.get(), delayNum.get());
- }
-
- if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow.get())) {
+ responseDescription->setObject(_statsTimeMSKey, delayNum);
+ delayNum->release();
+ }
+
+ if (response->isEqualTo(gIOPMStatsDriverPSChangeSlow)) {
powerCaps = OSNumber::withNumber(powerState, 32);
#if !defined(__i386__) && !defined(__x86_64__) && (DEVELOPMENT || DEBUG)
- static const char * driverCallTypes[] = {
- [kDriverCallInformPreChange] = "powerStateWillChangeTo",
- [kDriverCallInformPostChange] = "powerStateDidChangeTo",
- [kDriverCallSetPowerState] = "setPowerState"
- };
-
- if (messageType < (sizeof(driverCallTypes) / sizeof(driverCallTypes[0]))) {
- DLOG("%s[0x%qx]::%s(%u) %stook %d ms\n",
- name, id, driverCallTypes[messageType], (uint32_t) powerState,
- async ? "async " : "", delay_ms);
- }
+ IOLog("%s::powerStateChange type(%d) to(%lu) async took %d ms\n",
+ name, messageType,
+ powerState, delay_ms);
#endif
} else {
powerCaps = OSNumber::withNumber(_pendingCapability, 32);
}
if (powerCaps) {
- responseDescription->setObject(_statsPowerCapsKey.get(), powerCaps.get());
+ responseDescription->setObject(_statsPowerCapsKey, powerCaps);
+ powerCaps->release();
}
sleep = OSSymbol::withCString("Sleep");
wake = OSSymbol::withCString("Wake");
if (_systemTransitionType == kSystemTransitionSleep) {
- responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep.get());
+ responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep);
} else if (_systemTransitionType == kSystemTransitionWake) {
- responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake.get());
+ responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake);
} else if (_systemTransitionType == kSystemTransitionCapability) {
if (CAP_LOSS(kIOPMSystemCapabilityGraphics)) {
- responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep.get());
+ responseDescription->setObject(kIOPMStatsSystemTransitionKey, sleep);
} else if (CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
- responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake.get());
- }
- }
+ responseDescription->setObject(kIOPMStatsSystemTransitionKey, wake);
+ }
+ }
+ if (sleep) {
+ sleep->release();
+ }
+ if (wake) {
+ wake->release();
+ }
+
+
IOLockLock(pmStatsLock);
if (pmStatsAppResponses && pmStatsAppResponses->getCount() < 50) {
- pmStatsAppResponses->setObject(responseDescription.get());
+ pmStatsAppResponses->setObject(responseDescription);
}
IOLockUnlock(pmStatsLock);
+
+ responseDescription->release();
}
return;
@@ -9894,6 +8690,7 @@
void * param1, void * param2,
void * param3, void * param4 )
{
+ uint32_t bootFailureCode = 0xffffffff;
if (pmTracer && functionName &&
functionName->isEqualTo(kIOPMRegisterNVRAMTracePointHandlerKey) &&
!pmTracer->tracePointHandler && !pmTracer->tracePointTarget) {
@@ -9905,18 +8702,16 @@
tracePointPCI = (uint32_t)(uintptr_t) param3;
tracePointPhases = (uint32_t)(uintptr_t) param4;
if ((tracePointPhases & 0xff) == kIOPMTracePointSystemSleep) {
- OSSharedPtr<IORegistryEntry> node = IORegistryEntry::fromPath( "/chosen", gIODTPlane );
+ IORegistryEntry *node = IORegistryEntry::fromPath( "/chosen", gIODTPlane );
if (node) {
- OSSharedPtr<OSObject> bootRomFailureProp;
- bootRomFailureProp = node->copyProperty(kIOEFIBootRomFailureKey);
- OSData *data = OSDynamicCast(OSData, bootRomFailureProp.get());
- uint32_t bootFailureCode;
+ OSData *data = OSDynamicCast( OSData, node->getProperty(kIOEFIBootRomFailureKey));
if (data && data->getLength() == sizeof(bootFailureCode)) {
- // Failure code from EFI/BootRom is a four byte structure
memcpy(&bootFailureCode, data->getBytesNoCopy(), sizeof(bootFailureCode));
- tracePointPCI = OSSwapBigToHostInt32(bootFailureCode);
}
- }
+ node->release();
+ }
+ // Failure code from EFI/BootRom is a four byte structure
+ tracePointPCI = OSSwapBigToHostInt32(bootFailureCode);
}
statusCode = (((uint64_t)tracePointPCI) << 32) | tracePointPhases;
if ((tracePointPhases & 0xff) != kIOPMTracePointSystemUp) {
@@ -9957,8 +8752,9 @@
if (regId == 0) {
regId = getRegistryEntryID();
}
- KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, code, (uintptr_t) regId, param1, param2, param3, 0);
-}
+ IOTimeStampConstant(code, (uintptr_t) regId, param1, param2, param3);
+}
+
void
IOPMrootDomain::tracePoint( uint8_t point )
@@ -9968,199 +8764,66 @@
}
if (kIOPMTracePointWakeCapabilityClients == point) {
- acceptSystemWakeEvents(kAcceptSystemWakeEvents_Disable);
+ acceptSystemWakeEvents(false);
}
kdebugTrace(kPMLogSleepWakeTracePoint, 0, point, 0);
pmTracer->tracePoint(point);
}
-static void
-kext_log_putc(char c)
-{
- if (gKextNameEnd || gKextNamePos >= (sizeof(gKextNameBuf) - 1)) {
- return;
- }
- if (c == '(' || c == '[' || c == ' ') {
- c = 0;
- gKextNameEnd = true;
- }
-
- gKextNameBuf[gKextNamePos++] = c;
-}
-
-static int
-kext_log(const char *fmt, ...)
-{
- va_list listp;
-
- va_start(listp, fmt);
- _doprnt(fmt, &listp, &kext_log_putc, 16);
- va_end(listp);
-
- return 0;
-}
-
-static OSPtr<const OSSymbol>
-copyKextIdentifierWithAddress(vm_address_t address)
-{
- OSSharedPtr<const OSSymbol> identifer;
-
- IOLockLock(gHaltLogLock);
-
- gKextNameEnd = false;
- gKextNamePos = 0;
- gKextNameBuf[0] = 0;
-
- OSKext::printKextsInBacktrace(&address, 1, kext_log, OSKext::kPrintKextsLock | OSKext::kPrintKextsTerse);
- gKextNameBuf[sizeof(gKextNameBuf) - 1] = 0;
- identifer = OSSymbol::withCString((gKextNameBuf[0] != 0) ? gKextNameBuf : kOSKextKernelIdentifier);
-
- IOLockUnlock(gHaltLogLock);
-
- return identifer;
-}
-
-// Caller serialized using PM workloop
-const char *
-IOPMrootDomain::getNotificationClientName(OSObject *object)
-{
- IOPMServiceInterestNotifier *notifier = (typeof(notifier))object;
- const char *clientName = "UNKNOWN";
-
- if (!notifier->clientName) {
- // Check for user client
- if (systemCapabilityNotifier && (((IOPMServiceInterestNotifier *) systemCapabilityNotifier.get())->handler == notifier->handler)) {
- OSNumber *clientID = NULL;
- messageClient(kIOMessageCopyClientID, object, &clientID);
- if (clientID) {
- OSSharedPtr<OSString> string(IOCopyLogNameForPID(clientID->unsigned32BitValue()), OSNoRetain);
- if (string) {
- notifier->clientName = OSSymbol::withString(string.get());
- }
- clientID->release();
- }
- } else if (notifier->identifier) {
- notifier->clientName.reset(notifier->identifier.get(), OSRetain);
- }
- }
-
- if (notifier->clientName) {
- clientName = notifier->clientName->getCStringNoCopy();
- }
-
- return clientName;
-}
-
void
-IOPMrootDomain::traceNotification(OSObject *object, bool start, uint64_t timestamp, uint32_t msgIndex)
+IOPMrootDomain::traceDetail(OSObject *object, bool start)
{
IOPMServiceInterestNotifier *notifier;
if (systemBooting) {
return;
}
+
notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
if (!notifier) {
return;
}
if (start) {
- pmTracer->traceDetail(notifier->uuid0 >> 32);
- kdebugTrace(kPMLogSleepWakeMessage, pmTracer->getTracePhase(),
- (uintptr_t) notifier->msgType, (uintptr_t) notifier->uuid0, (uintptr_t) notifier->uuid1);
-
- // Update notifier state used for response/ack logging
- notifier->msgIndex = msgIndex;
- notifier->msgAbsTime = timestamp;
-
- if (msgIndex != UINT_MAX) {
- DLOG("%s[%u] to %s\n", getIOMessageString(notifier->msgType), msgIndex, getNotificationClientName(notifier));
+ pmTracer->traceDetail( notifier->uuid0 >> 32 );
+ kdebugTrace(kPMLogSleepWakeMessage, pmTracer->getTracePhase(), notifier->msgType, notifier->uuid0, notifier->uuid1);
+ if (notifier->identifier) {
+ DLOG("trace point 0x%02x msg 0x%x to %s\n", pmTracer->getTracePhase(), notifier->msgType,
+ notifier->identifier->getCStringNoCopy());
} else {
- DLOG("%s to %s\n", getIOMessageString(notifier->msgType), getNotificationClientName(notifier));
- }
-
- assert(notifierObject == NULL);
+ DLOG("trace point 0x%02x msg 0x%x\n", pmTracer->getTracePhase(), notifier->msgType);
+ }
notifierThread = current_thread();
- notifierObject.reset(notifier, OSRetain);
+ notifierObject = notifier;
+ notifier->retain();
} else {
- uint64_t nsec;
- uint32_t delayMS;
-
- SUB_ABSOLUTETIME(×tamp, ¬ifier->msgAbsTime);
- absolutetime_to_nanoseconds(timestamp, &nsec);
- delayMS = (uint32_t)(nsec / 1000000ULL);
- if (delayMS > notifier->maxMsgDelayMS) {
- notifier->maxMsgDelayMS = delayMS;
- }
-
- assert(notifierObject == notifier);
- notifierObject.reset();
notifierThread = NULL;
- }
-}
+ notifierObject = NULL;
+ notifier->release();
+ }
+}
+
void
-IOPMrootDomain::traceNotificationAck(OSObject *object, uint32_t delay_ms)
-{
- if (systemBooting) {
- return;
- }
+IOPMrootDomain::traceAckDelay(OSObject *object, uint32_t response, uint32_t delay_ms)
+{
IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
if (!notifier) {
+ DLOG("Unknown notifier\n");
return;
}
- kdebugTrace(kPMLogDrvResponseDelay, notifier->uuid0,
- (uintptr_t) notifier->uuid1, (uintptr_t) 0, (uintptr_t) delay_ms);
-
- DLOG("%s[%u] ack from %s took %d ms\n",
- getIOMessageString(notifier->msgType), notifier->msgIndex, getNotificationClientName(notifier), delay_ms);
- if (delay_ms > notifier->maxAckDelayMS) {
- notifier->maxAckDelayMS = delay_ms;
- }
-}
-
-void
-IOPMrootDomain::traceNotificationResponse(OSObject *object, uint32_t delay_ms, uint32_t ack_time_us)
-{
- if (systemBooting) {
- return;
- }
- IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
- if (!notifier) {
- return;
- }
-
- kdebugTrace(kPMLogDrvResponseDelay, notifier->uuid0,
- (uintptr_t) notifier->uuid1, (uintptr_t)(ack_time_us / 1000), (uintptr_t) delay_ms);
-
- if (ack_time_us == 0) {
- // Client work is done and ack will not be forthcoming
- DLOG("%s[%u] response from %s took %d ms\n",
- getIOMessageString(notifier->msgType), notifier->msgIndex, getNotificationClientName(notifier), delay_ms);
- } else {
- // Client needs more time and it must ack within ack_time_us
- DLOG("%s[%u] response from %s took %d ms (ack in %d us)\n",
- getIOMessageString(notifier->msgType), notifier->msgIndex, getNotificationClientName(notifier), delay_ms, ack_time_us);
- }
-}
-
-void
-IOPMrootDomain::traceFilteredNotification(OSObject *object)
-{
- if ((kIOLogDebugPower & gIOKitDebug) == 0) {
- return;
- }
- if (systemBooting) {
- return;
- }
- IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, object);
- if (!notifier) {
- return;
- }
-
- DLOG("%s to %s dropped\n", getIOMessageString(notifier->msgType), getNotificationClientName(notifier));
+ if (!systemBooting) {
+ kdebugTrace(kPMLogDrvResponseDelay, notifier->uuid0, notifier->uuid1, response, delay_ms);
+ if (notifier->identifier) {
+ DLOG("Response from %s took %d ms(response:%d)\n",
+ notifier->identifier->getCStringNoCopy(), delay_ms, response);
+ } else {
+ DLOG("Response from kext UUID %llx-%llx took %d ms(response:%d)\n",
+ notifier->uuid0, notifier->uuid1, delay_ms, response);
+ }
+ }
}
void
@@ -10173,6 +8836,7 @@
DLOG("trace point 0x%02x msgType 0x%x detail 0x%08x\n", pmTracer->getTracePhase(), msgType, delay);
}
}
+
void
IOPMrootDomain::configureReportGated(uint64_t channel_id, uint64_t action, void *result)
@@ -10196,9 +8860,6 @@
bktCnt = kSleepDelaysBcktCnt;
bktSize = kSleepDelaysBcktSize;
clientCnt = &sleepDelaysClientCnt;
- } else {
- assert(false);
- return;
}
switch (action) {
@@ -10210,11 +8871,12 @@
}
reportSize = HISTREPORT_BUFSIZE(bktCnt);
- *report = IOMallocZeroData(reportSize);
+ *report = IOMalloc(reportSize);
if (*report == NULL) {
break;
}
- HISTREPORT_INIT((uint16_t)bktCnt, bktSize, *report, reportSize,
+ bzero(*report, reportSize);
+ HISTREPORT_INIT(bktCnt, bktSize, *report, reportSize,
getRegistryEntryID(), channel_id, kIOReportCategoryPower);
if (channel_id == kAssertDelayChID) {
@@ -10228,7 +8890,7 @@
break;
}
if (*clientCnt == 1) {
- IOFreeData(*report, HISTREPORT_BUFSIZE(bktCnt));
+ IOFree(*report, HISTREPORT_BUFSIZE(bktCnt));
*report = NULL;
}
(*clientCnt)--;
@@ -10291,9 +8953,6 @@
report = &assertOnWakeReport;
} else if (ch_id == kSleepDelaysChID) {
report = &sleepDelaysReport;
- } else {
- assert(false);
- return kIOReturnBadArgument;
}
if (*report == NULL) {
@@ -10374,15 +9033,16 @@
#define kPMBestGuessPCIDevicesCount 25
#define kPMMaxRTCBitfieldSize 32
-OSPtr<PMTraceWorker>
-PMTraceWorker::tracer(IOPMrootDomain * owner)
-{
- OSSharedPtr<PMTraceWorker> me = OSMakeShared<PMTraceWorker>();
+PMTraceWorker * PMTraceWorker::tracer(IOPMrootDomain * owner)
+{
+ PMTraceWorker *me;
+
+ me = OSTypeAlloc( PMTraceWorker );
if (!me || !me->init()) {
return NULL;
}
- DLOG("PMTraceWorker %p\n", OBFUSCATE(me.get()));
+ DLOG("PMTraceWorker %p\n", OBFUSCATE(me));
// Note that we cannot instantiate the PCI device -> bit mappings here, since
// the IODeviceTree has not yet been created by IOPlatformExpert. We create
@@ -10419,13 +9079,13 @@
IOLockLock(l);
IOLockLock(l);
}
-#endif /* DEVELOPMENT || DEBUG */
+#endif
}
int
PMTraceWorker::recordTopLevelPCIDevice(IOService * pciDevice)
{
- OSSharedPtr<const OSSymbol> deviceName;
+ const OSSymbol * deviceName;
int index = -1;
IOLockLock(pmTraceWorkerLock);
@@ -10443,13 +9103,15 @@
}
if ((deviceName = pciDevice->copyName()) &&
- (pciDeviceBitMappings->getNextIndexOfObject(deviceName.get(), 0) == (unsigned int)-1) &&
- pciDeviceBitMappings->setObject(deviceName.get())) {
+ (pciDeviceBitMappings->getNextIndexOfObject(deviceName, 0) == (unsigned int)-1) &&
+ pciDeviceBitMappings->setObject(deviceName)) {
index = pciDeviceBitMappings->getCount() - 1;
_LOG("PMTrace PCI array: set object %s => %d\n",
deviceName->getCStringNoCopy(), index);
}
-
+ if (deviceName) {
+ deviceName->release();
+ }
if (!addedToRegistry && (index >= 0)) {
addedToRegistry = owner->setProperty("PCITopLevel", this);
}
@@ -10670,22 +9332,24 @@
void
PMHaltWorker::work( PMHaltWorker * me )
{
- OSSharedPtr<IOService> service;
+ IOService * service;
OSSet * inner;
AbsoluteTime startTime, elapsedTime;
UInt32 deltaTime;
bool timeout;
while (true) {
+ service = NULL;
timeout = false;
// Claim an unit of work from the shared pool
IOLockLock( gPMHaltLock );
inner = (OSSet *)gPMHaltArray->getObject(me->depth);
if (inner) {
- service.reset(OSDynamicCast(IOService, inner->getAnyObject()), OSRetain);
+ service = OSDynamicCast(IOService, inner->getAnyObject());
if (service) {
- inner->removeObject(service.get());
+ service->retain();
+ inner->removeObject(service);
}
}
IOLockUnlock( gPMHaltLock );
@@ -10695,18 +9359,18 @@
clock_get_uptime(&startTime);
if (!service->isInactive() &&
- service->setProperty(gPMHaltClientAcknowledgeKey.get(), me)) {
+ service->setProperty(gPMHaltClientAcknowledgeKey, me)) {
IOLockLock(me->lock);
me->startTime = startTime;
- me->service = service.get();
+ me->service = service;
me->timeout = false;
IOLockUnlock(me->lock);
- service->systemWillShutdown( gPMHaltMessageType);
+ service->systemWillShutdown( gPMHaltMessageType );
// Wait for driver acknowledgement
IOLockLock(me->lock);
- while (service->propertyExists(gPMHaltClientAcknowledgeKey.get())) {
+ while (service->getProperty(gPMHaltClientAcknowledgeKey)) {
IOLockSleep(me->lock, me, THREAD_UNINT);
}
me->service = NULL;
@@ -10722,10 +9386,11 @@
service->getName(), service->getRegistryEntryID(),
(uint32_t) deltaTime );
halt_log_enter("PowerOff/Restart handler completed",
- OSMemberFunctionCast(const void *, service.get(), &IOService::systemWillShutdown),
+ OSMemberFunctionCast(const void *, service, &IOService::systemWillShutdown),
elapsedTime);
}
+ service->release();
me->visits++;
}
}
@@ -10770,21 +9435,22 @@
void
IOPMrootDomain::acknowledgeSystemWillShutdown( IOService * from )
{
- PMHaltWorker * worker;
- OSSharedPtr<OSObject> prop;
+ PMHaltWorker * worker;
+ OSObject * prop;
if (!from) {
return;
}
//DLOG("%s acknowledged\n", from->getName());
- prop = from->copyProperty( gPMHaltClientAcknowledgeKey.get());
+ prop = from->copyProperty( gPMHaltClientAcknowledgeKey );
if (prop) {
- worker = (PMHaltWorker *) prop.get();
+ worker = (PMHaltWorker *) prop;
IOLockLock(worker->lock);
- from->removeProperty( gPMHaltClientAcknowledgeKey.get());
+ from->removeProperty( gPMHaltClientAcknowledgeKey );
thread_wakeup((event_t) worker);
IOLockUnlock(worker->lock);
+ worker->release();
} else {
DLOG("%s acknowledged without worker property\n",
from->getName());
@@ -10801,22 +9467,21 @@
static void
notifySystemShutdown( IOService * root, uint32_t messageType )
{
-#define PLACEHOLDER ((OSSet *)gPMHaltArray.get())
- OSSharedPtr<IORegistryIterator> iter;
- IORegistryEntry * entry;
- IOService * node;
- OSSet * inner;
- OSSharedPtr<OSSet> newInner;
- PMHaltWorker * workers[kPMHaltMaxWorkers];
- AbsoluteTime deadline;
- unsigned int totalNodes = 0;
- unsigned int depth;
- unsigned int rootDepth;
- unsigned int numWorkers;
- unsigned int count;
- int waitResult;
- void * baseFunc;
- bool ok;
+#define PLACEHOLDER ((OSSet *)gPMHaltArray)
+ IORegistryIterator * iter;
+ IORegistryEntry * entry;
+ IOService * node;
+ OSSet * inner;
+ PMHaltWorker * workers[kPMHaltMaxWorkers];
+ AbsoluteTime deadline;
+ unsigned int totalNodes = 0;
+ unsigned int depth;
+ unsigned int rootDepth;
+ unsigned int numWorkers;
+ unsigned int count;
+ int waitResult;
+ void * baseFunc;
+ bool ok;
DLOG("%s msgType = 0x%x\n", __FUNCTION__, messageType);
@@ -10900,10 +9565,10 @@
if (depth < count) {
inner = (OSSet *)gPMHaltArray->getObject(depth);
if (inner == PLACEHOLDER) {
- newInner = OSSet::withCapacity(40);
- if (newInner) {
- gPMHaltArray->replaceObject(depth, newInner.get());
- inner = newInner.get();
+ inner = OSSet::withCapacity(40);
+ if (inner) {
+ gPMHaltArray->replaceObject(depth, inner);
+ inner->release();
}
}
@@ -10917,6 +9582,7 @@
DLOG("Skipped PM node %s\n", node->getName());
}
}
+ iter->release();
}
// debug only
@@ -11023,19 +9689,6 @@
ret = pmAssertions->createAssertion(whichAssertionBits, assertionLevel, ownerService, ownerDescription, &newAssertion);
if (kIOReturnSuccess == ret) {
-#if (DEVELOPMENT || DEBUG)
- if (_aotNow || (kIOLogPMRootDomain & gIOKitDebug)) {
- const char *serviceName = (ownerService && ownerService->reserved) ? ownerService->getName() : NULL;
- OSReportWithBacktrace("PMRD: createPMAssertion(0x%qx) %s (%s)", newAssertion,
- serviceName, ownerDescription);
- }
-#endif /* (DEVELOPMENT || DEBUG) */
-
- const bool waitForWakeup = (whichAssertionBits & kIOPMDriverAssertionForceWakeupBit);
- if (waitForWakeup) {
- waitForSystemTransitionToMinPowerState(AOT_STATE);
- }
-
return newAssertion;
} else {
return 0;
@@ -11045,22 +9698,10 @@
IOReturn
IOPMrootDomain::releasePMAssertion(IOPMDriverAssertionID releaseAssertion)
{
-#if (DEVELOPMENT || DEBUG)
- if (_aotNow || (kIOLogPMRootDomain & gIOKitDebug)) {
- PMAssertStruct *details = pmAssertions->detailsForID(releaseAssertion, NULL);
- if (details) {
- const char *serviceName = (details->ownerService && details->ownerService->reserved) ?
- details->ownerService->getName() : NULL;
- const char *ownerString = details->ownerString ? details->ownerString->getCStringNoCopy() : NULL;
- OSReportWithBacktrace("PMRD: releasePMAssertion(0x%qx) %s (%s)", releaseAssertion, serviceName, ownerString);
- } else {
- OSReportWithBacktrace("PMRD: releasePMAssertion(0x%qx)", releaseAssertion);
- }
- }
-#endif /* (DEVELOPMENT || DEBUG) */
if (!pmAssertions) {
return kIOReturnInternalError;
}
+
return pmAssertions->releaseAssertion(releaseAssertion);
}
@@ -11103,119 +9744,6 @@
return pmAssertions->setUserAssertionLevels(inLevels);
}
-IOReturn
-IOPMrootDomain::acquireDriverKitMatchingAssertion()
-{
- return gIOPMWorkLoop->runActionBlock(^{
- if (_driverKitMatchingAssertionCount != 0) {
- _driverKitMatchingAssertionCount++;
- return kIOReturnSuccess;
- } else {
- if (kSystemTransitionSleep == _systemTransitionType && !idleSleepRevertible) {
- // system going to sleep
- return kIOReturnBusy;
- } else {
- // createPMAssertion is asynchronous.
- // we must also set _driverKitMatchingAssertionCount under the PM workloop lock so that we can cancel sleep immediately
- // The assertion is used so that on release, we reevaluate all assertions
- _driverKitMatchingAssertion = createPMAssertion(kIOPMDriverAssertionCPUBit, kIOPMDriverAssertionLevelOn, this, "DK matching");
- if (_driverKitMatchingAssertion != kIOPMUndefinedDriverAssertionID) {
- _driverKitMatchingAssertionCount = 1;
- return kIOReturnSuccess;
- } else {
- return kIOReturnBusy;
- }
- }
- }
- });
-}
-
-void
-IOPMrootDomain::releaseDriverKitMatchingAssertion()
-{
- gIOPMWorkLoop->runActionBlock(^{
- if (_driverKitMatchingAssertionCount != 0) {
- _driverKitMatchingAssertionCount--;
- if (_driverKitMatchingAssertionCount == 0) {
- releasePMAssertion(_driverKitMatchingAssertion);
- _driverKitMatchingAssertion = kIOPMUndefinedDriverAssertionID;
- }
- } else {
- panic("Over-release of driverkit matching assertion");
- }
- return kIOReturnSuccess;
- });
-}
-
-IOReturn
-IOPMrootDomain::acquireDriverKitSyncedAssertion(IOService * from, IOPMDriverAssertionID * assertionID)
-{
- return gIOPMWorkLoop->runActionBlock(^{
- if (kSystemTransitionSleep == _systemTransitionType && !idleSleepRevertible) {
- // system going to sleep
- return kIOReturnBusy;
- }
- // createPMAssertion is asynchronous.
- // we must also set _driverKitSyncedAssertionCount under the PM workloop lock so that we can cancel sleep immediately
- // only kIOPMDriverAssertionCPUBit is used for "synced" assertion
- *assertionID = createPMAssertion(kIOPMDriverAssertionCPUBit, kIOPMDriverAssertionLevelOn, this, from->getName());
- if (*assertionID != kIOPMUndefinedDriverAssertionID) {
- _driverKitSyncedAssertionCount++;
- return kIOReturnSuccess;
- } else {
- return kIOReturnBusy;
- }
- });
-}
-
-void
-IOPMrootDomain::releaseDriverKitSyncedAssertion(IOPMDriverAssertionID assertionID)
-{
- gIOPMWorkLoop->runActionBlock(^{
- if (_driverKitSyncedAssertionCount != 0) {
- _driverKitSyncedAssertionCount--;
- releasePMAssertion(assertionID);
- } else {
- panic("Over-release of driverkit synced assertion");
- }
- return kIOReturnSuccess;
- });
-}
-
-
-IOReturn
-IOPMrootDomain::createPMAssertionSafe(
- IOPMDriverAssertionID *assertionID,
- IOPMDriverAssertionType whichAssertionBits,
- IOPMDriverAssertionLevel assertionLevel,
- IOService *ownerService,
- const char *ownerDescription)
-{
- IOReturn ret;
- IOPMDriverAssertionID __block id;
-
- if (!assertionID) {
- return kIOReturnBadArgument;
- }
-
- // Grab workloop to check current transition
- ret = gIOPMWorkLoop->runActionBlock(^{
- if (_systemTransitionType == kSystemTransitionSleep) {
- return kIOReturnBusy;
- }
- id = createPMAssertion(whichAssertionBits, assertionLevel, ownerService, ownerDescription);
- return id ? kIOReturnSuccess : kIOReturnError;
- });
-
- if (ret == kIOReturnSuccess) {
- *assertionID = id;
- } else if (ret == kIOReturnBusy && (kIOLogPMRootDomain & gIOKitDebug)) {
- DLOG("assertion denied due to ongoing sleep transition (%s)\n", ownerDescription);
- }
-
- return ret;
-}
-
bool
IOPMrootDomain::serializeProperties( OSSerialize * s ) const
{
@@ -11225,10 +9753,10 @@
return IOService::serializeProperties(s);
}
-OSSharedPtr<OSObject>
+OSObject *
IOPMrootDomain::copyProperty( const char * aKey) const
{
- OSSharedPtr<OSObject> obj;
+ OSObject *obj = NULL;
obj = IOService::copyProperty(aKey);
if (obj) {
@@ -11238,18 +9766,18 @@
if (!strncmp(aKey, kIOPMSleepWakeWdogRebootKey,
sizeof(kIOPMSleepWakeWdogRebootKey))) {
if (swd_flags & SWD_BOOT_BY_SW_WDOG) {
- return OSSharedPtr<OSBoolean>(kOSBooleanTrue, OSNoRetain);
+ return kOSBooleanTrue;
} else {
- return OSSharedPtr<OSBoolean>(kOSBooleanFalse, OSNoRetain);
+ return kOSBooleanFalse;
}
}
if (!strncmp(aKey, kIOPMSleepWakeWdogLogsValidKey,
sizeof(kIOPMSleepWakeWdogLogsValidKey))) {
if (swd_flags & SWD_VALID_LOGS) {
- return OSSharedPtr<OSBoolean>(kOSBooleanTrue, OSNoRetain);
+ return kOSBooleanTrue;
} else {
- return OSSharedPtr<OSBoolean>(kOSBooleanFalse, OSNoRetain);
+ return kOSBooleanFalse;
}
}
@@ -11260,67 +9788,68 @@
*/
if (!strcmp(aKey, "DesktopMode")) {
if (desktopMode) {
- return OSSharedPtr<OSBoolean>(kOSBooleanTrue, OSNoRetain);
+ return kOSBooleanTrue;
} else {
- return OSSharedPtr<OSBoolean>(kOSBooleanFalse, OSNoRetain);
+ return kOSBooleanFalse;
}
}
if (!strcmp(aKey, "DisplayIdleForDemandSleep")) {
if (displayIdleForDemandSleep) {
- return OSSharedPtr<OSBoolean>(kOSBooleanTrue, OSNoRetain);
+ return kOSBooleanTrue;
} else {
- return OSSharedPtr<OSBoolean>(kOSBooleanFalse, OSNoRetain);
+ return kOSBooleanFalse;
}
}
if (!strcmp(aKey, kIOPMDriverWakeEventsKey)) {
- OSSharedPtr<OSArray> array;
+ OSArray * array = NULL;
WAKEEVENT_LOCK();
if (_systemWakeEventsArray && _systemWakeEventsArray->getCount()) {
- OSSharedPtr<OSCollection> collection = _systemWakeEventsArray->copyCollection();
- if (collection) {
- array = OSDynamicPtrCast<OSArray>(collection);
+ OSCollection *collection = _systemWakeEventsArray->copyCollection();
+ if (collection && !(array = OSDynamicCast(OSArray, collection))) {
+ collection->release();
}
}
WAKEEVENT_UNLOCK();
- return os::move(array);
+ return array;
}
if (!strcmp(aKey, kIOPMSleepStatisticsAppsKey)) {
- OSSharedPtr<OSArray> array;
+ OSArray * array = NULL;
IOLockLock(pmStatsLock);
if (pmStatsAppResponses && pmStatsAppResponses->getCount()) {
- OSSharedPtr<OSCollection> collection = pmStatsAppResponses->copyCollection();
- if (collection) {
- array = OSDynamicPtrCast<OSArray>(collection);
- }
+ OSCollection *collection = pmStatsAppResponses->copyCollection();
+ if (collection && !(array = OSDynamicCast(OSArray, collection))) {
+ collection->release();
+ }
+ pmStatsAppResponses->flushCollection();
}
IOLockUnlock(pmStatsLock);
- return os::move(array);
+ return array;
}
if (!strcmp(aKey, kIOPMIdleSleepPreventersKey)) {
OSArray *idleSleepList = NULL;
gRootDomain->copySleepPreventersList(&idleSleepList, NULL);
- return OSSharedPtr<OSArray>(idleSleepList, OSNoRetain);
+ return idleSleepList;
}
if (!strcmp(aKey, kIOPMSystemSleepPreventersKey)) {
OSArray *systemSleepList = NULL;
gRootDomain->copySleepPreventersList(NULL, &systemSleepList);
- return OSSharedPtr<OSArray>(systemSleepList, OSNoRetain);
+ return systemSleepList;
}
if (!strcmp(aKey, kIOPMIdleSleepPreventersWithIDKey)) {
OSArray *idleSleepList = NULL;
gRootDomain->copySleepPreventersListWithID(&idleSleepList, NULL);
- return OSSharedPtr<OSArray>(idleSleepList, OSNoRetain);
+ return idleSleepList;
}
if (!strcmp(aKey, kIOPMSystemSleepPreventersWithIDKey)) {
OSArray *systemSleepList = NULL;
gRootDomain->copySleepPreventersListWithID(NULL, &systemSleepList);
- return OSSharedPtr<OSArray>(systemSleepList, OSNoRetain);
+ return systemSleepList;
}
return NULL;
}
@@ -11336,22 +9865,6 @@
WAKEEVENT_UNLOCK();
}
-void
-IOPMrootDomain::copyShutdownReasonString( char * outBuf, size_t bufSize )
-{
- WAKEEVENT_LOCK();
- strlcpy(outBuf, gShutdownReasonString, bufSize);
- WAKEEVENT_UNLOCK();
-}
-
-void
-IOPMrootDomain::copyShutdownTime( uint64_t * time )
-{
- WAKEEVENT_LOCK();
- *time = gShutdownTime;
- WAKEEVENT_UNLOCK();
-}
-
//******************************************************************************
// acceptSystemWakeEvents
//
@@ -11359,36 +9872,28 @@
//******************************************************************************
void
-IOPMrootDomain::acceptSystemWakeEvents( uint32_t control )
+IOPMrootDomain::acceptSystemWakeEvents( bool accept )
{
bool logWakeReason = false;
WAKEEVENT_LOCK();
- switch (control) {
- case kAcceptSystemWakeEvents_Enable:
- assert(_acceptSystemWakeEvents == false);
+ if (accept) {
if (!_systemWakeEventsArray) {
_systemWakeEventsArray = OSArray::withCapacity(4);
}
_acceptSystemWakeEvents = (_systemWakeEventsArray != NULL);
- if (!(_aotNow && (kIOPMWakeEventAOTExitFlags & _aotPendingFlags))) {
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
+ if (!(kIOPMWakeEventAOTExitFlags & _aotPendingFlags))
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
+ {
gWakeReasonString[0] = '\0';
if (_systemWakeEventsArray) {
_systemWakeEventsArray->flushCollection();
}
}
- _aotWakeEventRunMode = 0;
-
- // Remove stale WakeType property before system sleep
- removeProperty(kIOPMRootDomainWakeTypeKey);
- removeProperty(kIOPMRootDomainWakeReasonKey);
- break;
-
- case kAcceptSystemWakeEvents_Disable:
+ } else {
_acceptSystemWakeEvents = false;
-#if defined(XNU_TARGET_OS_OSX)
- logWakeReason = (gWakeReasonString[0] != '\0');
-#else /* !defined(XNU_TARGET_OS_OSX) */
+#if CONFIG_EMBEDDED
logWakeReason = gWakeReasonSysctlRegistered;
#if DEVELOPMENT
static int panic_allowed = -1;
@@ -11407,28 +9912,16 @@
}
}
if (i >= strlen(gWakeReasonString)) {
- panic("Wake reason is empty");
- }
- }
-#endif /* DEVELOPMENT */
-#endif /* !defined(XNU_TARGET_OS_OSX) */
-
- // publish kIOPMRootDomainWakeReasonKey if not already set
- if (!propertyExists(kIOPMRootDomainWakeReasonKey)) {
- setProperty(kIOPMRootDomainWakeReasonKey, gWakeReasonString);
- }
- break;
-
- case kAcceptSystemWakeEvents_Reenable:
- assert(_acceptSystemWakeEvents == false);
- _acceptSystemWakeEvents = (_systemWakeEventsArray != NULL);
- removeProperty(kIOPMRootDomainWakeReasonKey);
- break;
+ panic("Wake reason is empty\n");
+ }
+ }
+#endif
+#endif
}
WAKEEVENT_UNLOCK();
if (logWakeReason) {
- MSG("system wake events: %s\n", gWakeReasonString);
+ MSG("system wake events:%s\n", gWakeReasonString);
}
}
@@ -11445,74 +9938,70 @@
const char * reason,
OSObject * details )
{
- OSSharedPtr<const OSSymbol> deviceName;
- OSSharedPtr<OSNumber> deviceRegId;
- OSSharedPtr<OSNumber> claimTime;
- OSSharedPtr<OSData> flagsData;
- OSSharedPtr<OSString> reasonString;
- OSSharedPtr<OSDictionary> dict;
- uint64_t timestamp;
- bool addWakeReason;
+ const OSSymbol * deviceName = NULL;
+ OSNumber * deviceRegId = NULL;
+ OSNumber * claimTime = NULL;
+ OSData * flagsData = NULL;
+ OSString * reasonString = NULL;
+ OSDictionary * d = NULL;
+ uint64_t timestamp;
+ bool ok = false;
+ bool addWakeReason;
+
+ pmEventTimeStamp(×tamp);
if (!device || !reason) {
return;
}
- pmEventTimeStamp(×tamp);
-
- uint64_t args[3] = {};
- strlcpy((char *)args, reason, sizeof(args));
- kdebugTrace(kPMLogClaimSystemWake, args[0], args[1], args[2], device->getRegistryEntryID());
-
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
IOOptionBits aotFlags = 0;
bool needAOTEvaluate = FALSE;
- if ((kIOPMAOTModeAddEventFlags & _aotMode) && (!flags || (flags == kIOPMWakeEventSource))) {
- flags |= kIOPMWakeEventAOTExit;
-
- // Only allow lingering in AOT_STATE for the two wake reasons used for the wrist raise gesture.
- if (!strcmp("AOP.OutboxNotEmpty", reason) || !strcmp("spu_gesture", reason)) {
- flags &= ~kIOPMWakeEventAOTExit;
- }
- }
-
-#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
- // Publishing the WakeType is serialized by the PM work loop
- if (!strcmp("rtc", reason) && (_nextScheduledAlarmType != NULL)) {
- pmPowerStateQueue->submitPowerEvent(kPowerEventPublishWakeType,
- (void *) _nextScheduledAlarmType.get());
- }
-
- // Workaround for the missing wake HID event
- if (gDarkWakeFlags & kDarkWakeFlagUserWakeWorkaround) {
- if (!strcmp("trackpadkeyboard", reason)) {
- pmPowerStateQueue->submitPowerEvent(kPowerEventPublishWakeType,
- (void *) gIOPMWakeTypeUserKey.get());
- }
- }
-#endif
+ if (kIOPMAOTModeAddEventFlags & _aotMode) {
+ if (!strcmp("hold", reason)
+ || !strcmp("help", reason)
+ || !strcmp("menu", reason)
+ || !strcmp("stockholm", reason)
+ || !strcmp("ringer", reason)
+ || !strcmp("ringerab", reason)
+ || !strcmp("smc0", reason)
+ || !strcmp("AOP.RTPWakeupAP", reason)
+ || !strcmp("BT.OutboxNotEmpty", reason)
+ || !strcmp("WL.OutboxNotEmpty", reason)) {
+ flags |= kIOPMWakeEventAOTExit;
+ }
+ }
+
+#if DEVELOPMENT || DEBUG
+ if (_aotLingerTime && !strcmp("rtc", reason)) {
+ flags |= kIOPMWakeEventAOTPossibleExit;
+ }
+#endif /* DEVELOPMENT || DEBUG */
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
deviceName = device->copyName(gIOServicePlane);
deviceRegId = OSNumber::withNumber(device->getRegistryEntryID(), 64);
claimTime = OSNumber::withNumber(timestamp, 64);
- flagsData = OSData::withValue(flags);
+ flagsData = OSData::withBytes(&flags, sizeof(flags));
reasonString = OSString::withCString(reason);
- dict = OSDictionary::withCapacity(5 + (details ? 1 : 0));
- if (!dict || !deviceName || !deviceRegId || !claimTime || !flagsData || !reasonString) {
+ d = OSDictionary::withCapacity(5 + (details ? 1 : 0));
+ if (!deviceName || !deviceRegId || !claimTime || !flagsData || !reasonString) {
goto done;
}
- dict->setObject(gIONameKey, deviceName.get());
- dict->setObject(gIORegistryEntryIDKey, deviceRegId.get());
- dict->setObject(kIOPMWakeEventTimeKey, claimTime.get());
- dict->setObject(kIOPMWakeEventFlagsKey, flagsData.get());
- dict->setObject(kIOPMWakeEventReasonKey, reasonString.get());
+ d->setObject(gIONameKey, deviceName);
+ d->setObject(gIORegistryEntryIDKey, deviceRegId);
+ d->setObject(kIOPMWakeEventTimeKey, claimTime);
+ d->setObject(kIOPMWakeEventFlagsKey, flagsData);
+ d->setObject(kIOPMWakeEventReasonKey, reasonString);
if (details) {
- dict->setObject(kIOPMWakeEventDetailsKey, details);
+ d->setObject(kIOPMWakeEventDetailsKey, details);
}
WAKEEVENT_LOCK();
addWakeReason = _acceptSystemWakeEvents;
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (_aotMode) {
IOLog("claimSystemWakeEvent(%s, %s, 0x%x) 0x%x %d\n", reason, deviceName->getCStringNoCopy(), (int)flags, _aotPendingFlags, _aotReadyToFullWake);
}
@@ -11537,179 +10026,50 @@
addWakeReason = _aotNow && _systemWakeEventsArray && ((kIOPMWakeEventAOTExitFlags & aotFlags));
needAOTEvaluate = _aotReadyToFullWake;
}
- DMSG("claimSystemWakeEvent(%s, 0x%x, %s, 0x%llx) aot %d phase 0x%x add %d\n",
- reason, (int)flags, deviceName->getCStringNoCopy(), device->getRegistryEntryID(),
- _aotNow, pmTracer->getTracePhase(), addWakeReason);
-
-#if DEVELOPMENT || DEBUG
- if (addWakeReason) {
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Report System Wake Event",
- "Reason: %s Flags: 0x%x Device: %s, DeviceRegEntry: 0x%llx\n",
- reason,
- (int)flags,
- deviceName->getCStringNoCopy(),
- device->getRegistryEntryID()
- );
- }
-#endif /* DEVELOPMENT || DEBUG */
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
if (!gWakeReasonSysctlRegistered) {
// Lazy registration until the platform driver stops registering
// the same name.
gWakeReasonSysctlRegistered = true;
+#if CONFIG_EMBEDDED
+ sysctl_register_oid(&sysctl__kern_wakereason);
+#endif
}
if (addWakeReason) {
- _systemWakeEventsArray->setObject(dict.get());
+ ok = _systemWakeEventsArray->setObject(d);
if (gWakeReasonString[0] != '\0') {
strlcat(gWakeReasonString, " ", sizeof(gWakeReasonString));
}
strlcat(gWakeReasonString, reason, sizeof(gWakeReasonString));
}
- if (_aotNow && _acceptSystemWakeEvents) {
- uint64_t runModeBits = (kIOPMAOTModeRunModeMask & flags) >> kIOPMAOTModeRunModeShift;
- if (runModeBits) {
- if (_aotWakeEventRunModeImpliesStorage & runModeBits) {
- runModeBits |= kIOPMDriverClassStorage;
- }
- IOLog("AOT wake event %s -> mode 0x%llx\n", reasonString->getCStringNoCopy(), runModeBits);
- _aotWakeEventRunMode |= runModeBits;
- }
- }
-
WAKEEVENT_UNLOCK();
+#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146))
if (needAOTEvaluate) {
- // Call aotEvaluate() on PM work loop since it may call
- // aotExit() which accesses PM state.
- pmPowerStateQueue->submitPowerEvent(kPowerEventAOTEvaluate);
- }
+ aotEvaluate(NULL);
+ }
+#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */
done:
- return;
-}
-
-//******************************************************************************
-// claimSystemBootEvent
-//
-// For a driver to claim a device is the source/conduit of a system boot event.
-//******************************************************************************
-
-void
-IOPMrootDomain::claimSystemBootEvent(
- IOService * device,
- IOOptionBits flags,
- const char * reason,
- __unused OSObject * details )
-{
- if (!device || !reason) {
- return;
- }
-
- DEBUG_LOG("claimSystemBootEvent(%s, %s, 0x%x)\n", reason, device->getName(), (uint32_t) flags);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Report System Boot Device",
- "Reason: %s Flags: 0x%x Device: %s",
- reason,
- (int)flags,
- device->getName()
- );
-#endif /* DEVELOPMENT || DEBUG */
- WAKEEVENT_LOCK();
- if (!gBootReasonSysctlRegistered) {
- // Lazy sysctl registration after setting gBootReasonString
- strlcat(gBootReasonString, reason, sizeof(gBootReasonString));
- os_atomic_store(&gBootReasonSysctlRegistered, true, release);
- }
- WAKEEVENT_UNLOCK();
-}
-
-//******************************************************************************
-// claimSystemShutdownEvent
-//
-// For drivers to claim a system shutdown event on the ensuing boot.
-//******************************************************************************
-
-void
-IOPMrootDomain::claimSystemShutdownEvent(
- IOService * device,
- IOOptionBits flags,
- const char * reason,
- OSObject * details )
-{
- if (!device || !reason) {
- return;
- }
-
- DEBUG_LOG("claimSystemShutdownEvent(%s, %s, 0x%x)\n", reason, device->getName(), (uint32_t) flags);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Report System Shutdown Cause From Previous Boot",
- "Reason: %s Flags: 0x%x Device: %s",
- reason,
- (int)flags,
- device->getName()
- );
-#endif /* DEVELOPMENT || DEBUG */
- WAKEEVENT_LOCK();
- if (gShutdownReasonString[0] != '\0') {
- strlcat(gShutdownReasonString, " ", sizeof(gShutdownReasonString));
- }
- strlcat(gShutdownReasonString, reason, sizeof(gShutdownReasonString));
-
- if (details) {
- OSDictionary *dict = OSDynamicCast(OSDictionary, details);
- if (dict) {
- OSSharedPtr<OSString> sharedKey = OSString::withCString(kIOPMRootDomainShutdownTime);
- if (sharedKey) {
- OSNumber *num = OSDynamicCast(OSNumber, dict->getObject(sharedKey.get()));
- if (num) {
- gShutdownTime = (uint64_t)(num->unsigned64BitValue());
- }
- }
- }
- }
-
- gShutdownReasonSysctlRegistered = true;
- WAKEEVENT_UNLOCK();
-}
-
-//******************************************************************************
-// requestRunMode
-//
-// For clients to request a LPW run mode. Only full wake is supported currently.
-//******************************************************************************
-
-IOReturn
-IOPMrootDomain::requestRunMode(uint64_t runModeMask)
-{
- // We only support requesting full wake at the moment
- if (runModeMask == kIOPMRunModeFullWake) {
- pmPowerStateQueue->submitPowerEvent(kPowerEventRunModeRequest, NULL, runModeMask);
- return kIOReturnSuccess;
- }
- return kIOReturnUnsupported;
-}
-
-IOReturn
-IOPMrootDomain::handleRequestRunMode(uint64_t runModeMask)
-{
- // TODO: Replace with run mode logic when implemented
- IOReturn ret = kIOReturnUnsupported;
-
- // We only support requesting full wake at the moment
- if (runModeMask == kIOPMRunModeFullWake) {
- // A simple CPS should suffice for now
- changePowerStateWithTagToPriv(ON_STATE, kCPSReasonEvaluatePolicy);
- ret = kIOReturnSuccess;
- }
-
- DLOG("%s: mask %llx ret %x\n", __func__, runModeMask, ret);
- return ret;
+ if (deviceName) {
+ deviceName->release();
+ }
+ if (deviceRegId) {
+ deviceRegId->release();
+ }
+ if (claimTime) {
+ claimTime->release();
+ }
+ if (flagsData) {
+ flagsData->release();
+ }
+ if (reasonString) {
+ reasonString->release();
+ }
+ if (d) {
+ d->release();
+ }
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -11787,7 +10147,7 @@
pmsh->pmso = pmso;
pmso->pmsh = pmsh;
- pmso->publishedFeatureID = OSDataAllocation<uint32_t>(settingCount, OSAllocateMemory);
+ pmso->publishedFeatureID = (uint32_t *)IOMalloc(sizeof(uint32_t) * settingCount);
if (pmso->publishedFeatureID) {
for (unsigned int i = 0; i < settingCount; i++) {
// Since there is now at least one listener to this setting, publish
@@ -11814,22 +10174,22 @@
PMSettingObject::free( void )
{
if (publishedFeatureID) {
- for (const auto& featureID : publishedFeatureID) {
- if (featureID) {
- parent->removePublishedFeature( featureID );
- }
- }
-
- publishedFeatureID = {};
+ for (uint32_t i = 0; i < settingCount; i++) {
+ if (publishedFeatureID[i]) {
+ parent->removePublishedFeature( publishedFeatureID[i] );
+ }
+ }
+
+ IOFree(publishedFeatureID, sizeof(uint32_t) * settingCount);
}
super::free();
}
-IOReturn
+void
PMSettingObject::dispatchPMSetting( const OSSymbol * type, OSObject * object )
{
- return (*func)(target, type, object, refcon);
+ (*func)(target, type, object, refcon);
}
void
@@ -11851,30 +10211,27 @@
PMAssertionsTracker *
PMAssertionsTracker::pmAssertionsTracker( IOPMrootDomain *rootDomain )
{
- PMAssertionsTracker *me;
-
- me = new PMAssertionsTracker;
- if (!me || !me->init()) {
- if (me) {
- me->release();
- }
- return NULL;
- }
-
- me->owner = rootDomain;
- me->issuingUniqueID = kAssertUniqueIDStart;
- me->assertionsArray = OSArray::withCapacity(5);
- me->assertionsKernel = 0;
- me->assertionsUser = 0;
- me->assertionsCombined = 0;
- me->assertionsArrayLock = IOLockAlloc();
- me->tabulateProducerCount = me->tabulateConsumerCount = 0;
- bzero(&me->assertionsLog, sizeof(me->assertionsLog));
-
- assert(me->assertionsArray);
- assert(me->assertionsArrayLock);
-
- return me;
+ PMAssertionsTracker *myself;
+
+ myself = new PMAssertionsTracker;
+
+ if (myself) {
+ myself->init();
+ myself->owner = rootDomain;
+ myself->issuingUniqueID = kAssertUniqueIDStart;
+ myself->assertionsArray = OSArray::withCapacity(5);
+ myself->assertionsKernel = 0;
+ myself->assertionsUser = 0;
+ myself->assertionsCombined = 0;
+ myself->assertionsArrayLock = IOLockAlloc();
+ myself->tabulateProducerCount = myself->tabulateConsumerCount = 0;
+
+ if (!myself->assertionsArray || !myself->assertionsArrayLock) {
+ myself = NULL;
+ }
+ }
+
+ return myself;
}
/* tabulate
@@ -11887,8 +10244,8 @@
{
int i;
int count;
- const PMAssertStruct *_a = nullptr;
- OSValueObject<PMAssertStruct> *_d = nullptr;
+ PMAssertStruct *_a = NULL;
+ OSData *_d = NULL;
IOPMDriverAssertionType oldKernel = assertionsKernel;
IOPMDriverAssertionType oldCombined = assertionsCombined;
@@ -11904,9 +10261,9 @@
if ((count = assertionsArray->getCount())) {
for (i = 0; i < count; i++) {
- _d = OSDynamicCast(OSValueObject<PMAssertStruct>, assertionsArray->getObject(i));
+ _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
if (_d) {
- _a = _d->getBytesNoCopy();
+ _a = (PMAssertStruct *)_d->getBytesNoCopy();
if (_a && (kIOPMDriverAssertionLevelOn == _a->level)) {
assertionsKernel |= _a->assertionBits;
}
@@ -11924,80 +10281,9 @@
}
void
-PMAssertionsTracker::updateCPUBitAccounting( PMAssertStruct *assertStruct )
-{
- AbsoluteTime now, elapsed;
- uint64_t nsec;
-
- if (((assertStruct->assertionBits & kIOPMDriverAssertionCPUBit) == 0) ||
- (assertStruct->assertCPUStartTime == 0)) {
- return;
- }
-
- now = mach_continuous_time();
- assertionsLog.addInterval(assertStruct->id, assertStruct->assertCPUStartTime, now);
-
- elapsed = now - assertStruct->assertCPUStartTime;
- absolutetime_to_nanoseconds(elapsed, &nsec);
- assertStruct->assertCPUDuration += nsec;
- assertStruct->assertCPUStartTime = 0;
-
- if (assertStruct->assertCPUDuration > maxAssertCPUDuration) {
- maxAssertCPUDuration = assertStruct->assertCPUDuration;
- maxAssertCPUEntryId = assertStruct->registryEntryID;
- }
-}
-
-void
-PMAssertionsTracker::reportCPUBitAccounting( void )
-{
- const PMAssertStruct *_a = nullptr;
- OSValueObject<PMAssertStruct> *_d = nullptr;
- int i, count;
- AbsoluteTime now;
- uint64_t nsec;
-
- ASSERT_GATED();
-
- // Account for drivers that are still holding the CPU assertion
- if (assertionsKernel & kIOPMDriverAssertionCPUBit) {
- now = mach_absolute_time();
- if ((count = assertionsArray->getCount())) {
- for (i = 0; i < count; i++) {
- _d = OSDynamicCast(OSValueObject<PMAssertStruct>, assertionsArray->getObject(i));
- if (_d) {
- _a = _d->getBytesNoCopy();
- if ((_a->assertionBits & kIOPMDriverAssertionCPUBit) &&
- (_a->level == kIOPMDriverAssertionLevelOn) &&
- (_a->assertCPUStartTime != 0)) {
- // Don't modify PMAssertStruct, leave that
- // for updateCPUBitAccounting()
- SUB_ABSOLUTETIME(&now, &_a->assertCPUStartTime);
- absolutetime_to_nanoseconds(now, &nsec);
- nsec += _a->assertCPUDuration;
- if (nsec > maxAssertCPUDuration) {
- maxAssertCPUDuration = nsec;
- maxAssertCPUEntryId = _a->registryEntryID;
- }
- }
- }
- }
- }
- }
-
- if (maxAssertCPUDuration) {
- DLOG("cpu assertion held for %llu ms by 0x%llx\n",
- (maxAssertCPUDuration / NSEC_PER_MSEC), maxAssertCPUEntryId);
- }
-
- maxAssertCPUDuration = 0;
- maxAssertCPUEntryId = 0;
-}
-
-void
PMAssertionsTracker::publishProperties( void )
{
- OSSharedPtr<OSArray> assertionsSummary;
+ OSArray *assertionsSummary = NULL;
if (tabulateConsumerCount != tabulateProducerCount) {
IOLockLock(assertionsArrayLock);
@@ -12008,7 +10294,8 @@
*/
assertionsSummary = copyAssertionsArray();
if (assertionsSummary) {
- owner->setProperty(kIOPMAssertionsDriverDetailedKey, assertionsSummary.get());
+ owner->setProperty(kIOPMAssertionsDriverDetailedKey, assertionsSummary);
+ assertionsSummary->release();
} else {
owner->removeProperty(kIOPMAssertionsDriverDetailedKey);
}
@@ -12021,11 +10308,11 @@
}
}
-PMAssertStruct *
+PMAssertionsTracker::PMAssertStruct *
PMAssertionsTracker::detailsForID(IOPMDriverAssertionID _id, int *index)
{
PMAssertStruct *_a = NULL;
- OSValueObject<PMAssertStruct> *_d = nullptr;
+ OSData *_d = NULL;
int found = -1;
int count = 0;
int i = 0;
@@ -12033,9 +10320,9 @@
if (assertionsArray
&& (count = assertionsArray->getCount())) {
for (i = 0; i < count; i++) {
- _d = OSDynamicCast(OSValueObject<PMAssertStruct>, assertionsArray->getObject(i));
+ _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
if (_d) {
- _a = _d->getMutableBytesNoCopy();
+ _a = (PMAssertStruct *)_d->getBytesNoCopy();
if (_a && (_id == _a->id)) {
found = i;
break;
@@ -12058,22 +10345,11 @@
* Perform assertion work on the PM workloop. Do not call directly.
*/
IOReturn
-PMAssertionsTracker::handleCreateAssertion(OSValueObject<PMAssertStruct> *newAssertion)
-{
- PMAssertStruct *assertStruct = nullptr;
-
+PMAssertionsTracker::handleCreateAssertion(OSData *newAssertion)
+{
ASSERT_GATED();
if (newAssertion) {
- assertStruct = newAssertion->getMutableBytesNoCopy();
-
- if ((assertStruct->assertionBits & kIOPMDriverAssertionCPUBit) &&
- (assertStruct->level == kIOPMDriverAssertionLevelOn)) {
- assertStruct->assertCPUStartTime = mach_continuous_time();
- }
-
- assertionsLog.addName(assertStruct->id, assertStruct->ownerString->getCStringNoCopy());
-
IOLockLock(assertionsArrayLock);
assertionsArray->setObject(newAssertion);
IOLockUnlock(assertionsArrayLock);
@@ -12096,29 +10372,23 @@
const char *whoItIs,
IOPMDriverAssertionID *outID)
{
- OSSharedPtr<OSValueObject<PMAssertStruct> > dataStore;
+ OSData *dataStore = NULL;
PMAssertStruct track;
// Warning: trillions and trillions of created assertions may overflow the unique ID.
track.id = OSIncrementAtomic64((SInt64*) &issuingUniqueID);
track.level = level;
track.assertionBits = which;
-
- // NB: ownerString is explicitly managed by PMAssertStruct
- // it will be released in `handleReleaseAssertion' below
- track.ownerString = whoItIs ? OSSymbol::withCString(whoItIs).detach():nullptr;
+ track.ownerString = whoItIs ? OSSymbol::withCString(whoItIs):NULL;
track.ownerService = serviceID;
track.registryEntryID = serviceID ? serviceID->getRegistryEntryID():0;
track.modifiedTime = 0;
pmEventTimeStamp(&track.createdTime);
- track.assertCPUStartTime = 0;
- track.assertCPUDuration = 0;
-
- dataStore = OSValueObjectWithValue(track);
+
+ dataStore = OSData::withBytes(&track, sizeof(PMAssertStruct));
if (!dataStore) {
if (track.ownerString) {
track.ownerString->release();
- track.ownerString = NULL;
}
return kIOReturnNoMemory;
}
@@ -12126,8 +10396,7 @@
*outID = track.id;
if (owner && owner->pmPowerStateQueue) {
- // queue action is responsible for releasing dataStore
- owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionCreate, (void *)dataStore.detach());
+ owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionCreate, (void *)dataStore);
}
return kIOReturnSuccess;
@@ -12150,15 +10419,8 @@
}
IOLockLock(assertionsArrayLock);
-
- if ((assertStruct->assertionBits & kIOPMDriverAssertionCPUBit) &&
- (assertStruct->level == kIOPMDriverAssertionLevelOn)) {
- updateCPUBitAccounting(assertStruct);
- }
-
if (assertStruct->ownerString) {
assertStruct->ownerString->release();
- assertStruct->ownerString = NULL;
}
assertionsArray->removeObject(index);
@@ -12200,14 +10462,6 @@
IOLockLock(assertionsArrayLock);
pmEventTimeStamp(&assertStruct->modifiedTime);
- if ((assertStruct->assertionBits & kIOPMDriverAssertionCPUBit) &&
- (assertStruct->level != _level)) {
- if (_level == kIOPMDriverAssertionLevelOn) {
- assertStruct->assertCPUStartTime = mach_continuous_time();
- } else {
- updateCPUBitAccounting(assertStruct);
- }
- }
assertStruct->level = _level;
IOLockUnlock(assertionsArrayLock);
@@ -12238,8 +10492,8 @@
ASSERT_GATED();
if (new_user_levels != assertionsUser) {
- DLOG("assertionsUser 0x%llx->0x%llx\n", assertionsUser, new_user_levels);
assertionsUser = new_user_levels;
+ DLOG("assertionsUser 0x%llx\n", assertionsUser);
}
tabulate();
@@ -12264,60 +10518,65 @@
}
-OSSharedPtr<OSArray>
+OSArray *
PMAssertionsTracker::copyAssertionsArray(void)
{
int count;
int i;
- OSSharedPtr<OSArray> outArray = NULL;
-
- if (!assertionsArray || (0 == (count = assertionsArray->getCount()))) {
+ OSArray *outArray = NULL;
+
+ if (!assertionsArray ||
+ (0 == (count = assertionsArray->getCount())) ||
+ (NULL == (outArray = OSArray::withCapacity(count)))) {
goto exit;
}
- outArray = OSArray::withCapacity(count);
- if (!outArray) {
- goto exit;
- }
for (i = 0; i < count; i++) {
- const PMAssertStruct *_a = nullptr;
- OSValueObject<PMAssertStruct> *_d = nullptr;
- OSSharedPtr<OSDictionary> details;
-
- _d = OSDynamicCast(OSValueObject<PMAssertStruct>, assertionsArray->getObject(i));
- if (_d && (_a = _d->getBytesNoCopy())) {
- OSSharedPtr<OSNumber> _n;
+ PMAssertStruct *_a = NULL;
+ OSData *_d = NULL;
+ OSDictionary *details = NULL;
+
+ _d = OSDynamicCast(OSData, assertionsArray->getObject(i));
+ if (_d && (_a = (PMAssertStruct *)_d->getBytesNoCopy())) {
+ OSNumber *_n = NULL;
details = OSDictionary::withCapacity(7);
if (!details) {
continue;
}
- outArray->setObject(details.get());
+ outArray->setObject(details);
+ details->release();
_n = OSNumber::withNumber(_a->id, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionIDKey, _n.get());
+ details->setObject(kIOPMDriverAssertionIDKey, _n);
+ _n->release();
}
_n = OSNumber::withNumber(_a->createdTime, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionCreatedTimeKey, _n.get());
+ details->setObject(kIOPMDriverAssertionCreatedTimeKey, _n);
+ _n->release();
}
_n = OSNumber::withNumber(_a->modifiedTime, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionModifiedTimeKey, _n.get());
+ details->setObject(kIOPMDriverAssertionModifiedTimeKey, _n);
+ _n->release();
}
_n = OSNumber::withNumber((uintptr_t)_a->registryEntryID, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionRegistryEntryIDKey, _n.get());
+ details->setObject(kIOPMDriverAssertionRegistryEntryIDKey, _n);
+ _n->release();
}
_n = OSNumber::withNumber(_a->level, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionLevelKey, _n.get());
+ details->setObject(kIOPMDriverAssertionLevelKey, _n);
+ _n->release();
}
_n = OSNumber::withNumber(_a->assertionBits, 64);
if (_n) {
- details->setObject(kIOPMDriverAssertionAssertedKey, _n.get());
+ details->setObject(kIOPMDriverAssertionAssertedKey, _n);
+ _n->release();
}
if (_a->ownerString) {
@@ -12327,7 +10586,7 @@
}
exit:
- return os::move(outArray);
+ return outArray;
}
IOPMDriverAssertionType
@@ -12340,7 +10599,6 @@
PMAssertionsTracker::getAssertionLevel(
IOPMDriverAssertionType type)
{
- // FIXME: unused and also wrong
if (type && ((type & assertionsKernel) == assertionsKernel)) {
return kIOPMDriverAssertionLevelOn;
} else {
@@ -12393,8 +10651,8 @@
static IOPMPowerState patriarchPowerStates[2] =
{
- {.version = kIOPMPowerStateVersion1, .outputPowerCharacter = ON_POWER },
- {.version = kIOPMPowerStateVersion1, .outputPowerCharacter = ON_POWER }
+ {1, 0, ON_POWER, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {1, 0, ON_POWER, 0, 0, 0, 0, 0, 0, 0, 0, 0},
};
void
@@ -12488,7 +10746,7 @@
{
}
-OSSharedPtr<OSObject>
+OSObject *
IORootParent::copyProperty( const char * aKey) const
{
return IOService::copyProperty(aKey);
@@ -12509,7 +10767,7 @@
}
-#if defined(__i386__) || defined(__x86_64__) || (defined(__arm64__) && HIBERNATION)
+#if defined(__i386__) || defined(__x86_64__)
IOReturn
IOPMrootDomain::restartWithStackshot()
{
@@ -12684,8 +10942,7 @@
uint32_t phaseDetail = 0;
bool efiFailure = false;
- OSSharedPtr<OSObject> statusCodeProp = copyProperty(kIOPMSleepWakeFailureCodeKey);
- statusCode = OSDynamicCast(OSNumber, statusCodeProp.get());
+ statusCode = OSDynamicCast(OSNumber, getProperty(kIOPMSleepWakeFailureCodeKey));
if (statusCode) {
pmStatusCode = statusCode->unsigned64BitValue();
phaseData = pmStatusCode & 0xFFFFFFFF;
@@ -12695,7 +10952,7 @@
efiFailure = true;
failureStr[0] = 0;
snprintf(failureStr, sizeof(failureStr), "Sleep Wake failure in EFI\n\nFailure code:: 0x%08x 0x%08x\n\nPlease IGNORE the below stackshot\n", phaseDetail, phaseData);
- len = (typeof(len))strnlen(failureStr, sizeof(failureStr));
+ len = strlen(failureStr);
}
}
@@ -12761,15 +11018,14 @@
hdr = (swd_hdr *)swd_buffer;
outbuf = (char *)hdr + hdr->spindump_offset;
- OSBoundedArrayRef<char> boundedOutBuf(outbuf, hdr->alloc_size - hdr->spindump_offset);
for (int i = 0; i < 8; i++) {
- snprintf(nvram_var_name_buffer, sizeof(nvram_var_name_buffer), "%s%02d", SWD_STACKSHOT_VAR_PREFIX, i + 1);
+ snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, i + 1);
if (!PEReadNVRAMProperty(nvram_var_name_buffer, NULL, &len)) {
LOG("No SleepWake blob to read beyond chunk %d\n", i);
break;
}
- if (PEReadNVRAMProperty(nvram_var_name_buffer, boundedOutBuf.slice(concat_len, len).data(), &len) == FALSE) {
+ if (PEReadNVRAMProperty(nvram_var_name_buffer, outbuf + concat_len, &len) == FALSE) {
PERemoveNVRAMProperty(nvram_var_name_buffer);
LOG("Could not read the property :-(\n");
break;
@@ -12812,28 +11068,25 @@
void
IOPMrootDomain::getFailureData(thread_t *thread, char *failureStr, size_t strLen)
{
- OSSharedPtr<IORegistryIterator> iter;
- OSSharedPtr<const OSSymbol> kextName = NULL;
+ IORegistryIterator * iter;
IORegistryEntry * entry;
IOService * node;
bool nodeFound = false;
const void * callMethod = NULL;
const char * objectName = NULL;
+ uint32_t timeout = getWatchdogTimeout();
const char * phaseString = NULL;
const char * phaseDescription = NULL;
- uint64_t delta;
-
- IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, notifierObject.get());
+
+ IOPMServiceInterestNotifier *notifier = OSDynamicCast(IOPMServiceInterestNotifier, notifierObject);
uint32_t tracePhase = pmTracer->getTracePhase();
*thread = NULL;
-
- delta = get_watchdog_elapsed_time();
if ((tracePhase < kIOPMTracePointSystemSleep) || (tracePhase == kIOPMTracePointDarkWakeEntry)) {
- snprintf(failureStr, strLen, "Sleep transition timed out after %qd seconds", delta);
+ snprintf(failureStr, strLen, "%sSleep transition timed out after %d seconds", failureStr, timeout);
} else {
- snprintf(failureStr, strLen, "Wake transition timed out after %qd seconds", delta);
+ snprintf(failureStr, strLen, "%sWake transition timed out after %d seconds", failureStr, timeout);
}
tracePhase2String(tracePhase, &phaseString, &phaseDescription);
@@ -12861,28 +11114,24 @@
break;
}
}
+ iter->release();
}
if (nodeFound) {
- kextName = copyKextIdentifierWithAddress((vm_address_t) callMethod);
- if (kextName) {
- objectName = kextName->getCStringNoCopy();
+ OSKext *kext = OSKext::lookupKextWithAddress((vm_address_t)callMethod);
+ if (kext) {
+ objectName = kext->getIdentifierCString();
+ kext->release();
}
}
}
if (phaseDescription) {
- strlcat(failureStr, " while ", strLen);
- strlcat(failureStr, phaseDescription, strLen);
- strlcat(failureStr, ".", strLen);
+ snprintf(failureStr, strLen, "%s while %s.", failureStr, phaseDescription);
}
if (objectName) {
- strlcat(failureStr, " Suspected bundle: ", strLen);
- strlcat(failureStr, objectName, strLen);
- strlcat(failureStr, ".", strLen);
+ snprintf(failureStr, strLen, "%s Suspected bundle: %s.", failureStr, objectName);
}
if (*thread) {
- char threadName[40];
- snprintf(threadName, sizeof(threadName), " Thread 0x%llx.", thread_tid(*thread));
- strlcat(failureStr, threadName, strLen);
+ snprintf(failureStr, strLen, "%s Thread 0x%llx.", failureStr, thread_tid(*thread));
}
DLOG("%s\n", failureStr);
@@ -12947,7 +11196,6 @@
{
unsigned int i = 0;
// if outlen > max size don't add to the buffer
- assert(buf != NULL);
if (strm && buf) {
if (swd_zip_var.outlen + len > SWD_COMPRESSED_BUFSIZE) {
LOG("No space to GZIP... not writing to NVRAM\n");
@@ -12960,7 +11208,6 @@
swd_zip_var.outlen += len;
return len;
}
-
static void
swd_zs_free(void * __unused ref, void * __unused ptr)
{
@@ -12971,10 +11218,6 @@
{
int wbits = 12;
int memlevel = 3;
-
- if (((unsigned int) numBytes) != numBytes) {
- return 0;
- }
if (!swd_zs.zalloc) {
swd_zs.zalloc = swd_zs_alloc;
@@ -12988,6 +11231,8 @@
}
}
+
+
swd_zip_var.zipped = 0;
swd_zip_var.totalbytes = 0; // should this be the max that we have?
swd_zip_var.lastpercent = 0;
@@ -13010,10 +11255,12 @@
int zr;
zs = &swd_zs;
+ zr = Z_OK;
+
while (swd_zip_var.error >= 0) {
if (!zs->avail_in) {
zs->next_in = (unsigned char *)inPtr ? (Bytef *)inPtr : (Bytef *)zs; /* zero marker? */
- zs->avail_in = (unsigned int) numBytes;
+ zs->avail_in = numBytes;
}
if (!zs->avail_out) {
zs->next_out = (Bytef *)zs;
@@ -13032,7 +11279,7 @@
}
}
}
-
+ zr = Z_OK;
//now flush the stream
while (swd_zip_var.error >= 0) {
if (!zs->avail_out) {
@@ -13069,27 +11316,26 @@
PERemoveNVRAMProperty(kIOSleepWakeFailureString);
char nvram_var_name_buf[20];
for (int i = 0; i < 8; i++) {
- snprintf(nvram_var_name_buf, sizeof(nvram_var_name_buf), "%s%02d", SWD_STACKSHOT_VAR_PREFIX, i + 1);
+ snprintf(nvram_var_name_buf, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, i + 1);
if (PERemoveNVRAMProperty(nvram_var_name_buf) == false) {
LOG("Removing %s returned false\n", nvram_var_name_buf);
}
}
// force NVRAM sync
- if (PEWriteNVRAMProperty(kIONVRAMSyncNowPropertyKey, kIONVRAMSyncNowPropertyKey, (unsigned int) strlen(kIONVRAMSyncNowPropertyKey)) == false) {
+ if (PEWriteNVRAMProperty(kIONVRAMSyncNowPropertyKey, kIONVRAMSyncNowPropertyKey, strlen(kIONVRAMSyncNowPropertyKey)) == false) {
DLOG("Failed to force nvram sync\n");
}
gRootDomain->swd_lock = 0;
}
-
void
IOPMrootDomain::takeStackshot(bool wdogTrigger)
{
swd_hdr * hdr = NULL;
int cnt = 0;
- int max_cnt;
+ int max_cnt = 2;
pid_t pid = 0;
kern_return_t kr = KERN_SUCCESS;
- uint64_t flags;
+ uint32_t flags;
char * dstAddr;
uint32_t size;
@@ -13100,14 +11346,9 @@
thread_t thread = NULL;
const char * swfPanic = "swfPanic";
- uint32_t bufSize;
- int success = 0;
-
-#if defined(__i386__) || defined(__x86_64__)
- const bool concise = false;
-#else
- const bool concise = true;
-#endif
+
+ uint32_t bufSize;
+ int success = 0;
if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock)) {
return;
@@ -13121,7 +11362,7 @@
if (wdogTrigger) {
getFailureData(&thread, failureStr, sizeof(failureStr));
- if (concise || (PEGetCoprocessorVersion() >= kCoprocessorVersion2)) {
+ if (PEGetCoprocessorVersion() >= kCoprocessorVersion2) {
goto skip_stackshot;
}
} else {
@@ -13130,7 +11371,7 @@
clock_get_uptime(&now);
SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
absolutetime_to_nanoseconds(now, &nsec);
- snprintf(failureStr, sizeof(failureStr), "Power button pressed during wake transition after %u ms.\n", ((int)((nsec) / NSEC_PER_MSEC)));
+ snprintf(failureStr, sizeof(failureStr), "%sPower button pressed during wake transition after %u ms.\n", failureStr, ((int)((nsec) / NSEC_PER_MSEC)));
}
if (swd_buffer == NULL) {
@@ -13140,19 +11381,19 @@
}
}
hdr = (swd_hdr *)swd_buffer;
- bufSize = hdr->alloc_size;
+ bufSize = hdr->alloc_size;;
+
+
+
dstAddr = (char*)hdr + hdr->spindump_offset;
- flags = STACKSHOT_KCDATA_FORMAT | STACKSHOT_NO_IO_STATS | STACKSHOT_SAVE_KEXT_LOADINFO | STACKSHOT_ACTIVE_KERNEL_THREADS_ONLY | STACKSHOT_THREAD_WAITINFO | STACKSHOT_INCLUDE_DRIVER_THREADS_IN_KERNEL;
-
+ flags = STACKSHOT_KCDATA_FORMAT | STACKSHOT_NO_IO_STATS | STACKSHOT_SAVE_KEXT_LOADINFO | STACKSHOT_ACTIVE_KERNEL_THREADS_ONLY | STACKSHOT_THREAD_WAITINFO;
/* If not wdogTrigger only take kernel tasks stackshot
*/
if (wdogTrigger) {
pid = -1;
- max_cnt = 3;
} else {
pid = 0;
- max_cnt = 2;
}
/* Attempt to take stackshot with all ACTIVE_KERNEL_THREADS
@@ -13164,14 +11405,12 @@
DLOG("Taking snapshot. bytesRemaining: %d\n", bytesRemaining);
size = bytesRemaining;
- kr = stack_snapshot_from_kernel(pid, dstAddr, size, flags, 0, 0, &bytesWritten);
- DLOG("stack_snapshot_from_kernel returned 0x%x. pid: %d bufsize:0x%x flags:0x%llx bytesWritten: %d\n",
+ kr = stack_snapshot_from_kernel(pid, dstAddr, size, flags, 0, &bytesWritten);
+ DLOG("stack_snapshot_from_kernel returned 0x%x. pid: %d bufsize:0x%x flags:0x%x bytesWritten: %d\n",
kr, pid, size, flags, bytesWritten);
if (kr == KERN_INSUFFICIENT_BUFFER_SIZE) {
if (pid == -1) {
pid = 0;
- } else if (flags & STACKSHOT_INCLUDE_DRIVER_THREADS_IN_KERNEL) {
- flags = flags & ~STACKSHOT_INCLUDE_DRIVER_THREADS_IN_KERNEL;
} else {
LOG("Insufficient buffer size for only kernel task\n");
break;
@@ -13179,7 +11418,7 @@
}
if (kr == KERN_SUCCESS) {
if (bytesWritten == 0) {
- MSG("Failed to get stackshot(0x%x) bufsize:0x%x flags:0x%llx\n", kr, size, flags);
+ MSG("Failed to get stackshot(0x%x) bufsize:0x%x flags:0x%x\n", kr, size, flags);
continue;
}
bytesRemaining -= bytesWritten;
@@ -13204,14 +11443,14 @@
if (max_chunks < 8) {
for (num_chunks = 0; num_chunks < max_chunks; num_chunks++) {
- snprintf(nvram_var_name_buffer, sizeof(nvram_var_name_buffer), "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks + 1);
+ snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks + 1);
if (PEWriteNVRAMPropertyWithCopy(nvram_var_name_buffer, (outbuf + (num_chunks * (2096 - 200))), (2096 - 200)) == FALSE) {
LOG("Failed to update NVRAM %d\n", num_chunks);
break;
}
}
if (leftover) {
- snprintf(nvram_var_name_buffer, sizeof(nvram_var_name_buffer), "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks + 1);
+ snprintf(nvram_var_name_buffer, 20, "%s%02d", SWD_STACKSHOT_VAR_PREFIX, num_chunks + 1);
if (PEWriteNVRAMPropertyWithCopy(nvram_var_name_buffer, (outbuf + (num_chunks * (2096 - 200))), leftover) == FALSE) {
LOG("Failed to update NVRAM with leftovers\n");
}
@@ -13219,12 +11458,9 @@
success = 1;
LOG("Successfully saved stackshot to NVRAM\n");
} else {
+ LOG("Compressed failure stackshot is too large. size=%d bytes\n", outlen);
if (pid == -1) {
- LOG("Compressed failure stackshot is too large. size=%d bytes\n", outlen);
pid = 0;
- } else if (flags & STACKSHOT_INCLUDE_DRIVER_THREADS_IN_KERNEL) {
- LOG("Compressed failure stackshot of kernel+dexts is too large size=%d bytes\n", outlen);
- flags = flags & ~STACKSHOT_INCLUDE_DRIVER_THREADS_IN_KERNEL;
} else {
LOG("Compressed failure stackshot of only kernel is too large size=%d bytes\n", outlen);
break;
@@ -13237,17 +11473,15 @@
if (failureStr[0]) {
// append sleep-wake failure code
- char traceCode[80];
- snprintf(traceCode, sizeof(traceCode), "\nFailure code:: 0x%08x %08x\n",
- pmTracer->getTraceData(), pmTracer->getTracePhase());
- strlcat(failureStr, traceCode, sizeof(failureStr));
- if (PEWriteNVRAMProperty(kIOSleepWakeFailureString, failureStr, (unsigned int) strnlen(failureStr, sizeof(failureStr))) == false) {
+ snprintf(failureStr, sizeof(failureStr), "%s\nFailure code:: 0x%08x %08x\n",
+ failureStr, pmTracer->getTraceData(), pmTracer->getTracePhase());
+ if (PEWriteNVRAMProperty(kIOSleepWakeFailureString, failureStr, strlen(failureStr)) == false) {
DLOG("Failed to write SleepWake failure string\n");
}
}
// force NVRAM sync
- if (PEWriteNVRAMProperty(kIONVRAMSyncNowPropertyKey, kIONVRAMSyncNowPropertyKey, (unsigned int) strlen(kIONVRAMSyncNowPropertyKey)) == false) {
+ if (PEWriteNVRAMProperty(kIONVRAMSyncNowPropertyKey, kIONVRAMSyncNowPropertyKey, strlen(kIONVRAMSyncNowPropertyKey)) == false) {
DLOG("Failed to force nvram sync\n");
}
@@ -13259,26 +11493,29 @@
// then don't trigger again until at least 1 successful sleep & wake.
if (!(sleepCnt && (displayWakeCnt || darkWakeCnt))) {
LOG("Shutting down due to repeated Sleep/Wake failures\n");
- updateTasksSuspend(kTasksSuspendSuspended, kTasksSuspendNoChange);
+ if (!tasksSuspended) {
+ tasksSuspended = TRUE;
+ updateTasksSuspend();
+ }
PEHaltRestart(kPEHaltCPU);
return;
}
}
if (gSwdPanic == 0) {
LOG("Calling panic prevented by swd_panic boot-args. Calling restart");
- updateTasksSuspend(kTasksSuspendSuspended, kTasksSuspendNoChange);
+ if (!tasksSuspended) {
+ tasksSuspended = TRUE;
+ updateTasksSuspend();
+ }
PEHaltRestart(kPERestartCPU);
}
}
- if (!concise && (PEWriteNVRAMProperty(kIOSleepWakeFailurePanic, swfPanic, (unsigned int) strlen(swfPanic)) == false)) {
+ if (PEWriteNVRAMProperty(kIOSleepWakeFailurePanic, swfPanic, strlen(swfPanic)) == false) {
DLOG("Failed to write SleepWake failure panic key\n");
}
-#if defined(__x86_64__)
if (thread) {
panic_with_thread_context(0, NULL, DEBUGGER_OPTION_ATTEMPTCOREDUMPANDREBOOT, thread, "%s", failureStr);
- } else
-#endif /* defined(__x86_64__) */
- {
+ } else {
panic_with_options(0, NULL, DEBUGGER_OPTION_ATTEMPTCOREDUMPANDREBOOT, "%s", failureStr);
}
} else {
@@ -13295,7 +11532,7 @@
swd_hdr *hdr = NULL;
void *bufPtr = NULL;
- OSSharedPtr<IOBufferMemoryDescriptor> memDesc;
+ IOBufferMemoryDescriptor *memDesc = NULL;
if (kIOSleepWakeWdogOff & gIOKitDebug) {
@@ -13333,7 +11570,7 @@
hdr->spindump_offset = sizeof(swd_hdr);
swd_buffer = (void *)hdr;
- swd_memDesc = os::move(memDesc);
+ swd_memDesc = memDesc;
DLOG("SleepWake debug buffer size:0x%x spindump offset:0x%x\n", hdr->alloc_size, hdr->spindump_offset);
exit:
@@ -13343,12 +11580,11 @@
void
IOPMrootDomain::sleepWakeDebugSpinDumpMemAlloc()
{
-#if UNUSED
vm_size_t size = SWD_SPINDUMP_SIZE;
swd_hdr *hdr = NULL;
- OSSharedPtr<IOBufferMemoryDescriptor> memDesc;
+ IOBufferMemoryDescriptor *memDesc = NULL;
if (!OSCompareAndSwap(0, 1, &gRootDomain->swd_lock)) {
return;
@@ -13372,11 +11608,9 @@
hdr->spindump_offset = sizeof(swd_hdr);
swd_spindump_buffer = (void *)hdr;
- swd_spindump_memDesc = os::move(memDesc);
exit:
gRootDomain->swd_lock = 0;
-#endif /* UNUSED */
}
void
@@ -13465,7 +11699,8 @@
return error;
}
-#else /* defined(__i386__) || defined(__x86_64__) */
+
+#else
void
IOPMrootDomain::sleepWakeDebugTrig(bool restart)
@@ -13484,17 +11719,14 @@
{
#pragma unused(restart)
}
-
void
IOPMrootDomain::deleteStackshot()
{
}
-
void
IOPMrootDomain::sleepWakeDebugMemAlloc()
{
}
-
void
IOPMrootDomain::saveFailureData2File()
{
@@ -13511,16 +11743,11 @@
return false;
}
-void
-IOPMrootDomain::sleepWakeDebugSaveSpinDumpFile()
-{
-}
-
errno_t
IOPMrootDomain::sleepWakeDebugSaveFile(const char *name, char *buf, int len)
{
return 0;
}
-#endif /* defined(__i386__) || defined(__x86_64__) */
-
+#endif
+