1 /*
2 * Copyright (c) 2021 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 #define IOKIT_ENABLE_SHARED_PTR
30
31 #include <IOKit/IOLib.h>
32 #include <IOKit/IOReturn.h>
33
34 #include <libkern/c++/OSArray.h>
35 #include <libkern/c++/OSDictionary.h>
36 #include <libkern/c++/OSNumber.h>
37 #include <libkern/c++/OSString.h>
38 #include <libkern/c++/OSSymbol.h>
39 #include <libkern/c++/OSUnserialize.h>
40 #include <libkern/c++/OSSharedPtr.h>
41 #include <libkern/c++/OSSerialize.h>
42
43 #include <sys/work_interval.h>
44 #include <sys/param.h>
45
46 #include <kern/thread_group.h>
47 #include <kern/work_interval.h>
48 #include <kern/workload_config.h>
49
50 #if DEVELOPMENT || DEBUG
51 #define WLC_LOG(fmt, args...) IOLog("WorkloadConfig: " fmt, ##args)
52 #else
53 #define WLC_LOG(fmt, args...)
54 #endif
55
56 /* Limit criticality offsets. */
57 #define MAX_CRITICALITY_OFFSET 16
58
59
60 /* Plist keys/values. */
61 #define kWorkloadIDTableKey "WorkloadIDTable"
62 #define kRootKey "Root"
63 #define kPhasesKey "Phases"
64 #define kWorkIntervalTypeKey "WorkIntervalType"
65 #define kWorkloadClassKey "WorkloadClass"
66 #define kCriticalityOffsetKey "CriticalityOffset"
67 #define kDefaultPhaseKey "DefaultPhase"
68 #define kFlagsKey "Flags"
69 #define kWorkloadIDConfigurationFlagsKey "WorkloadIDConfigurationFlags"
70
71 #define kDisableWorkloadClassThreadPolicyValue "DisableWorkloadClassThreadPolicy"
72 #define kWIComplexityAllowedValue "ComplexityAllowed"
73 #if defined(XNU_TARGET_OS_XR)
74 #if defined(CONFIG_THREAD_GROUPS)
75 #define kUXMValue "UXM"
76 #define kStrictTimersValue "StrictTimers"
77 #endif /* CONFIG_THREAD_GROUPS */
78 #endif /* XNU_TARGET_OS_XR */
79
80 #define ARRAY_LEN(x) (sizeof (x) / sizeof (x[0]))
81
82 #if !CONFIG_THREAD_GROUPS
83 #define THREAD_GROUP_FLAGS_EFFICIENT 0
84 #define THREAD_GROUP_FLAGS_APPLICATION 0
85 #define THREAD_GROUP_FLAGS_CRITICAL 0
86 #define THREAD_GROUP_FLAGS_BEST_EFFORT 0
87 #define THREAD_GROUP_FLAGS_ABSENT 0
88 #endif /* CONFIG_THREAD_GROUPS */
89
90 /* BEGIN IGNORE CODESTYLE */
91 static const struct WorkloadClassData {
92 const char *name;
93 UInt32 workIntervalFlags;
94 UInt32 threadGroupFlags;
95 } wlClassData[] = {
96 [WI_CLASS_NONE] =
97 {
98 .name = "NONE",
99 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
100 .threadGroupFlags = THREAD_GROUP_FLAGS_ABSENT,
101 },
102 [WI_CLASS_DISCRETIONARY] =
103 {
104 .name = "DISCRETIONARY",
105 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
106 .threadGroupFlags = THREAD_GROUP_FLAGS_EFFICIENT,
107 },
108 [WI_CLASS_BEST_EFFORT] =
109 {
110 .name = "BEST_EFFORT",
111 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
112 .threadGroupFlags = THREAD_GROUP_FLAGS_BEST_EFFORT,
113 },
114 [WI_CLASS_APP_SUPPORT] =
115 {
116 .name = "APPLICATION_SUPPORT",
117 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
118 .threadGroupFlags = 0,
119 },
120 [WI_CLASS_APPLICATION] =
121 {
122 .name = "APPLICATION",
123 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
124 .threadGroupFlags = THREAD_GROUP_FLAGS_APPLICATION,
125 },
126 [WI_CLASS_SYSTEM] =
127 {
128 .name = "SYSTEM",
129 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
130 .threadGroupFlags = 0,
131 },
132 [WI_CLASS_SYSTEM_CRITICAL] =
133 {
134 .name = "SYSTEM_CRITICAL",
135 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID,
136 .threadGroupFlags = THREAD_GROUP_FLAGS_CRITICAL,
137 },
138 [WI_CLASS_REALTIME] =
139 {
140 .name = "REALTIME",
141 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID |
142 WORK_INTERVAL_WORKLOAD_ID_RT_ALLOWED,
143 .threadGroupFlags = 0,
144 },
145 [WI_CLASS_REALTIME_CRITICAL] =
146 {
147 .name = "REALTIME_CRITICAL",
148 .workIntervalFlags = WORK_INTERVAL_WORKLOAD_ID_HAS_ID |
149 WORK_INTERVAL_WORKLOAD_ID_RT_ALLOWED |
150 WORK_INTERVAL_WORKLOAD_ID_RT_CRITICAL,
151 .threadGroupFlags = THREAD_GROUP_FLAGS_CRITICAL,
152 },
153 };
154 /* END IGNORE CODESTYLE */
155
156 struct FlagMap {
157 const char *str;
158 UInt32 flags;
159 };
160
161 static inline IOReturn
stringToFlags(const OSString & str,UInt32 & flags,const struct FlagMap * map,size_t mapLen)162 stringToFlags(const OSString &str, UInt32 &flags, const struct FlagMap *map,
163 size_t mapLen)
164 {
165 for (size_t i = 0; i < mapLen; i++) {
166 if (str.isEqualTo(map[i].str)) {
167 flags = map[i].flags;
168 return kIOReturnSuccess;
169 }
170 }
171
172 return kIOReturnNotFound;
173 }
174
175 static inline IOReturn
flagsToString(const UInt32 flags,OSSharedPtr<OSString> & str,const struct FlagMap * map,size_t mapLen)176 flagsToString(const UInt32 flags, OSSharedPtr<OSString> &str, const struct FlagMap *map,
177 size_t mapLen)
178 {
179 for (size_t i = 0; i < mapLen; i++) {
180 if (flags == map[i].flags) {
181 str = OSString::withCStringNoCopy(map[i].str);
182 return kIOReturnSuccess;
183 }
184 }
185
186 return kIOReturnNotFound;
187 }
188
189 /* BEGIN IGNORE CODESTYLE */
190 static const struct FlagMap typeMap[] = {
191 {
192 .str = "DEFAULT",
193 .flags = WORK_INTERVAL_TYPE_DEFAULT |
194 WORK_INTERVAL_FLAG_UNRESTRICTED,
195 },
196 {
197 .str = "COREAUDIO",
198 .flags = WORK_INTERVAL_TYPE_COREAUDIO |
199 WORK_INTERVAL_FLAG_ENABLE_AUTO_JOIN |
200 WORK_INTERVAL_FLAG_ENABLE_DEFERRED_FINISH,
201 },
202 {
203 .str = "COREANIMATION",
204 .flags = WORK_INTERVAL_TYPE_COREANIMATION,
205 },
206 {
207 .str = "CA_RENDER_SERVER",
208 .flags = WORK_INTERVAL_TYPE_CA_RENDER_SERVER,
209 },
210 {
211 .str = "FRAME_COMPOSITOR",
212 .flags = WORK_INTERVAL_TYPE_FRAME_COMPOSITOR,
213 },
214 {
215 .str = "CA_CLIENT",
216 .flags = WORK_INTERVAL_TYPE_CA_CLIENT |
217 WORK_INTERVAL_FLAG_UNRESTRICTED,
218 },
219 {
220 .str = "HID_DELIVERY",
221 .flags = WORK_INTERVAL_TYPE_HID_DELIVERY,
222 },
223 {
224 .str = "COREMEDIA",
225 .flags = WORK_INTERVAL_TYPE_COREMEDIA,
226 },
227 {
228 .str = "ARKIT",
229 .flags = WORK_INTERVAL_TYPE_ARKIT |
230 WORK_INTERVAL_FLAG_FINISH_AT_DEADLINE,
231 },
232 {
233 .str = "AUDIO_CLIENT",
234 .flags = WORK_INTERVAL_TYPE_COREAUDIO |
235 WORK_INTERVAL_FLAG_UNRESTRICTED |
236 WORK_INTERVAL_FLAG_ENABLE_AUTO_JOIN |
237 WORK_INTERVAL_FLAG_ENABLE_DEFERRED_FINISH
238 },
239 };
240 /* END IGNORE CODESTYLE */
241
242 static IOReturn
unparseWorkIntervalType(const UInt32 createFlags,OSSharedPtr<OSString> & typeStr)243 unparseWorkIntervalType(const UInt32 createFlags, OSSharedPtr<OSString> &typeStr)
244 {
245 IOReturn ret = flagsToString(createFlags, typeStr, typeMap,
246 ARRAY_LEN(typeMap));
247 if (ret != kIOReturnSuccess) {
248 WLC_LOG("unrecognised create flags: 0x%x\n", createFlags);
249 }
250
251 return ret;
252 }
253
254 static IOReturn
parseWorkIntervalType(const OSSymbol & id,const OSObject * typeObj,UInt32 & createFlags)255 parseWorkIntervalType(const OSSymbol &id, const OSObject *typeObj, UInt32 &createFlags)
256 {
257 OSSharedPtr<OSString> defaultIntervalType = OSString::withCString("DEFAULT");
258
259 const OSString *typeStr = OSDynamicCast(OSString, typeObj);
260 if (typeStr == nullptr) {
261 typeStr = defaultIntervalType.get();
262 }
263
264 IOReturn ret = stringToFlags(*typeStr, createFlags, typeMap,
265 ARRAY_LEN(typeMap));
266 if (ret != kIOReturnSuccess) {
267 WLC_LOG("unrecognised \"" kWorkIntervalTypeKey "\": \"%s\"\n",
268 typeStr->getCStringNoCopy());
269 }
270
271 return ret;
272 }
273
274 static IOReturn
parseWorkloadClass(const OSSymbol & id,const OSObject * wlClassObj,wi_class_t & wiClass)275 parseWorkloadClass(const OSSymbol &id, const OSObject *wlClassObj, wi_class_t &wiClass)
276 {
277 const OSString *wlClass = OSDynamicCast(OSString, wlClassObj);
278 if (wlClass == nullptr) {
279 wiClass = WI_CLASS_NONE;
280 return kIOReturnSuccess;
281 }
282
283 for (size_t i = 0; i < ARRAY_LEN(wlClassData); i++) {
284 if (wlClassData[i].name != nullptr &&
285 wlClass->isEqualTo(wlClassData[i].name)) {
286 wiClass = (wi_class_t)i;
287 return kIOReturnSuccess;
288 }
289 }
290
291 WLC_LOG("%s: unknown %s: \"%s\"\n", id.getCStringNoCopy(),
292 kWorkloadClassKey, wlClass->getCStringNoCopy());
293 return kIOReturnError;
294 }
295
296 static IOReturn
parseCriticalityOffset(const OSSymbol & id,const wi_class_t wiClass,const OSObject * cOffsetObj,uint8_t & criticalityOffset)297 parseCriticalityOffset(const OSSymbol &id, const wi_class_t wiClass,
298 const OSObject *cOffsetObj, uint8_t &criticalityOffset)
299 {
300 if (wiClass != WI_CLASS_SYSTEM_CRITICAL &&
301 wiClass != WI_CLASS_REALTIME_CRITICAL &&
302 wiClass != WI_CLASS_BEST_EFFORT &&
303 wiClass != WI_CLASS_APP_SUPPORT &&
304 wiClass != WI_CLASS_SYSTEM) {
305 criticalityOffset = 0;
306 return kIOReturnSuccess;
307 }
308
309 const OSNumber *cOffset = OSDynamicCast(OSNumber, cOffsetObj);
310 if (cOffset == nullptr) {
311 criticalityOffset = 0;
312 return kIOReturnSuccess;
313 }
314
315 UInt64 criticalityOffset64 = cOffset->unsigned64BitValue();
316 const int nBytes = cOffset->numberOfBytes();
317 if (nBytes <= sizeof(criticalityOffset64) &&
318 criticalityOffset64 < MAX_CRITICALITY_OFFSET) {
319 criticalityOffset = (uint8_t)criticalityOffset64;
320 return kIOReturnSuccess;
321 }
322
323 WLC_LOG("%s: criticality offset too large\n", id.getCStringNoCopy());
324 return kIOReturnError;
325 }
326
327 static IOReturn
parseFlags(const OSSymbol & id,const OSObject * flagsObj,UInt32 & threadGroupFlags,UInt32 & workIntervalFlags)328 parseFlags(const OSSymbol &id, const OSObject *flagsObj, UInt32 &threadGroupFlags,
329 UInt32 &workIntervalFlags)
330 {
331 /* Optional, so just carry on if not found. */
332 if (flagsObj == nullptr) {
333 return kIOReturnSuccess;
334 }
335
336 OSArray *flags = OSDynamicCast(OSArray, flagsObj);
337 if (flags == nullptr) {
338 WLC_LOG("failed to parse \"" kFlagsKey "\"\n");
339 return kIOReturnError;
340 }
341
342 /* BEGIN IGNORE CODESTYLE */
343 __block IOReturn ret = kIOReturnSuccess;
344 flags->iterateObjects(^bool (OSObject *object) {
345 const OSString *flag = OSDynamicCast(OSString, object);
346 if (flag == nullptr) {
347 WLC_LOG("%s: non-string flag found\n", id.getCStringNoCopy());
348 ret = kIOReturnError;
349 return true;
350
351 }
352
353 /* Ignore unknown flags. */
354 #if defined(XNU_TARGET_OS_XR)
355 #if CONFIG_THREAD_GROUPS
356 if (flag->isEqualTo(kUXMValue)) {
357 threadGroupFlags |= THREAD_GROUP_FLAGS_MANAGED;
358 }
359 if (flag->isEqualTo(kStrictTimersValue)) {
360 threadGroupFlags |= THREAD_GROUP_FLAGS_STRICT_TIMERS;
361 }
362 #endif /* CONFIG_THREAD_GROUPS */
363 #endif /* XNU_TARGET_OS_XR */
364 if (flag->isEqualTo(kWIComplexityAllowedValue)) {
365 workIntervalFlags |= WORK_INTERVAL_WORKLOAD_ID_COMPLEXITY_ALLOWED;
366 }
367
368 return false;
369 });
370 /* END IGNORE CODESTYLE */
371
372 return ret;
373 }
374
375 static
376 IOReturn
parsePhases(workload_config_ctx_t * ctx,const OSSymbol & id,OSObject * phasesObj)377 parsePhases(workload_config_ctx_t *ctx, const OSSymbol &id, OSObject *phasesObj)
378 {
379 __block IOReturn ret = kIOReturnError;
380
381 OSDictionary *phases = OSDynamicCast(OSDictionary, phasesObj);
382 if (phases == nullptr) {
383 WLC_LOG("%s: failed to find dictionary for \"" kPhasesKey "\"\n",
384 id.getCStringNoCopy());
385 return kIOReturnError;
386 }
387
388 /* There should be at least one phase described. */
389 ret = kIOReturnError;
390
391 /* BEGIN IGNORE CODESTYLE */
392 phases->iterateObjects(^bool (const OSSymbol *phase, OSObject *value) {
393 const OSDictionary *dict = OSDynamicCast(OSDictionary, value);
394 if (dict == nullptr) {
395 WLC_LOG("%s: failed to find dictionary for \"%s\" phase\n",
396 id.getCStringNoCopy(), phase->getCStringNoCopy());
397 ret = kIOReturnError;
398 return true;
399 }
400
401 UInt32 createFlags = 0;
402 ret = parseWorkIntervalType(id, dict->getObject(kWorkIntervalTypeKey),
403 createFlags);
404 if (ret != kIOReturnSuccess) {
405 return true;
406 }
407
408 wi_class_t wiClass = WI_CLASS_NONE;
409 ret = parseWorkloadClass(id, dict->getObject(kWorkloadClassKey), wiClass);
410 if (ret != kIOReturnSuccess) {
411 return true;
412 }
413 const struct WorkloadClassData classData = wlClassData[wiClass];
414
415 uint8_t criticalityOffset = 0;
416 ret = parseCriticalityOffset(id, wiClass,
417 dict->getObject(kCriticalityOffsetKey), criticalityOffset);
418 if (ret != kIOReturnSuccess) {
419 return true;
420 }
421
422 UInt32 threadGroupFlags = classData.threadGroupFlags;
423 UInt32 workIntervalFlags = classData.workIntervalFlags;
424 ret = parseFlags(id, dict->getObject(kFlagsKey), threadGroupFlags, workIntervalFlags);
425 if (ret != kIOReturnSuccess) {
426 return true;
427 }
428
429 const workload_config_t config = {
430 .wc_thread_group_flags = threadGroupFlags,
431 .wc_flags = workIntervalFlags,
432 .wc_create_flags = createFlags,
433 .wc_class_offset = (uint8_t)criticalityOffset,
434 .wc_class = wiClass,
435 };
436 ret = workload_config_insert(ctx, id.getCStringNoCopy(), phase->getCStringNoCopy(), &config);
437 if (ret != kIOReturnSuccess) {
438 WLC_LOG("%s: failed to add \"%s\" phase\n",
439 id.getCStringNoCopy(), phase->getCStringNoCopy());
440 return true;
441 }
442
443 return false;
444 });
445 /* END IGNORE CODESTYLE */
446
447 return ret;
448 }
449
450 static IOReturn
parseRoot(const OSSymbol & id,const OSObject * rootDict,OSString * & defaultPhase)451 parseRoot(const OSSymbol &id, const OSObject *rootDict, OSString *&defaultPhase)
452 {
453 const OSDictionary *root = OSDynamicCast(OSDictionary, rootDict);
454 if (root == nullptr) {
455 WLC_LOG("%s: failed to find dictionary for \"" kRootKey "\"\n",
456 id.getCStringNoCopy());
457 return kIOReturnError;
458 }
459
460 defaultPhase = OSDynamicCast(OSString, root->getObject(kDefaultPhaseKey));
461 if (defaultPhase == nullptr) {
462 WLC_LOG("%s: failed to find \"" kDefaultPhaseKey"\" in \"" kRootKey "\" dictionary\n",
463 id.getCStringNoCopy());
464 return kIOReturnError;
465 }
466
467 if (defaultPhase->getLength() == 0) {
468 WLC_LOG("%s: \"" kDefaultPhaseKey" \" is empty in \"" kRootKey "\" dictionary\n",
469 id.getCStringNoCopy());
470 return kIOReturnError;
471 }
472
473 return kIOReturnSuccess;
474 }
475
476 static IOReturn
parseWorkloadIDTable(workload_config_ctx_t * ctx,OSDictionary * IDTable)477 parseWorkloadIDTable(workload_config_ctx_t *ctx, OSDictionary *IDTable)
478 {
479 /*
480 * At least one valid entry is expected, so start off with error to
481 * catch an empty table or one with no valid entries.
482 */
483 __block IOReturn ret = kIOReturnError;
484
485 /* BEGIN IGNORE CODESTYLE */
486 IDTable->iterateObjects(^bool (const OSSymbol *id, OSObject *value) {
487 /* Validate the workload ID. */
488 if (id->getLength() == 0) {
489 WLC_LOG("zero length ID in \"" kWorkloadIDTableKey "\"\n");
490 ret = kIOReturnError;
491 return true;
492 }
493
494 /* Parse its properties. */
495 OSDictionary *idConfig = OSDynamicCast(OSDictionary, value);
496 if (idConfig == nullptr) {
497 WLC_LOG("failed to find dictionary for \"%s\"\n",
498 id->getCStringNoCopy());
499 ret = kIOReturnError;
500 return true;
501 }
502
503 ret = parsePhases(ctx, *id, idConfig->getObject(kPhasesKey));
504 if (ret != kIOReturnSuccess) {
505 return true;
506 }
507
508 OSString *defaultPhase = nullptr;
509 ret = parseRoot(*id, idConfig->getObject(kRootKey), defaultPhase);
510 if (ret != kIOReturnSuccess) {
511 return true;
512 }
513
514 /* Fails if the specified phase doesn't exist.. */
515 ret = workload_config_set_default(ctx, id->getCStringNoCopy(),
516 defaultPhase->getCStringNoCopy());
517 if (ret != kIOReturnSuccess) {
518 WLC_LOG("failed to set default phase (%s) for \"%s\"\n",
519 defaultPhase->getCStringNoCopy(), id->getCStringNoCopy());
520 return true;
521 }
522
523 return false;
524 });
525 /* END IGNORE CODESTYLE */
526
527 return ret;
528 }
529
530 static IOReturn
parseWorkloadIDConfigurationFlags(workload_config_ctx_t * ctx,const OSObject * idTableFlagsObj)531 parseWorkloadIDConfigurationFlags(workload_config_ctx_t *ctx, const OSObject *idTableFlagsObj)
532 {
533 /* Optional, so just carry on if not found. */
534 if (idTableFlagsObj == nullptr) {
535 return kIOReturnSuccess;
536 }
537
538 OSArray *idTableFlags = OSDynamicCast(OSArray, idTableFlagsObj);
539 if (idTableFlags == nullptr) {
540 WLC_LOG("failed to parse \""
541 kWorkloadIDConfigurationFlagsKey "\"\n");
542 return kIOReturnError;
543 }
544
545 /* BEGIN IGNORE CODESTYLE */
546 __block IOReturn ret = kIOReturnSuccess;
547 idTableFlags->iterateObjects(^bool (OSObject *object) {
548 const OSString *flag = OSDynamicCast(OSString, object);
549 if (flag == nullptr) {
550 WLC_LOG("non-string Workload ID Table flag found\n");
551 ret = kIOReturnError;
552 return true;
553 }
554
555 if (flag->isEqualTo(kDisableWorkloadClassThreadPolicyValue)) {
556 workload_config_clear_flag(ctx, WLC_F_THREAD_POLICY);
557 }
558
559 return false;
560 });
561 /* END IGNORE CODESTYLE */
562
563 return ret;
564 }
565
566 static IOReturn
unparseWorkloadIDConfigurationFlags(OSSharedPtr<OSDictionary> & plist)567 unparseWorkloadIDConfigurationFlags(OSSharedPtr<OSDictionary> &plist)
568 {
569 workload_config_flags_t flags = WLC_F_NONE;
570
571 /* There may be no config at all. That's ok. */
572 if (workload_config_get_flags(&flags) != KERN_SUCCESS) {
573 return kIOReturnSuccess;
574 }
575
576 /* Workload config can change thread policy scheduling - the default. */
577 if ((flags & WLC_F_THREAD_POLICY) != 0) {
578 return kIOReturnSuccess;
579 }
580
581 OSSharedPtr<OSArray> idTableFlags = OSArray::withCapacity(1);
582 OSSharedPtr<OSString> flag = OSString::withCString(kDisableWorkloadClassThreadPolicyValue);
583 if (!idTableFlags->setObject(flag) ||
584 !plist->setObject(kWorkloadIDConfigurationFlagsKey, idTableFlags)) {
585 return kIOReturnError;
586 }
587
588 return kIOReturnSuccess;
589 }
590
591 extern "C" {
592 extern IOReturn IOParseWorkloadConfig(workload_config_ctx_t *, const char *, size_t);
593 extern IOReturn IOUnparseWorkloadConfig(char *, size_t *);
594 }
595
596 /* Called locked. */
597 IOReturn
IOParseWorkloadConfig(workload_config_ctx_t * ctx,const char * buffer,size_t size)598 IOParseWorkloadConfig(workload_config_ctx_t *ctx, const char *buffer, size_t size)
599 {
600 IOReturn ret = kIOReturnError;
601
602 OSSharedPtr<OSString> unserializeErrorString = nullptr;
603 OSSharedPtr<OSObject> obj = nullptr;
604 OSDictionary *idTable = nullptr;
605 OSDictionary *dict = nullptr;
606
607 ret = workload_config_init(ctx);
608 if (ret != kIOReturnSuccess) {
609 WLC_LOG("failed to initialize workload configuration\n");
610 goto out;
611 }
612
613 obj = OSUnserializeXML(buffer, unserializeErrorString);
614 dict = OSDynamicCast(OSDictionary, obj.get());
615 if (dict == nullptr) {
616 WLC_LOG("failed to unserialize plist\n");
617 ret = kIOReturnError;
618 goto out;
619 }
620
621 idTable = OSDynamicCast(OSDictionary, dict->getObject(kWorkloadIDTableKey));
622 if (idTable == nullptr) {
623 WLC_LOG("failed to find " kWorkloadIDTableKey "\n");
624 ret = kIOReturnError;
625 goto out;
626 }
627
628 ret = parseWorkloadIDTable(ctx, idTable);
629 if (ret != kIOReturnSuccess) {
630 goto out;
631 }
632
633 ret = parseWorkloadIDConfigurationFlags(ctx, dict->getObject(kWorkloadIDConfigurationFlagsKey));
634 if (ret != kIOReturnSuccess) {
635 goto out;
636 }
637
638 ret = kIOReturnSuccess;
639
640 out:
641 if (ret != kIOReturnSuccess) {
642 workload_config_free(ctx);
643 }
644
645 return ret;
646 }
647
648 /*
649 * Does the reverse of IOParseWorkloadConfig() - i.e. serializes the internal
650 * workload configuration.
651 * The serialized workload config is copied to 'buffer' (if non-NULL).
652 * size is in/out - it describes the size of buffer and on return the length of
653 * the serialized config.
654 */
655 IOReturn
IOUnparseWorkloadConfig(char * buffer,size_t * size)656 IOUnparseWorkloadConfig(char *buffer, size_t *size)
657 {
658 assert(size != nullptr);
659
660 OSSharedPtr<OSDictionary> dict = nullptr;;
661 OSSharedPtr<OSDictionary> idTable = nullptr;
662 OSSharedPtr<OSSerialize> serialize = nullptr;
663
664 serialize = OSSerialize::withCapacity(1);
665 if (serialize == nullptr) {
666 return kIOReturnNoMemory;
667 }
668
669 dict = OSDictionary::withCapacity(1);
670 if (dict == nullptr) {
671 return kIOReturnNoMemory;
672 }
673
674 idTable = OSDictionary::withCapacity(1);
675 if (idTable == nullptr) {
676 return kIOReturnNoMemory;
677 }
678
679 __block IOReturn ret = kIOReturnSuccess;
680 /* BEGIN IGNORE CODESTYLE */
681 workload_config_iterate(^(const char *id_str, const void *config) {
682 OSSharedPtr<OSDictionary> idDict = OSDictionary::withCapacity(1);
683 if (idDict == nullptr) {
684 ret = kIOReturnNoMemory;
685 return true;
686 }
687
688 OSSharedPtr<OSDictionary> phase = OSDictionary::withCapacity(1);
689 if (phase == nullptr) {
690 ret = kIOReturnNoMemory;
691 return true;
692 }
693
694 workload_config_phases_iterate(config, ^(const char *phase_str,
695 const bool is_default, const workload_config_t *wc) {
696 OSSharedPtr<OSDictionary> phaseData = OSDictionary::withCapacity(1);
697 if (phaseData == nullptr) {
698 ret = kIOReturnNoMemory;
699 return true;
700 }
701
702 if (wc->wc_class != WI_CLASS_NONE) {
703 assert3u(wc->wc_class, <, WI_CLASS_COUNT);
704 OSSharedPtr<OSString> wClass = OSString::withCString(wlClassData[wc->wc_class].name);
705 if (wClass == nullptr || !phaseData->setObject(kWorkloadClassKey, wClass)) {
706 ret = kIOReturnError;
707 return true;
708 }
709 }
710
711 if (wc->wc_class_offset > 0) {
712 OSSharedPtr<OSNumber> criticalityOffset = OSNumber::withNumber(wc->wc_class_offset, 8);
713 if (criticalityOffset == nullptr ||
714 !phaseData->setObject(kCriticalityOffsetKey, criticalityOffset)) {
715 ret = kIOReturnError;
716 return true;
717 }
718 }
719
720 OSSharedPtr<OSString> type = nullptr;
721 if (unparseWorkIntervalType(wc->wc_create_flags, type) != kIOReturnSuccess ||
722 !phaseData->setObject(kWorkIntervalTypeKey, type)) {
723 ret = kIOReturnError;
724 return true;
725 }
726
727
728 OSSharedPtr<OSArray> flags = OSArray::withCapacity(2);
729 if (flags == nullptr) {
730 ret = kIOReturnError;
731 return true;
732 }
733 #if defined(XNU_TARGET_OS_XR)
734 #if CONFIG_THREAD_GROUPS
735 if ((wc->wc_thread_group_flags & THREAD_GROUP_FLAGS_MANAGED) != 0) {
736 OSSharedPtr<OSString> UXMStr = OSString::withCString(kUXMValue);
737 if (UXMStr == nullptr || !flags->setObject(UXMStr)) {
738 ret = kIOReturnError;
739 return true;
740 }
741 }
742 if ((wc->wc_thread_group_flags & THREAD_GROUP_FLAGS_STRICT_TIMERS) != 0) {
743 OSSharedPtr<OSString> StrictTimersStr = OSString::withCString(kStrictTimersValue);
744 if (StrictTimersStr == nullptr || !flags->setObject(StrictTimersStr)) {
745 ret = kIOReturnError;
746 return true;
747 }
748 }
749 #endif /* CONFIG_THREAD_GROUPS */
750 #endif /* XNU_TARGET_OS_XR */
751 if ((wc->wc_flags & WORK_INTERVAL_WORKLOAD_ID_COMPLEXITY_ALLOWED) != 0) {
752 OSSharedPtr<OSString> WIComplexityAllowedStr =
753 OSString::withCString(kWIComplexityAllowedValue);
754 if (WIComplexityAllowedStr == nullptr || !flags->setObject(WIComplexityAllowedStr)) {
755 ret = kIOReturnError;
756 return true;
757 }
758 }
759 if (flags->getCount() && !phaseData->setObject(kFlagsKey, flags)) {
760 ret = kIOReturnError;
761 return true;
762 }
763
764 if (!phase->setObject(phase_str, phaseData)) {
765 ret = kIOReturnError;
766 return true;
767 }
768
769 if (is_default) {
770 OSSharedPtr<OSDictionary> root = OSDictionary::withCapacity(1);
771 OSSharedPtr<OSString> phaseStr = OSString::withCString(phase_str);
772
773 if (root == nullptr || phaseStr == nullptr ||
774 !root->setObject(kDefaultPhaseKey, phaseStr)) {
775 ret = kIOReturnError;
776 return true;
777 }
778
779 if (!idDict->setObject(kRootKey, root)) {
780 ret = kIOReturnError;
781 return true;
782 }
783 }
784
785 return false;
786
787 });
788
789 if (ret != kIOReturnSuccess) {
790 return true;
791 }
792
793 if (!idDict->setObject(kPhasesKey, phase)) {
794 ret = kIOReturnError;
795 return true;
796 }
797
798 if (!idTable->setObject(id_str, idDict)) {
799 ret = kIOReturnError;
800 return true;
801 }
802
803 return false;
804 });
805 /* END IGNORE CODESTYLE */
806
807 if (ret != kIOReturnSuccess) {
808 return ret;
809 }
810
811 OSSharedPtr<OSDictionary> plist = OSDictionary::withCapacity(1);
812 if (plist == nullptr) {
813 return kIOReturnError;
814 }
815
816 if (idTable->getCount() > 0 &&
817 !plist->setObject(kWorkloadIDTableKey, idTable)) {
818 return kIOReturnError;
819 }
820
821 if (unparseWorkloadIDConfigurationFlags(plist) != kIOReturnSuccess) {
822 return kIOReturnError;
823 }
824
825 if (!plist->serialize(serialize.get())) {
826 return kIOReturnError;
827 }
828
829 if (buffer != nullptr) {
830 (void) strlcpy(buffer, serialize->text(), *size);
831 }
832 *size = serialize->getLength();
833
834 return kIOReturnSuccess;
835 }
836