1 /*
2 * Copyright (c) 1998-2020 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
30 *
31 */
32
33 #include <IOKit/assert.h>
34 #include <IOKit/IOLib.h>
35 #include <IOKit/IOKitKeys.h>
36 #include <IOKit/IOBufferMemoryDescriptor.h>
37 #include "RootDomainUserClient.h"
38 #include <IOKit/pwr_mgt/IOPMLibDefs.h>
39 #include <IOKit/pwr_mgt/IOPMPrivate.h>
40 #include <sys/proc.h>
41
42 #define super IOUserClient2022
43
44 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
45
OSDefineMetaClassAndStructors(RootDomainUserClient,IOUserClient2022)46 OSDefineMetaClassAndStructors(RootDomainUserClient, IOUserClient2022)
47
48 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
49
50 bool
51 RootDomainUserClient::initWithTask(task_t owningTask, void *security_id,
52 UInt32 type, OSDictionary * properties)
53 {
54 if (properties) {
55 properties->setObject(kIOUserClientCrossEndianCompatibleKey, kOSBooleanTrue);
56 }
57
58 if (!super::initWithTask(owningTask, security_id, type, properties)) {
59 return false;
60 }
61
62 fOwningTask = owningTask;
63 task_reference(fOwningTask);
64 return true;
65 }
66
67
68 bool
start(IOService * provider)69 RootDomainUserClient::start( IOService * provider )
70 {
71 assert(OSDynamicCast(IOPMrootDomain, provider));
72 if (!super::start(provider)) {
73 return false;
74 }
75 fOwner = (IOPMrootDomain *)provider;
76
77 setProperty(kIOUserClientDefaultLockingKey, kOSBooleanTrue);
78 setProperty(kIOUserClientDefaultLockingSetPropertiesKey, kOSBooleanTrue);
79 setProperty(kIOUserClientDefaultLockingSingleThreadExternalMethodKey, kOSBooleanFalse);
80
81 setProperty(kIOUserClientEntitlementsKey, kOSBooleanFalse);
82
83 return true;
84 }
85
86 IOReturn
secureSleepSystem(uint32_t * return_code)87 RootDomainUserClient::secureSleepSystem( uint32_t *return_code )
88 {
89 return secureSleepSystemOptions(NULL, 0, return_code);
90 }
91
92 IOReturn
secureSleepSystemOptions(const void * inOptions,IOByteCount inOptionsSize,uint32_t * returnCode)93 RootDomainUserClient::secureSleepSystemOptions(
94 const void *inOptions,
95 IOByteCount inOptionsSize,
96 uint32_t *returnCode)
97 {
98 int local_priv = 0;
99 int admin_priv = 0;
100 IOReturn ret = kIOReturnNotPrivileged;
101
102 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeLocalUser);
103 local_priv = (kIOReturnSuccess == ret);
104
105 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
106 admin_priv = (kIOReturnSuccess == ret);
107
108 if ((local_priv || admin_priv) && fOwner) {
109 OSString *unserializeErrorString = NULL;
110 OSObject *unserializedObject = NULL;
111 OSDictionary *sleepOptionsDict = NULL; // do not release
112
113 proc_t p;
114 p = (proc_t)get_bsdtask_info(fOwningTask);
115 if (p) {
116 fOwner->setProperty("SleepRequestedByPID", proc_pid(p), 32);
117 }
118
119 if (inOptions) {
120 unserializedObject = OSUnserializeXML((const char *)inOptions, inOptionsSize, &unserializeErrorString);
121 sleepOptionsDict = OSDynamicCast( OSDictionary, unserializedObject);
122 if (!sleepOptionsDict) {
123 IOLog("IOPMRootDomain SleepSystem unserialization failure: %s\n",
124 unserializeErrorString ? unserializeErrorString->getCStringNoCopy() : "Unknown");
125 }
126 }
127
128 if (sleepOptionsDict) {
129 // Publish Sleep Options in registry under root_domain
130 fOwner->setProperty( kRootDomainSleepOptionsKey, sleepOptionsDict);
131 } else {
132 // No options
133 // Clear any pre-existing options
134 fOwner->removeProperty( kRootDomainSleepOptionsKey );
135 }
136
137 *returnCode = fOwner->sleepSystemOptions( sleepOptionsDict );
138 OSSafeReleaseNULL(unserializedObject);
139 OSSafeReleaseNULL(unserializeErrorString);
140 } else {
141 *returnCode = kIOReturnNotPrivileged;
142 }
143
144 return kIOReturnSuccess;
145 }
146
147 IOReturn
secureSetAggressiveness(unsigned long type,unsigned long newLevel,int * return_code)148 RootDomainUserClient::secureSetAggressiveness(
149 unsigned long type,
150 unsigned long newLevel,
151 int *return_code )
152 {
153 int local_priv = 0;
154 int admin_priv = 0;
155 IOReturn ret = kIOReturnNotPrivileged;
156
157 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeLocalUser);
158 local_priv = (kIOReturnSuccess == ret);
159
160 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
161 admin_priv = (kIOReturnSuccess == ret);
162
163 if ((local_priv || admin_priv) && fOwner) {
164 *return_code = fOwner->setAggressiveness(type, newLevel);
165 } else {
166 *return_code = kIOReturnNotPrivileged;
167 }
168 return kIOReturnSuccess;
169 }
170
171 IOReturn
secureSetMaintenanceWakeCalendar(IOPMCalendarStruct * inCalendar,uint32_t * returnCode)172 RootDomainUserClient::secureSetMaintenanceWakeCalendar(
173 IOPMCalendarStruct *inCalendar,
174 uint32_t *returnCode)
175 {
176 int admin_priv = 0;
177 IOReturn ret = kIOReturnNotPrivileged;
178
179 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
180 admin_priv = (kIOReturnSuccess == ret);
181
182 if (admin_priv && fOwner) {
183 *returnCode = fOwner->setMaintenanceWakeCalendar(inCalendar);
184 } else {
185 *returnCode = kIOReturnNotPrivileged;
186 }
187 return kIOReturnSuccess;
188 }
189
190 IOReturn
secureSetUserAssertionLevels(uint32_t assertionBitfield)191 RootDomainUserClient::secureSetUserAssertionLevels(
192 uint32_t assertionBitfield)
193 {
194 int admin_priv = 0;
195 IOReturn ret = kIOReturnNotPrivileged;
196
197 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
198 admin_priv = (kIOReturnSuccess == ret);
199
200 if (admin_priv && fOwner) {
201 ret = fOwner->setPMAssertionUserLevels(assertionBitfield);
202 } else {
203 ret = kIOReturnNotPrivileged;
204 }
205 return kIOReturnSuccess;
206 }
207
208 IOReturn
secureGetSystemSleepType(uint32_t * outSleepType,uint32_t * sleepTimer)209 RootDomainUserClient::secureGetSystemSleepType(
210 uint32_t *outSleepType, uint32_t *sleepTimer)
211 {
212 int admin_priv = 0;
213 IOReturn ret;
214
215 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
216 admin_priv = (kIOReturnSuccess == ret);
217
218 if (admin_priv && fOwner) {
219 ret = fOwner->getSystemSleepType(outSleepType, sleepTimer);
220 } else {
221 ret = kIOReturnNotPrivileged;
222 }
223 return ret;
224 }
225
226 IOReturn
secureAttemptIdleSleepAbort(uint32_t * outReverted)227 RootDomainUserClient::secureAttemptIdleSleepAbort(
228 uint32_t *outReverted)
229 {
230 int admin_priv = 0;
231 IOReturn ret;
232
233 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
234 admin_priv = (kIOReturnSuccess == ret);
235
236 if (admin_priv && fOwner) {
237 *outReverted = (uint32_t) fOwner->attemptIdleSleepAbort();
238 } else {
239 ret = kIOReturnNotPrivileged;
240 }
241 return ret;
242 }
243
244 IOReturn
secureSetLockdownModeHibernation(uint32_t status)245 RootDomainUserClient::secureSetLockdownModeHibernation(
246 uint32_t status)
247 {
248 #if HIBERNATION
249 int admin_priv = 0;
250 IOReturn ret;
251
252 ret = clientHasPrivilege(fOwningTask, kIOClientPrivilegeAdministrator);
253 admin_priv = (kIOReturnSuccess == ret);
254
255 if (admin_priv && fOwner) {
256 fOwner->setLockdownModeHibernation(status);
257 } else {
258 ret = kIOReturnNotPrivileged;
259 }
260 return kIOReturnSuccess;
261 #else
262 return kIOReturnError;
263 #endif
264 }
265
266 IOReturn
clientClose(void)267 RootDomainUserClient::clientClose( void )
268 {
269 terminate();
270
271 return kIOReturnSuccess;
272 }
273
274 void
stop(IOService * provider)275 RootDomainUserClient::stop( IOService *provider)
276 {
277 if (fOwningTask) {
278 task_deallocate(fOwningTask);
279 fOwningTask = NULL;
280 }
281
282 super::stop(provider);
283 }
284
285 IOReturn
externalMethod(uint32_t selector,IOExternalMethodArgumentsOpaque * args)286 RootDomainUserClient::externalMethod(uint32_t selector, IOExternalMethodArgumentsOpaque * args )
287 {
288 static const IOExternalMethodDispatch2022 dispatchArray[] = {
289 [kPMSetAggressiveness] = {
290 .function = &RootDomainUserClient::externalMethodDispatched,
291 .checkScalarInputCount = 2,
292 .checkStructureInputSize = 0,
293 .checkScalarOutputCount = 1,
294 .checkStructureOutputSize = 0,
295 .allowAsync = false,
296 .checkEntitlement = NULL,
297 },
298 [kPMGetAggressiveness] = {
299 .function = &RootDomainUserClient::externalMethodDispatched,
300 .checkScalarInputCount = 1,
301 .checkStructureInputSize = 0,
302 .checkScalarOutputCount = 1,
303 .checkStructureOutputSize = 0,
304 .allowAsync = false,
305 .checkEntitlement = NULL,
306 },
307 [kPMSleepSystem] = {
308 .function = &RootDomainUserClient::externalMethodDispatched,
309 .checkScalarInputCount = 0,
310 .checkStructureInputSize = 0,
311 .checkScalarOutputCount = 1,
312 .checkStructureOutputSize = 0,
313 .allowAsync = false,
314 .checkEntitlement = NULL,
315 },
316 [kPMAllowPowerChange] = {
317 .function = &RootDomainUserClient::externalMethodDispatched,
318 .checkScalarInputCount = 1,
319 .checkStructureInputSize = 0,
320 .checkScalarOutputCount = 0,
321 .checkStructureOutputSize = 0,
322 .allowAsync = false,
323 .checkEntitlement = NULL,
324 },
325 [kPMCancelPowerChange] = {
326 .function = &RootDomainUserClient::externalMethodDispatched,
327 .checkScalarInputCount = 1,
328 .checkStructureInputSize = 0,
329 .checkScalarOutputCount = 0,
330 .checkStructureOutputSize = 0,
331 .allowAsync = false,
332 .checkEntitlement = NULL,
333 },
334 [kPMShutdownSystem] = {
335 .function = &RootDomainUserClient::externalMethodDispatched,
336 .checkScalarInputCount = 0,
337 .checkStructureInputSize = 0,
338 .checkScalarOutputCount = 0,
339 .checkStructureOutputSize = 0,
340 .allowAsync = false,
341 .checkEntitlement = NULL,
342 },
343 [kPMRestartSystem] = {
344 .function = &RootDomainUserClient::externalMethodDispatched,
345 .checkScalarInputCount = 0,
346 .checkStructureInputSize = 0,
347 .checkScalarOutputCount = 0,
348 .checkStructureOutputSize = 0,
349 .allowAsync = false,
350 .checkEntitlement = NULL,
351 },
352 [kPMSleepSystemOptions] = {
353 .function = &RootDomainUserClient::externalMethodDispatched,
354 .checkScalarInputCount = 0,
355 .checkStructureInputSize = kIOUCVariableStructureSize,
356 .checkScalarOutputCount = 0,
357 .checkStructureOutputSize = sizeof(uint32_t),
358 .allowAsync = false,
359 .checkEntitlement = NULL,
360 },
361 [kPMSetMaintenanceWakeCalendar] = {
362 .function = &RootDomainUserClient::externalMethodDispatched,
363 .checkScalarInputCount = 0,
364 .checkStructureInputSize = sizeof(IOPMCalendarStruct),
365 .checkScalarOutputCount = 0,
366 .checkStructureOutputSize = sizeof(uint32_t),
367 .allowAsync = false,
368 .checkEntitlement = NULL,
369 },
370 [kPMSetUserAssertionLevels] = {
371 .function = &RootDomainUserClient::externalMethodDispatched,
372 .checkScalarInputCount = 1,
373 .checkStructureInputSize = 0,
374 .checkScalarOutputCount = 0,
375 .checkStructureOutputSize = 0,
376 .allowAsync = false,
377 .checkEntitlement = NULL,
378 },
379 [kPMActivityTickle] = {
380 .function = &RootDomainUserClient::externalMethodDispatched,
381 .checkScalarInputCount = 0,
382 .checkStructureInputSize = 0,
383 .checkScalarOutputCount = 0,
384 .checkStructureOutputSize = 0,
385 .allowAsync = false,
386 .checkEntitlement = NULL,
387 },
388 [kPMSetClamshellSleepState] = {
389 .function = &RootDomainUserClient::externalMethodDispatched,
390 .checkScalarInputCount = 1,
391 .checkStructureInputSize = 0,
392 .checkScalarOutputCount = 0,
393 .checkStructureOutputSize = 0,
394 .allowAsync = false,
395 .checkEntitlement = NULL,
396 },
397 [kPMGetSystemSleepType] = {
398 .function = &RootDomainUserClient::externalMethodDispatched,
399 .checkScalarInputCount = 0,
400 .checkStructureInputSize = 0,
401 .checkScalarOutputCount = 2,
402 .checkStructureOutputSize = 0,
403 .allowAsync = false,
404 .checkEntitlement = NULL,
405 },
406 [kPMSleepWakeWatchdogEnable] = {
407 .function = &RootDomainUserClient::externalMethodDispatched,
408 .checkScalarInputCount = 0,
409 .checkStructureInputSize = 0,
410 .checkScalarOutputCount = 0,
411 .checkStructureOutputSize = 0,
412 .allowAsync = false,
413 .checkEntitlement = NULL,
414 },
415 [kPMSleepWakeDebugTrig] = {
416 .function = &RootDomainUserClient::externalMethodDispatched,
417 .checkScalarInputCount = 0,
418 .checkStructureInputSize = 0,
419 .checkScalarOutputCount = 0,
420 .checkStructureOutputSize = 0,
421 .allowAsync = false,
422 .checkEntitlement = NULL,
423 },
424 [kPMSetDisplayPowerOn] = {
425 .function = &RootDomainUserClient::externalMethodDispatched,
426 .checkScalarInputCount = 1,
427 .checkStructureInputSize = 0,
428 .checkScalarOutputCount = 0,
429 .checkStructureOutputSize = 0,
430 .allowAsync = false,
431 .checkEntitlement = NULL,
432 },
433 [kPMRequestIdleSleepRevert] = {
434 .function = &RootDomainUserClient::externalMethodDispatched,
435 .checkScalarInputCount = 0,
436 .checkStructureInputSize = 0,
437 .checkScalarOutputCount = 1,
438 .checkStructureOutputSize = 0,
439 .allowAsync = false,
440 .checkEntitlement = NULL,
441 },
442 [kPMSetLDMHibernationDisable] = {
443 .function = &RootDomainUserClient::externalMethodDispatched,
444 .checkScalarInputCount = 1,
445 .checkStructureInputSize = 0,
446 .checkScalarOutputCount = 0,
447 .checkStructureOutputSize = 0,
448 .allowAsync = false,
449 .checkEntitlement = NULL,
450 },
451 };
452
453 return dispatchExternalMethod(selector, args, dispatchArray, sizeof(dispatchArray) / sizeof(dispatchArray[0]), this, NULL);
454 }
455 IOReturn
externalMethodDispatched(OSObject * target,void * reference,IOExternalMethodArguments * arguments)456 RootDomainUserClient::externalMethodDispatched(OSObject * target, void * reference, IOExternalMethodArguments * arguments)
457 {
458 IOReturn ret = kIOReturnBadArgument;
459 RootDomainUserClient * me = (typeof(me))target;
460 switch (arguments->selector) {
461 case kPMSetAggressiveness:
462 ret = me->secureSetAggressiveness(
463 (unsigned long)arguments->scalarInput[0],
464 (unsigned long)arguments->scalarInput[1],
465 (int *)&arguments->scalarOutput[0]);
466 break;
467
468 case kPMGetAggressiveness:
469 ret = me->fOwner->getAggressiveness(
470 (unsigned long)arguments->scalarInput[0],
471 (unsigned long *)&arguments->scalarOutput[0]);
472 break;
473
474 case kPMSleepSystem:
475 ret = me->secureSleepSystem(
476 (uint32_t *)&arguments->scalarOutput[0]);
477 break;
478
479 case kPMAllowPowerChange:
480 ret = me->fOwner->allowPowerChange(
481 arguments->scalarInput[0]);
482 break;
483
484 case kPMCancelPowerChange:
485 ret = me->fOwner->cancelPowerChange(
486 arguments->scalarInput[0]);
487 break;
488
489 case kPMShutdownSystem:
490 // deprecated interface
491 ret = kIOReturnUnsupported;
492 break;
493
494 case kPMRestartSystem:
495 // deprecated interface
496 ret = kIOReturnUnsupported;
497 break;
498
499 case kPMSleepSystemOptions:
500 ret = me->secureSleepSystemOptions(
501 arguments->structureInput,
502 arguments->structureInputSize,
503 (uint32_t *)&arguments->structureOutput);
504 break;
505 case kPMSetMaintenanceWakeCalendar:
506 ret = me->secureSetMaintenanceWakeCalendar(
507 (IOPMCalendarStruct *)arguments->structureInput,
508 (uint32_t *)&arguments->structureOutput);
509 arguments->structureOutputSize = sizeof(uint32_t);
510 break;
511
512 case kPMSetUserAssertionLevels:
513 ret = me->secureSetUserAssertionLevels(
514 (uint32_t)arguments->scalarInput[0]);
515 break;
516
517 case kPMActivityTickle:
518 if (me->fOwner->checkSystemCanSustainFullWake()) {
519 me->fOwner->reportUserInput();
520 me->fOwner->setProperty(kIOPMRootDomainWakeTypeKey, "UserActivity Assertion");
521 }
522 ret = kIOReturnSuccess;
523 break;
524
525 case kPMSetClamshellSleepState:
526 me->fOwner->setClamShellSleepDisable(arguments->scalarInput[0] ? true : false,
527 IOPMrootDomain::kClamshellSleepDisablePowerd);
528 ret = kIOReturnSuccess;
529 break;
530
531 case kPMGetSystemSleepType:
532 ret = me->secureGetSystemSleepType(
533 (uint32_t *) &arguments->scalarOutput[0],
534 (uint32_t *) &arguments->scalarOutput[1]);
535 break;
536
537 #if defined(__i386__) || defined(__x86_64__)
538 case kPMSleepWakeWatchdogEnable:
539 ret = clientHasPrivilege(me->fOwningTask, kIOClientPrivilegeAdministrator);
540 if (ret == kIOReturnSuccess) {
541 me->fOwner->sleepWakeDebugEnableWdog();
542 }
543 break;
544
545 case kPMSleepWakeDebugTrig:
546 ret = clientHasPrivilege(me->fOwningTask, kIOClientPrivilegeAdministrator);
547 if (ret == kIOReturnSuccess) {
548 me->fOwner->sleepWakeDebugTrig(false);
549 }
550 break;
551 #endif
552
553 case kPMSetDisplayPowerOn:
554 ret = clientHasPrivilege(me->fOwningTask, kIOClientPrivilegeAdministrator);
555 if (ret == kIOReturnSuccess) {
556 me->fOwner->setDisplayPowerOn((uint32_t)arguments->scalarInput[0]);
557 }
558 break;
559
560 case kPMRequestIdleSleepRevert:
561 ret = me->secureAttemptIdleSleepAbort(
562 (uint32_t *) &arguments->scalarOutput[0]);
563 break;
564
565 case kPMSetLDMHibernationDisable:
566 ret = me->secureSetLockdownModeHibernation((uint32_t)arguments->scalarInput[0]);
567 break;
568
569
570 default:
571 // bad selector
572 return kIOReturnBadArgument;
573 }
574
575 return ret;
576 }
577
578 /* getTargetAndMethodForIndex
579 * Not used. We prefer to use externalMethod() for user client invocations.
580 * We maintain getTargetAndExternalMethod since it's an exported symbol,
581 * and only for that reason.
582 */
583 IOExternalMethod *
getTargetAndMethodForIndex(IOService ** targetP,UInt32 index)584 RootDomainUserClient::getTargetAndMethodForIndex(
585 IOService ** targetP, UInt32 index )
586 {
587 // DO NOT EDIT
588 return super::getTargetAndMethodForIndex(targetP, index);
589 }
590
591 /* setPreventative
592 * Does nothing. Exists only for exported symbol compatibility.
593 */
594 void
setPreventative(UInt32 on_off,UInt32 types_of_sleep)595 RootDomainUserClient::setPreventative(UInt32 on_off, UInt32 types_of_sleep)
596 {
597 return;
598 } // DO NOT EDIT
599