]> git.saurik.com Git - apple/xnu.git/blobdiff - iokit/Kernel/RootDomainUserClient.cpp
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-2050.18.24.tar.gz
[apple/xnu.git] / iokit / Kernel / RootDomainUserClient.cpp
diff --git a/iokit/Kernel/RootDomainUserClient.cpp b/iokit/Kernel/RootDomainUserClient.cpp
index d55003ded3471ebf5fad1856d8d206662a6ce10e..75a26e7cc544f7af607e8142bc74bc5118e1f0e7 100644 (file)
--- a/iokit/Kernel/RootDomainUserClient.cpp
+++ b/iokit/Kernel/RootDomainUserClient.cpp
@@ -32,9 +32,11 @@
 
 #include <IOKit/assert.h>
 #include <IOKit/IOLib.h>
 
 #include <IOKit/assert.h>
 #include <IOKit/IOLib.h>
+#include <IOKit/IOKitKeys.h>
 #include <IOKit/IOBufferMemoryDescriptor.h>
 #include "RootDomainUserClient.h"
 #include <IOKit/pwr_mgt/IOPMLibDefs.h>
 #include <IOKit/IOBufferMemoryDescriptor.h>
 #include "RootDomainUserClient.h"
 #include <IOKit/pwr_mgt/IOPMLibDefs.h>
+#include <IOKit/pwr_mgt/IOPMPrivate.h>
 
 #define super IOUserClient
 
 
 #define super IOUserClient
 
@@ -44,9 +46,13 @@ OSDefineMetaClassAndStructors(RootDomainUserClient, IOUserClient)
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-bool RootDomainUserClient::initWithTask(task_t owningTask, void *security_id, UInt32)
+bool RootDomainUserClient::initWithTask(task_t owningTask, void *security_id, 
+                                       UInt32 type, OSDictionary * properties)
 {
 {
-    if (!super::init())
+    if (properties)
+       properties->setObject(kIOUserClientCrossEndianCompatibleKey, kOSBooleanTrue);
+
+    if (!super::initWithTask(owningTask, security_id, type, properties))
        return false;
 
     fOwningTask = owningTask;
        return false;
 
     fOwningTask = owningTask;
@@ -66,26 +72,65 @@ bool RootDomainUserClient::start( IOService * provider )
     return true;
 }
 
     return true;
 }
 
-IOReturn RootDomainUserClient::secureSleepSystem( int *return_code )
+IOReturn RootDomainUserClient::secureSleepSystem( uint32_t *return_code )
+{
+    return secureSleepSystemOptions(NULL, 0, return_code);
+}
+
+IOReturn RootDomainUserClient::secureSleepSystemOptions( 
+    const void      *inOptions, 
+    IOByteCount     inOptionsSize __unused,
+    uint32_t        *returnCode)
 {
 {
+
     int             local_priv = 0;
     int             admin_priv = 0;
     IOReturn        ret = kIOReturnNotPrivileged;
     int             local_priv = 0;
     int             admin_priv = 0;
     IOReturn        ret = kIOReturnNotPrivileged;
+    OSDictionary    *unserializedOptions =  NULL;
+    OSString        *unserializeErrorString = NULL;
 
     ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeLocalUser);
     local_priv = (kIOReturnSuccess == ret);
     
     ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
     admin_priv = (kIOReturnSuccess == ret);
 
     ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeLocalUser);
     local_priv = (kIOReturnSuccess == ret);
     
     ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
     admin_priv = (kIOReturnSuccess == ret);
+    
+    
+    if (inOptions)
+    {
+        unserializedOptions = OSDynamicCast( OSDictionary,
+                                             OSUnserializeXML((const char *)inOptions, &unserializeErrorString));
+    
+        if (!unserializedOptions) {
+            IOLog("IOPMRootDomain SleepSystem unserialization failure: %s\n", 
+                unserializeErrorString ? unserializeErrorString->getCStringNoCopy() : "Unknown");
+        }
+    }
+
+    if ( (local_priv || admin_priv) 
+          && fOwner ) 
+    {
+        if (unserializedOptions) 
+        {
+            // Publish Sleep Options in registry under root_domain
+            fOwner->setProperty( kRootDomainSleepOptionsKey, unserializedOptions);            
+
+            *returnCode = fOwner->sleepSystemOptions( unserializedOptions );
+
+            unserializedOptions->release();        
+        } else {
+            // No options
+            // Clear any pre-existing options
+            fOwner->removeProperty( kRootDomainSleepOptionsKey );
+
+            *returnCode = fOwner->sleepSystemOptions( NULL );        
+        }
 
 
-    if((local_priv || admin_priv) && fOwner) {
-        *return_code = fOwner->sleepSystem();
-        return kIOReturnSuccess;
     } else {
     } else {
-        *return_code = kIOReturnNotPrivileged;
-        return kIOReturnSuccess;
+        *returnCode = kIOReturnNotPrivileged;
     }
 
     }
 
+    return kIOReturnSuccess;
 }
 
 IOReturn RootDomainUserClient::secureSetAggressiveness( 
 }
 
 IOReturn RootDomainUserClient::secureSetAggressiveness( 
@@ -105,14 +150,46 @@ IOReturn RootDomainUserClient::secureSetAggressiveness(
 
     if((local_priv || admin_priv) && fOwner) {
         *return_code = fOwner->setAggressiveness(type, newLevel);
 
     if((local_priv || admin_priv) && fOwner) {
         *return_code = fOwner->setAggressiveness(type, newLevel);
-        return kIOReturnSuccess;
     } else {
         *return_code = kIOReturnNotPrivileged;
     } else {
         *return_code = kIOReturnNotPrivileged;
-        return kIOReturnSuccess;
     }
     }
+    return kIOReturnSuccess;
+}
+
+IOReturn RootDomainUserClient::secureSetMaintenanceWakeCalendar(
+    IOPMCalendarStruct      *inCalendar,
+    uint32_t                *returnCode)
+{
+    int                     admin_priv = 0;
+    IOReturn                ret = kIOReturnNotPrivileged;
+    
+    ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
+    admin_priv = (kIOReturnSuccess == ret);
 
 
+    if (admin_priv && fOwner) {
+        *returnCode = fOwner->setMaintenanceWakeCalendar(inCalendar);
+    } else {
+        *returnCode = kIOReturnNotPrivileged;
+    }
+    return kIOReturnSuccess;
 }
 
 }
 
+IOReturn RootDomainUserClient::secureSetUserAssertionLevels(
+    uint32_t    assertionBitfield)
+{
+    int                     admin_priv = 0;
+    IOReturn                ret = kIOReturnNotPrivileged;
+    
+    ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
+    admin_priv = (kIOReturnSuccess == ret);
+
+    if (admin_priv && fOwner) {
+        ret = fOwner->setPMAssertionUserLevels(assertionBitfield);
+    } else {
+        ret = kIOReturnNotPrivileged;
+    }
+    return kIOReturnSuccess;
+}
 
 IOReturn RootDomainUserClient::clientClose( void )
 {
 
 IOReturn RootDomainUserClient::clientClose( void )
 {
@@ -126,51 +203,191 @@ IOReturn RootDomainUserClient::clientClose( void )
     return kIOReturnSuccess;
 }
 
     return kIOReturnSuccess;
 }
 
-IOExternalMethod *
-RootDomainUserClient::getTargetAndMethodForIndex( IOService ** targetP, UInt32 index )
+IOReturn RootDomainUserClient::clientMemoryForType(
+    UInt32 type,
+    IOOptionBits *options,
+    IOMemoryDescriptor ** memory)
+{
+    if (!fOwner)
+        return kIOReturnNotReady;
+
+    if (kPMRootDomainMapTraceBuffer == type)
+    {
+        *memory = fOwner->getPMTraceMemoryDescriptor();
+        if (*memory) {
+            (*memory)->retain();
+            *options = 0;
+            return kIOReturnSuccess;
+        } else {
+            return kIOReturnNotFound;
+        }
+
+    }
+    return kIOReturnUnsupported;
+}
+
+IOReturn RootDomainUserClient::externalMethod(
+    uint32_t selector, 
+    IOExternalMethodArguments * arguments,
+    IOExternalMethodDispatch * dispatch __unused, 
+    OSObject * target __unused,
+    void * reference __unused )
 {
 {
-    static IOExternalMethod sMethods[] = {
-        { // kPMSetAggressiveness, 0
-            1, (IOMethod)&RootDomainUserClient::secureSetAggressiveness, kIOUCScalarIScalarO, 2, 1
-        },
-        { // kPMGetAggressiveness, 1
-            0, (IOMethod)&IOPMrootDomain::getAggressiveness, kIOUCScalarIScalarO, 1, 1
-        },
-        { // kPMSleepSystem, 2
-            1, (IOMethod)&RootDomainUserClient::secureSleepSystem, kIOUCScalarIScalarO, 0, 1
-        },
-        { // kPMAllowPowerChange, 3
-            0, (IOMethod)&IOPMrootDomain::allowPowerChange, kIOUCScalarIScalarO, 1, 0
-        },
-        { // kPMCancelPowerChange, 4
-            0, (IOMethod)&IOPMrootDomain::cancelPowerChange, kIOUCScalarIScalarO, 1, 0
-        },
-        { // kPMShutdownSystem, 5
-            0, (IOMethod)&IOPMrootDomain::shutdownSystem, kIOUCScalarIScalarO, 0, 0
-        },
-        { // kPMRestartSystem, 6
-            0, (IOMethod)&IOPMrootDomain::restartSystem, kIOUCScalarIScalarO, 0, 0
-        },
-        { // kPMSetPreventative, 7
-            1, (IOMethod) &RootDomainUserClient::setPreventative, kIOUCScalarIScalarO, 2, 0
-        },
-    };
+    IOReturn    ret = kIOReturnBadArgument;    
+    
+    switch (selector)
+    {
+        case kPMSetAggressiveness:
+            if ((2 == arguments->scalarInputCount)
+                && (1 == arguments->scalarOutputCount))
+            {
+                ret = this->secureSetAggressiveness(
+                                (unsigned long)arguments->scalarInput[0],
+                                (unsigned long)arguments->scalarInput[1],
+                                (int *)&arguments->scalarOutput[0]);
+            }
+            break;
+        
+        case kPMGetAggressiveness:
+            if ((1 == arguments->scalarInputCount)
+                && (1 == arguments->scalarOutputCount))
+            {
+                ret = fOwner->getAggressiveness(
+                                (unsigned long)arguments->scalarInput[0],
+                                (unsigned long *)&arguments->scalarOutput[0]);
+            }
+            break;
+        
+        case kPMSleepSystem:
+            if (1 == arguments->scalarOutputCount)
+            {
+                ret = this->secureSleepSystem(
+                                (uint32_t *)&arguments->scalarOutput[0]);            
+            }
+            break;
+
+        case kPMAllowPowerChange:
+            if (1 == arguments->scalarInputCount)
+            {
+                ret = fOwner->allowPowerChange(
+                                arguments->scalarInput[0]);
+            }
+            break;
+
+        case kPMCancelPowerChange:
+            if (1 == arguments->scalarInputCount)
+            {
+                ret = fOwner->cancelPowerChange(
+                                arguments->scalarInput[0]);
+            }
+            break;
+
+        case kPMShutdownSystem:
+            // deperecated interface
+            ret = kIOReturnUnsupported;
+            break;
+
+        case kPMRestartSystem:
+            // deperecated interface
+            ret = kIOReturnUnsupported;
+            break;
+
+        case kPMSleepSystemOptions:
+            ret = this->secureSleepSystemOptions(
+                    arguments->structureInput,
+                    arguments->structureInputSize,
+                    (uint32_t *)&arguments->scalarOutput[0]);
+            break;
+        case kPMSetMaintenanceWakeCalendar:
+            ret = this->secureSetMaintenanceWakeCalendar(
+                    (IOPMCalendarStruct *)arguments->structureInput, 
+                    (uint32_t *)&arguments->structureOutput);
+            arguments->structureOutputSize = sizeof(uint32_t);
+            break;
+            
+        case kPMSetUserAssertionLevels:
+            ret = this->secureSetUserAssertionLevels(
+                        (uint32_t)arguments->scalarInput[0]);
+            break;
+            
+        case kPMActivityTickle:
+            fOwner->reportUserInput( );
+            fOwner->setProperty(kIOPMRootDomainWakeTypeKey, "UserActivity Assertion");
+            ret = kIOReturnSuccess;
+            break;
+            
+/*
+        case kPMMethodCopySystemTimeline:
+            // intentional fallthrough
+        case kPMMethodCopyDetailedTimeline:
+
+            if (!arguments->structureOutputDescriptor)
+            {
+                // TODO: Force IOKit.framework to always send this data out
+                // of line; so I don't have to create a MemoryDescriptor here.
+                mem_size = arguments->structureOutputSize;
+                mem = IOMemoryDescriptor::withAddressRange(
+                                    (mach_vm_address_t)arguments->structureOutput, 
+                                    (mach_vm_size_t)mem_size,
+                                    kIODirectionIn, current_task());
+            } else {
+                mem_size = arguments->structureOutputDescriptorSize;
+                if (( mem = arguments->structureOutputDescriptor ))
+                    mem->retain();   
+            }
+            
+            if (mem)
+            {
+                mem->prepare(kIODirectionNone);
     
     
-    if(index >= kNumPMMethods)
-       return NULL;
-    else {
-        if (sMethods[index].object)
-            *targetP = this;
-        else
-            *targetP = fOwner;
-
-        return &sMethods[index];
+                if (kPMMethodCopySystemTimeline == selector) {
+                    arguments->scalarOutput[0] = fOwner->copySystemTimeline(
+                                    mem, &mem_size);
+                } 
+                else
+                if (kPMMethodCopyDetailedTimeline == selector) {
+                    arguments->scalarOutput[0] = fOwner->copyDetailedTimeline(
+                                    mem, &mem_size);
+                }
+            
+                if (arguments->structureOutputDescriptor) {
+                    arguments->structureOutputDescriptorSize = mem_size;
+                } else {
+                    arguments->structureOutputSize = mem_size;
+                }
+            
+                mem->release();
+
+                ret = kIOReturnSuccess;
+            } else {
+                ret = kIOReturnCannotWire;
+            }
+            
+            break;
+*/
+        default:
+            // bad selector
+            return kIOReturnBadArgument;
     }
     }
+
+    return ret;
 }
 
 }
 
-void 
-RootDomainUserClient::setPreventative(UInt32 on_off, UInt32 types_of_sleep)
+/* getTargetAndMethodForIndex
+ * Not used. We prefer to use externalMethod() for user client invocations.
+ * We maintain getTargetAndExternalMethod since it's an exported symbol,
+ * and only for that reason.
+ */
+IOExternalMethod * RootDomainUserClient::getTargetAndMethodForIndex( 
+    IOService ** targetP, UInt32 index )
 {
 {
-    return;
+    // DO NOT EDIT
+    return super::getTargetAndMethodForIndex(targetP, index);
 }
 
 }
 
+/* setPreventative
+ * Does nothing. Exists only for exported symbol compatibility.
+ */
+void 
+RootDomainUserClient::setPreventative(UInt32 on_off, UInt32 types_of_sleep)
+{ return; } // DO NOT EDIT
mirror of XNU