1 | /* |
2 | * Copyright (c) 2000-2016 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 | /* OSMetaClass.cpp created by gvdl on Fri 1998-11-17 */ |
29 | |
30 | #include <string.h> |
31 | |
32 | #include <libkern/OSReturn.h> |
33 | |
34 | #include <libkern/c++/OSMetaClass.h> |
35 | #include <libkern/c++/OSObject.h> |
36 | #include <libkern/c++/OSKext.h> |
37 | |
38 | #include <libkern/c++/OSCollectionIterator.h> |
39 | #include <libkern/c++/OSDictionary.h> |
40 | #include <libkern/c++/OSArray.h> |
41 | #include <libkern/c++/OSSet.h> |
42 | #include <libkern/c++/OSSymbol.h> |
43 | #include <libkern/c++/OSNumber.h> |
44 | #include <libkern/c++/OSSerialize.h> |
45 | |
46 | #include <libkern/c++/OSLib.h> |
47 | #include <libkern/OSAtomic.h> |
48 | |
49 | #include <IOKit/IOLib.h> |
50 | |
51 | #include <IOKit/IOKitDebug.h> |
52 | |
53 | |
54 | __BEGIN_DECLS |
55 | |
56 | #include <sys/systm.h> |
57 | #include <mach/mach_types.h> |
58 | #include <kern/locks.h> |
59 | #include <kern/clock.h> |
60 | #include <kern/thread_call.h> |
61 | #include <kern/host.h> |
62 | #include <mach/mach_interface.h> |
63 | |
64 | #if PRAGMA_MARK |
65 | #pragma mark Macros |
66 | #endif /* PRAGMA_MARK */ |
67 | /********************************************************************* |
68 | * Macros |
69 | *********************************************************************/ |
70 | __END_DECLS |
71 | |
72 | #if PRAGMA_MARK |
73 | #pragma mark Internal constants & data structs |
74 | #endif /* PRAGMA_MARK */ |
75 | /********************************************************************* |
76 | * Internal constants & data structs |
77 | *********************************************************************/ |
78 | OSKextLogSpec kOSMetaClassLogSpec = |
79 | kOSKextLogErrorLevel | |
80 | kOSKextLogLoadFlag | |
81 | kOSKextLogKextBookkeepingFlag; |
82 | |
83 | static enum { |
84 | kCompletedBootstrap = 0, |
85 | kNoDictionaries = 1, |
86 | kMakingDictionaries = 2 |
87 | } sBootstrapState = kNoDictionaries; |
88 | |
89 | static const int kClassCapacityIncrement = 40; |
90 | static const int kKModCapacityIncrement = 10; |
91 | static OSDictionary * sAllClassesDict; |
92 | static unsigned int sDeepestClass; |
93 | IOLock * sAllClassesLock = NULL; |
94 | IOLock * sInstancesLock = NULL; |
95 | |
96 | /* |
97 | * While loading a kext and running all its constructors to register |
98 | * all OSMetaClass classes, the classes are queued up here. Only one |
99 | * kext can be in flight at a time, guarded by sStalledClassesLock |
100 | */ |
101 | static struct StalledData { |
102 | const char * kextIdentifier; |
103 | OSReturn result; |
104 | unsigned int capacity; |
105 | unsigned int count; |
106 | OSMetaClass ** classes; |
107 | } * sStalled; |
108 | IOLock * sStalledClassesLock = NULL; |
109 | |
110 | struct ExpansionData { |
111 | OSOrderedSet * instances; |
112 | OSKext * kext; |
113 | uint32_t retain; |
114 | #if IOTRACKING |
115 | IOTrackingQueue * tracking; |
116 | #endif |
117 | }; |
118 | |
119 | |
120 | #if PRAGMA_MARK |
121 | #pragma mark OSMetaClassBase |
122 | #endif /* PRAGMA_MARK */ |
123 | /********************************************************************* |
124 | * OSMetaClassBase. |
125 | *********************************************************************/ |
126 | |
127 | #if APPLE_KEXT_VTABLE_PADDING |
128 | /********************************************************************* |
129 | * Reserved vtable functions. |
130 | *********************************************************************/ |
131 | #if SLOT_USED |
132 | void OSMetaClassBase::_RESERVEDOSMetaClassBase0() |
133 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 0); } |
134 | void OSMetaClassBase::_RESERVEDOSMetaClassBase1() |
135 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 1); } |
136 | void OSMetaClassBase::_RESERVEDOSMetaClassBase2() |
137 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 2); } |
138 | #endif /* SLOT_USED */ |
139 | |
140 | // As these slots are used move them up inside the #if above |
141 | void OSMetaClassBase::_RESERVEDOSMetaClassBase3() |
142 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 3); } |
143 | void OSMetaClassBase::_RESERVEDOSMetaClassBase4() |
144 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 4); } |
145 | void OSMetaClassBase::_RESERVEDOSMetaClassBase5() |
146 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 5); } |
147 | void OSMetaClassBase::_RESERVEDOSMetaClassBase6() |
148 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 6); } |
149 | #endif |
150 | |
151 | |
152 | /********************************************************************* |
153 | *********************************************************************/ |
154 | |
155 | #if defined(__arm__) || defined(__arm64__) |
156 | |
157 | |
158 | |
159 | /* |
160 | IHI0059A "C++ Application Binary Interface Standard for the ARM 64 - bit Architecture": |
161 | |
162 | 3.2.1 Representation of pointer to member function The generic C++ ABI [GC++ABI] |
163 | specifies that a pointer to member function is a pair of words <ptr, adj>. The |
164 | least significant bit of ptr discriminates between (0) the address of a non- |
165 | virtual member function and (1) the offset in the class's virtual table of the |
166 | address of a virtual function. This encoding cannot work for the AArch64 |
167 | instruction set where the architecture reserves all bits of code addresses. This |
168 | ABI specifies that adj contains twice the this adjustment, plus 1 if the member |
169 | function is virtual. The least significant bit of adj then makes exactly the |
170 | same discrimination as the least significant bit of ptr does for Itanium. A |
171 | pointer to member function is NULL when ptr = 0 and the least significant bit of |
172 | adj is zero. |
173 | */ |
174 | |
175 | OSMetaClassBase::_ptf_t |
176 | OSMetaClassBase::_ptmf2ptf(const OSMetaClassBase *self, void (OSMetaClassBase::*func)(void)) |
177 | { |
178 | typedef long int ptrdiff_t; |
179 | struct ptmf_t { |
180 | _ptf_t fPFN; |
181 | ptrdiff_t delta; |
182 | }; |
183 | union { |
184 | void (OSMetaClassBase::*fIn)(void); |
185 | struct ptmf_t pTMF; |
186 | } map; |
187 | _ptf_t pfn; |
188 | |
189 | map.fIn = func; |
190 | pfn = map.pTMF.fPFN; |
191 | |
192 | if (map.pTMF.delta & 1) { |
193 | // virtual |
194 | union { |
195 | const OSMetaClassBase *fObj; |
196 | _ptf_t **vtablep; |
197 | } u; |
198 | u.fObj = self; |
199 | |
200 | // Virtual member function so dereference table |
201 | pfn = *(_ptf_t *)(((uintptr_t)*u.vtablep) + (uintptr_t)pfn); |
202 | return pfn; |
203 | |
204 | } else { |
205 | // Not virtual, i.e. plain member func |
206 | return pfn; |
207 | } |
208 | } |
209 | |
210 | #endif /* defined(__arm__) || defined(__arm64__) */ |
211 | /********************************************************************* |
212 | * These used to be inline in the header but gcc didn't believe us |
213 | * Now we MUST pull the inline out at least until the compiler is |
214 | * repaired. |
215 | * |
216 | * Helper inlines for runtime type preprocessor macros |
217 | *********************************************************************/ |
218 | |
219 | /********************************************************************* |
220 | *********************************************************************/ |
221 | OSMetaClassBase * |
222 | OSMetaClassBase::safeMetaCast( |
223 | const OSMetaClassBase * me, |
224 | const OSMetaClass * toType) |
225 | { |
226 | return (me)? me->metaCast(toType) : 0; |
227 | } |
228 | |
229 | /********************************************************************* |
230 | *********************************************************************/ |
231 | bool |
232 | OSMetaClassBase::checkTypeInst( |
233 | const OSMetaClassBase * inst, |
234 | const OSMetaClassBase * typeinst) |
235 | { |
236 | const OSMetaClass * toType = OSTypeIDInst(typeinst); |
237 | return typeinst && inst && (0 != inst->metaCast(toType)); |
238 | } |
239 | |
240 | /********************************************************************* |
241 | *********************************************************************/ |
242 | void OSMetaClassBase:: |
243 | initialize() |
244 | { |
245 | sAllClassesLock = IOLockAlloc(); |
246 | sStalledClassesLock = IOLockAlloc(); |
247 | sInstancesLock = IOLockAlloc(); |
248 | } |
249 | |
250 | #if APPLE_KEXT_VTABLE_PADDING |
251 | /********************************************************************* |
252 | * If you need this slot you had better setup an IOCTL style interface. |
253 | * 'Cause the whole kernel world depends on OSMetaClassBase and YOU |
254 | * CANT change the VTABLE size ever. |
255 | *********************************************************************/ |
256 | void |
257 | OSMetaClassBase::_RESERVEDOSMetaClassBase7() |
258 | { panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called." , 7); } |
259 | #endif |
260 | |
261 | /********************************************************************* |
262 | *********************************************************************/ |
263 | OSMetaClassBase::OSMetaClassBase() |
264 | { |
265 | } |
266 | |
267 | /********************************************************************* |
268 | *********************************************************************/ |
269 | OSMetaClassBase::~OSMetaClassBase() |
270 | { |
271 | void ** thisVTable; |
272 | |
273 | thisVTable = (void **) this; |
274 | *thisVTable = (void *) -1UL; |
275 | } |
276 | |
277 | /********************************************************************* |
278 | *********************************************************************/ |
279 | bool |
280 | OSMetaClassBase::isEqualTo(const OSMetaClassBase * anObj) const |
281 | { |
282 | return this == anObj; |
283 | } |
284 | |
285 | /********************************************************************* |
286 | *********************************************************************/ |
287 | OSMetaClassBase * |
288 | OSMetaClassBase::metaCast(const OSMetaClass * toMeta) const |
289 | { |
290 | return toMeta->checkMetaCast(this); |
291 | } |
292 | |
293 | /********************************************************************* |
294 | *********************************************************************/ |
295 | OSMetaClassBase * |
296 | OSMetaClassBase::metaCast(const OSSymbol * toMetaSymb) const |
297 | { |
298 | return OSMetaClass::checkMetaCastWithName(toMetaSymb, this); |
299 | } |
300 | |
301 | /********************************************************************* |
302 | *********************************************************************/ |
303 | OSMetaClassBase * |
304 | OSMetaClassBase::metaCast(const OSString * toMetaStr) const |
305 | { |
306 | const OSSymbol * tempSymb = OSSymbol::withString(toMetaStr); |
307 | OSMetaClassBase * ret = 0; |
308 | if (tempSymb) { |
309 | ret = metaCast(tempSymb); |
310 | tempSymb->release(); |
311 | } |
312 | return ret; |
313 | } |
314 | |
315 | /********************************************************************* |
316 | *********************************************************************/ |
317 | OSMetaClassBase * |
318 | OSMetaClassBase::metaCast(const char * toMetaCStr) const |
319 | { |
320 | const OSSymbol * tempSymb = OSSymbol::withCString(toMetaCStr); |
321 | OSMetaClassBase * ret = 0; |
322 | if (tempSymb) { |
323 | ret = metaCast(tempSymb); |
324 | tempSymb->release(); |
325 | } |
326 | return ret; |
327 | } |
328 | |
329 | #if PRAGMA_MARK |
330 | #pragma mark OSMetaClassMeta |
331 | #endif /* PRAGMA_MARK */ |
332 | /********************************************************************* |
333 | * OSMetaClassMeta - the bootstrap metaclass of OSMetaClass |
334 | *********************************************************************/ |
335 | class OSMetaClassMeta : public OSMetaClass |
336 | { |
337 | public: |
338 | OSMetaClassMeta(); |
339 | OSObject * alloc() const; |
340 | }; |
341 | OSMetaClassMeta::OSMetaClassMeta() |
342 | : OSMetaClass("OSMetaClass" , 0, sizeof(OSMetaClass)) |
343 | { } |
344 | OSObject * OSMetaClassMeta::alloc() const { return 0; } |
345 | |
346 | static OSMetaClassMeta sOSMetaClassMeta; |
347 | |
348 | const OSMetaClass * const OSMetaClass::metaClass = &sOSMetaClassMeta; |
349 | const OSMetaClass * OSMetaClass::getMetaClass() const |
350 | { return &sOSMetaClassMeta; } |
351 | |
352 | #if PRAGMA_MARK |
353 | #pragma mark OSMetaClass |
354 | #endif /* PRAGMA_MARK */ |
355 | /********************************************************************* |
356 | * OSMetaClass |
357 | *********************************************************************/ |
358 | |
359 | #if APPLE_KEXT_VTABLE_PADDING |
360 | /********************************************************************* |
361 | * Reserved functions. |
362 | *********************************************************************/ |
363 | void OSMetaClass::_RESERVEDOSMetaClass0() |
364 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 0); } |
365 | void OSMetaClass::_RESERVEDOSMetaClass1() |
366 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 1); } |
367 | void OSMetaClass::_RESERVEDOSMetaClass2() |
368 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 2); } |
369 | void OSMetaClass::_RESERVEDOSMetaClass3() |
370 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 3); } |
371 | void OSMetaClass::_RESERVEDOSMetaClass4() |
372 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 4); } |
373 | void OSMetaClass::_RESERVEDOSMetaClass5() |
374 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 5); } |
375 | void OSMetaClass::_RESERVEDOSMetaClass6() |
376 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 6); } |
377 | void OSMetaClass::_RESERVEDOSMetaClass7() |
378 | { panic("OSMetaClass::_RESERVEDOSMetaClass%d called" , 7); } |
379 | #endif |
380 | |
381 | /********************************************************************* |
382 | *********************************************************************/ |
383 | static void |
384 | OSMetaClassLogErrorForKext( |
385 | OSReturn error, |
386 | OSKext * aKext) |
387 | { |
388 | const char * message = NULL; |
389 | |
390 | switch (error) { |
391 | case kOSReturnSuccess: |
392 | return; |
393 | case kOSMetaClassNoInit: // xxx - never returned; logged at fail site |
394 | message = "OSMetaClass: preModLoad() wasn't called (runtime internal error)." ; |
395 | break; |
396 | case kOSMetaClassNoDicts: |
397 | message = "OSMetaClass: Allocation failure for OSMetaClass internal dictionaries." ; |
398 | break; |
399 | case kOSMetaClassNoKModSet: |
400 | message = "OSMetaClass: Allocation failure for internal kext recording set/set missing." ; |
401 | break; |
402 | case kOSMetaClassNoInsKModSet: |
403 | message = "OSMetaClass: Failed to record class in kext." ; |
404 | break; |
405 | case kOSMetaClassDuplicateClass: |
406 | message = "OSMetaClass: Duplicate class encountered." ; |
407 | break; |
408 | case kOSMetaClassNoSuper: // xxx - never returned |
409 | message = "OSMetaClass: Can't associate a class with its superclass." ; |
410 | break; |
411 | case kOSMetaClassInstNoSuper: // xxx - never returned |
412 | message = "OSMetaClass: Instance construction error; unknown superclass." ; |
413 | break; |
414 | case kOSMetaClassNoKext: |
415 | message = "OSMetaClass: Kext not found for metaclass." ; |
416 | break; |
417 | case kOSMetaClassInternal: |
418 | default: |
419 | message = "OSMetaClass: Runtime internal error." ; |
420 | break; |
421 | } |
422 | |
423 | if (message) { |
424 | OSKextLog(aKext, kOSMetaClassLogSpec, "%s" , message); |
425 | } |
426 | return; |
427 | } |
428 | |
429 | void |
430 | OSMetaClass::logError(OSReturn error) |
431 | { |
432 | OSMetaClassLogErrorForKext(error, NULL); |
433 | } |
434 | |
435 | /********************************************************************* |
436 | * The core constructor for a MetaClass (defined with this name always |
437 | * but within the scope of its represented class). |
438 | * |
439 | * MetaClass constructors are invoked in OSRuntimeInitializeCPP(), |
440 | * in between calls to OSMetaClass::preModLoad(), which sets up for |
441 | * registration, and OSMetaClass::postModLoad(), which actually |
442 | * records all the class/kext relationships of the new MetaClasses. |
443 | *********************************************************************/ |
444 | OSMetaClass::OSMetaClass( |
445 | const char * inClassName, |
446 | const OSMetaClass * inSuperClass, |
447 | unsigned int inClassSize) |
448 | { |
449 | instanceCount = 0; |
450 | classSize = inClassSize; |
451 | superClassLink = inSuperClass; |
452 | |
453 | reserved = IONew(ExpansionData, 1); |
454 | bzero(reserved, sizeof(ExpansionData)); |
455 | #if IOTRACKING |
456 | uint32_t numSiteQs = 0; |
457 | if ((this == &OSSymbol ::gMetaClass) |
458 | || (this == &OSString ::gMetaClass) |
459 | || (this == &OSNumber ::gMetaClass) |
460 | || (this == &OSString ::gMetaClass) |
461 | || (this == &OSData ::gMetaClass) |
462 | || (this == &OSDictionary::gMetaClass) |
463 | || (this == &OSArray ::gMetaClass) |
464 | || (this == &OSSet ::gMetaClass)) numSiteQs = 27; |
465 | |
466 | reserved->tracking = IOTrackingQueueAlloc(inClassName, (uintptr_t) this, |
467 | inClassSize, 0, kIOTrackingQueueTypeAlloc, |
468 | numSiteQs); |
469 | #endif |
470 | |
471 | /* Hack alert: We are just casting inClassName and storing it in |
472 | * an OSString * instance variable. This may be because you can't |
473 | * create C++ objects in static constructors, but I really don't know! |
474 | */ |
475 | className = (const OSSymbol *)inClassName; |
476 | |
477 | // sStalledClassesLock taken in preModLoad |
478 | if (!sStalled) { |
479 | /* There's no way we can look up the kext here, unfortunately. |
480 | */ |
481 | OSKextLog(/* kext */ NULL, kOSMetaClassLogSpec, |
482 | "OSMetaClass: preModLoad() wasn't called for class %s " |
483 | "(runtime internal error)." , |
484 | inClassName); |
485 | } else if (!sStalled->result) { |
486 | // Grow stalled array if neccessary |
487 | if (sStalled->count >= sStalled->capacity) { |
488 | OSMetaClass **oldStalled = sStalled->classes; |
489 | int oldSize = sStalled->capacity * sizeof(OSMetaClass *); |
490 | int newSize = oldSize |
491 | + kKModCapacityIncrement * sizeof(OSMetaClass *); |
492 | |
493 | sStalled->classes = (OSMetaClass **)kalloc_tag(newSize, VM_KERN_MEMORY_OSKEXT); |
494 | if (!sStalled->classes) { |
495 | sStalled->classes = oldStalled; |
496 | sStalled->result = kOSMetaClassNoTempData; |
497 | return; |
498 | } |
499 | |
500 | sStalled->capacity += kKModCapacityIncrement; |
501 | memmove(sStalled->classes, oldStalled, oldSize); |
502 | kfree(oldStalled, oldSize); |
503 | OSMETA_ACCUMSIZE(((size_t)newSize) - ((size_t)oldSize)); |
504 | } |
505 | |
506 | sStalled->classes[sStalled->count++] = this; |
507 | } |
508 | } |
509 | |
510 | /********************************************************************* |
511 | *********************************************************************/ |
512 | OSMetaClass::~OSMetaClass() |
513 | { |
514 | OSKext * myKext = reserved ? reserved->kext : 0; // do not release |
515 | |
516 | /* Hack alert: 'className' is a C string during early C++ init, and |
517 | * is converted to a real OSSymbol only when we record the OSKext in |
518 | * OSMetaClass::postModLoad(). So only do this bit if we have an OSKext. |
519 | * We can't safely cast or check 'className'. |
520 | * |
521 | * Also, release className *after* calling into the kext, |
522 | * as removeClass() may access className. |
523 | */ |
524 | IOLockLock(sAllClassesLock); |
525 | if (sAllClassesDict) { |
526 | if (myKext) { |
527 | sAllClassesDict->removeObject(className); |
528 | } else { |
529 | sAllClassesDict->removeObject((const char *)className); |
530 | } |
531 | } |
532 | IOLockUnlock(sAllClassesLock); |
533 | |
534 | if (myKext) { |
535 | if (myKext->removeClass(this) != kOSReturnSuccess) { |
536 | // xxx - what can we do? |
537 | } |
538 | className->release(); |
539 | } |
540 | |
541 | // sStalledClassesLock taken in preModLoad |
542 | if (sStalled) { |
543 | unsigned int i; |
544 | |
545 | /* First pass find class in stalled list. If we find it that means |
546 | * we started C++ init with constructors but now we're tearing down |
547 | * because of some failure. |
548 | */ |
549 | for (i = 0; i < sStalled->count; i++) { |
550 | if (this == sStalled->classes[i]) { |
551 | break; |
552 | } |
553 | } |
554 | |
555 | /* Remove this metaclass from the stalled list so postModLoad() doesn't |
556 | * try to register it. |
557 | */ |
558 | if (i < sStalled->count) { |
559 | sStalled->count--; |
560 | if (i < sStalled->count) { |
561 | memmove(&sStalled->classes[i], &sStalled->classes[i+1], |
562 | (sStalled->count - i) * sizeof(OSMetaClass *)); |
563 | } |
564 | } |
565 | } |
566 | #if IOTRACKING |
567 | IOTrackingQueueFree(reserved->tracking); |
568 | #endif |
569 | IODelete(reserved, ExpansionData, 1); |
570 | } |
571 | |
572 | /********************************************************************* |
573 | * Empty overrides. |
574 | *********************************************************************/ |
575 | void OSMetaClass::retain() const { } |
576 | void OSMetaClass::release() const { } |
577 | void OSMetaClass::release(__unused int when) const { } |
578 | void OSMetaClass::taggedRetain(__unused const void * tag) const { } |
579 | void OSMetaClass::taggedRelease(__unused const void * tag) const { } |
580 | void OSMetaClass::taggedRelease(__unused const void * tag, __unused const int when) const { } |
581 | int OSMetaClass::getRetainCount() const { return 0; } |
582 | |
583 | /********************************************************************* |
584 | *********************************************************************/ |
585 | const char * |
586 | OSMetaClass::getClassName() const |
587 | { |
588 | if (!className) return NULL; |
589 | return className->getCStringNoCopy(); |
590 | } |
591 | /********************************************************************* |
592 | *********************************************************************/ |
593 | const OSSymbol * |
594 | OSMetaClass::getClassNameSymbol() const |
595 | { |
596 | return className; |
597 | } |
598 | /********************************************************************* |
599 | *********************************************************************/ |
600 | unsigned int |
601 | OSMetaClass::getClassSize() const |
602 | { |
603 | return classSize; |
604 | } |
605 | |
606 | /********************************************************************* |
607 | *********************************************************************/ |
608 | void * |
609 | OSMetaClass::preModLoad(const char * kextIdentifier) |
610 | { |
611 | IOLockLock(sStalledClassesLock); |
612 | |
613 | assert (sStalled == NULL); |
614 | sStalled = (StalledData *)kalloc_tag(sizeof(* sStalled), VM_KERN_MEMORY_OSKEXT); |
615 | if (sStalled) { |
616 | sStalled->classes = (OSMetaClass **) |
617 | kalloc_tag(kKModCapacityIncrement * sizeof(OSMetaClass *), VM_KERN_MEMORY_OSKEXT); |
618 | if (!sStalled->classes) { |
619 | kfree(sStalled, sizeof(*sStalled)); |
620 | return 0; |
621 | } |
622 | OSMETA_ACCUMSIZE((kKModCapacityIncrement * sizeof(OSMetaClass *)) + |
623 | sizeof(*sStalled)); |
624 | |
625 | sStalled->result = kOSReturnSuccess; |
626 | sStalled->capacity = kKModCapacityIncrement; |
627 | sStalled->count = 0; |
628 | sStalled->kextIdentifier = kextIdentifier; |
629 | bzero(sStalled->classes, kKModCapacityIncrement * sizeof(OSMetaClass *)); |
630 | } |
631 | |
632 | // keep sStalledClassesLock locked until postModLoad |
633 | |
634 | return sStalled; |
635 | } |
636 | |
637 | /********************************************************************* |
638 | *********************************************************************/ |
639 | bool |
640 | OSMetaClass::checkModLoad(void * loadHandle) |
641 | { |
642 | return sStalled && loadHandle == sStalled && |
643 | sStalled->result == kOSReturnSuccess; |
644 | } |
645 | |
646 | /********************************************************************* |
647 | *********************************************************************/ |
648 | OSReturn |
649 | OSMetaClass::postModLoad(void * loadHandle) |
650 | { |
651 | OSReturn result = kOSReturnSuccess; |
652 | OSSymbol * myKextName = 0; // must release |
653 | OSKext * myKext = 0; // must release |
654 | |
655 | if (!sStalled || loadHandle != sStalled) { |
656 | result = kOSMetaClassInternal; |
657 | goto finish; |
658 | } |
659 | |
660 | if (sStalled->result) { |
661 | result = sStalled->result; |
662 | } else switch (sBootstrapState) { |
663 | |
664 | case kNoDictionaries: |
665 | sBootstrapState = kMakingDictionaries; |
666 | // No break; fall through |
667 | [[clang::fallthrough]]; |
668 | |
669 | case kMakingDictionaries: |
670 | sAllClassesDict = OSDictionary::withCapacity(kClassCapacityIncrement); |
671 | if (!sAllClassesDict) { |
672 | result = kOSMetaClassNoDicts; |
673 | break; |
674 | } |
675 | sAllClassesDict->setOptions(OSCollection::kSort, OSCollection::kSort); |
676 | |
677 | // No break; fall through |
678 | [[clang::fallthrough]]; |
679 | |
680 | case kCompletedBootstrap: |
681 | { |
682 | unsigned int i; |
683 | myKextName = const_cast<OSSymbol *>(OSSymbol::withCStringNoCopy( |
684 | sStalled->kextIdentifier)); |
685 | |
686 | if (!sStalled->count) { |
687 | break; // Nothing to do so just get out |
688 | } |
689 | |
690 | myKext = OSKext::lookupKextWithIdentifier(myKextName); |
691 | if (!myKext) { |
692 | result = kOSMetaClassNoKext; |
693 | |
694 | /* Log this error here so we can include the kext name. |
695 | */ |
696 | OSKextLog(/* kext */ NULL, kOSMetaClassLogSpec, |
697 | "OSMetaClass: Can't record classes for kext %s - kext not found." , |
698 | sStalled->kextIdentifier); |
699 | break; |
700 | } |
701 | |
702 | /* First pass checking classes aren't already loaded. If any already |
703 | * exist, we don't register any, and so we don't technically have |
704 | * to do any C++ teardown. |
705 | * |
706 | * Hack alert: me->className has been a C string until now. |
707 | * We only release the OSSymbol if we store the kext. |
708 | */ |
709 | IOLockLock(sAllClassesLock); |
710 | for (i = 0; i < sStalled->count; i++) { |
711 | const OSMetaClass * me = sStalled->classes[i]; |
712 | OSMetaClass * orig = OSDynamicCast(OSMetaClass, |
713 | sAllClassesDict->getObject((const char *)me->className)); |
714 | |
715 | if (orig) { |
716 | |
717 | /* Log this error here so we can include the class name. |
718 | * xxx - we should look up the other kext that defines the class |
719 | */ |
720 | #if CONFIG_EMBEDDED |
721 | panic( |
722 | #else |
723 | OSKextLog(myKext, kOSMetaClassLogSpec, |
724 | #endif /* CONFIG_EMBEDDED */ |
725 | "OSMetaClass: Kext %s class %s is a duplicate;" |
726 | "kext %s already has a class by that name." , |
727 | sStalled->kextIdentifier, (const char *)me->className, |
728 | ((OSKext *)orig->reserved->kext)->getIdentifierCString()); |
729 | result = kOSMetaClassDuplicateClass; |
730 | break; |
731 | } |
732 | unsigned int depth = 1; |
733 | while ((me = me->superClassLink)) depth++; |
734 | if (depth > sDeepestClass) sDeepestClass = depth; |
735 | } |
736 | IOLockUnlock(sAllClassesLock); |
737 | |
738 | /* Bail if we didn't go through the entire list of new classes |
739 | * (if we hit a duplicate). |
740 | */ |
741 | if (i != sStalled->count) { |
742 | break; |
743 | } |
744 | |
745 | // Second pass symbolling strings and inserting classes in dictionary |
746 | IOLockLock(sAllClassesLock); |
747 | for (i = 0; i < sStalled->count; i++) { |
748 | OSMetaClass * me = sStalled->classes[i]; |
749 | |
750 | /* Hack alert: me->className has been a C string until now. |
751 | * We only release the OSSymbol in ~OSMetaClass() |
752 | * if we set the reference to the kext. |
753 | */ |
754 | me->className = |
755 | OSSymbol::withCStringNoCopy((const char *)me->className); |
756 | |
757 | // xxx - I suppose if these fail we're going to panic soon.... |
758 | sAllClassesDict->setObject(me->className, me); |
759 | |
760 | /* Do not retain the kext object here. |
761 | */ |
762 | me->reserved->kext = myKext; |
763 | if (myKext) { |
764 | result = myKext->addClass(me, sStalled->count); |
765 | if (result != kOSReturnSuccess) { |
766 | /* OSKext::addClass() logs with kOSMetaClassNoInsKModSet. */ |
767 | break; |
768 | } |
769 | } |
770 | } |
771 | IOLockUnlock(sAllClassesLock); |
772 | sBootstrapState = kCompletedBootstrap; |
773 | break; |
774 | } |
775 | |
776 | default: |
777 | result = kOSMetaClassInternal; |
778 | break; |
779 | } |
780 | |
781 | finish: |
782 | /* Don't call logError() for success or the conditions logged above |
783 | * or by called function. |
784 | */ |
785 | if (result != kOSReturnSuccess && |
786 | result != kOSMetaClassNoInsKModSet && |
787 | result != kOSMetaClassDuplicateClass && |
788 | result != kOSMetaClassNoKext) { |
789 | |
790 | OSMetaClassLogErrorForKext(result, myKext); |
791 | } |
792 | |
793 | OSSafeReleaseNULL(myKextName); |
794 | OSSafeReleaseNULL(myKext); |
795 | |
796 | if (sStalled) { |
797 | OSMETA_ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) + |
798 | sizeof(*sStalled))); |
799 | kfree(sStalled->classes, sStalled->capacity * sizeof(OSMetaClass *)); |
800 | kfree(sStalled, sizeof(*sStalled)); |
801 | sStalled = 0; |
802 | } |
803 | |
804 | IOLockUnlock(sStalledClassesLock); |
805 | |
806 | return result; |
807 | } |
808 | |
809 | |
810 | /********************************************************************* |
811 | *********************************************************************/ |
812 | void |
813 | OSMetaClass::instanceConstructed() const |
814 | { |
815 | // if ((0 == OSIncrementAtomic(&(((OSMetaClass *) this)->instanceCount))) && superClassLink) |
816 | if ((0 == OSIncrementAtomic(&instanceCount)) && superClassLink) { |
817 | superClassLink->instanceConstructed(); |
818 | } |
819 | } |
820 | |
821 | /********************************************************************* |
822 | *********************************************************************/ |
823 | void |
824 | OSMetaClass::instanceDestructed() const |
825 | { |
826 | if ((1 == OSDecrementAtomic(&instanceCount)) && superClassLink) { |
827 | superClassLink->instanceDestructed(); |
828 | } |
829 | |
830 | if (((int)instanceCount) < 0) { |
831 | OSKext * myKext = reserved->kext; |
832 | |
833 | OSKextLog(myKext, kOSMetaClassLogSpec, |
834 | // xxx - this phrasing is rather cryptic |
835 | "OSMetaClass: Class %s - bad retain (%d)" , |
836 | getClassName(), instanceCount); |
837 | } |
838 | } |
839 | |
840 | /********************************************************************* |
841 | *********************************************************************/ |
842 | bool |
843 | OSMetaClass::modHasInstance(const char * kextIdentifier) |
844 | { |
845 | bool result = false; |
846 | OSKext * theKext = NULL; // must release |
847 | |
848 | theKext = OSKext::lookupKextWithIdentifier(kextIdentifier); |
849 | if (!theKext) { |
850 | goto finish; |
851 | } |
852 | |
853 | result = theKext->hasOSMetaClassInstances(); |
854 | |
855 | finish: |
856 | OSSafeReleaseNULL(theKext); |
857 | return result; |
858 | } |
859 | |
860 | /********************************************************************* |
861 | *********************************************************************/ |
862 | void |
863 | OSMetaClass::reportModInstances(const char * kextIdentifier) |
864 | { |
865 | OSKext::reportOSMetaClassInstances(kextIdentifier, |
866 | kOSKextLogExplicitLevel); |
867 | return; |
868 | } |
869 | /********************************************************************* |
870 | *********************************************************************/ |
871 | |
872 | void |
873 | OSMetaClass::addInstance(const OSObject * instance, bool super) const |
874 | { |
875 | if (!super) IOLockLock(sInstancesLock); |
876 | |
877 | if (!reserved->instances) { |
878 | reserved->instances = OSOrderedSet::withCapacity(16); |
879 | if (superClassLink) { |
880 | superClassLink->addInstance(reserved->instances, true); |
881 | } |
882 | } |
883 | reserved->instances->setLastObject(instance); |
884 | |
885 | if (!super) IOLockUnlock(sInstancesLock); |
886 | } |
887 | |
888 | void |
889 | OSMetaClass::removeInstance(const OSObject * instance, bool super) const |
890 | { |
891 | if (!super) IOLockLock(sInstancesLock); |
892 | |
893 | if (reserved->instances) { |
894 | reserved->instances->removeObject(instance); |
895 | if (0 == reserved->instances->getCount()) { |
896 | if (superClassLink) { |
897 | superClassLink->removeInstance(reserved->instances, true); |
898 | } |
899 | IOLockLock(sAllClassesLock); |
900 | reserved->instances->release(); |
901 | reserved->instances = 0; |
902 | IOLockUnlock(sAllClassesLock); |
903 | } |
904 | } |
905 | |
906 | if (!super) IOLockUnlock(sInstancesLock); |
907 | } |
908 | |
909 | void |
910 | OSMetaClass::applyToInstances(OSOrderedSet * set, |
911 | OSMetaClassInstanceApplierFunction applier, |
912 | void * context) |
913 | { |
914 | enum { kLocalDepth = 24 }; |
915 | unsigned int _nextIndex[kLocalDepth]; |
916 | OSOrderedSet * _sets[kLocalDepth]; |
917 | unsigned int * nextIndex = &_nextIndex[0]; |
918 | OSOrderedSet ** sets = &_sets[0]; |
919 | OSObject * obj; |
920 | OSOrderedSet * childSet; |
921 | unsigned int maxDepth; |
922 | unsigned int idx; |
923 | unsigned int level; |
924 | bool done; |
925 | |
926 | maxDepth = sDeepestClass; |
927 | if (maxDepth > kLocalDepth) |
928 | { |
929 | nextIndex = IONew(typeof(nextIndex[0]), maxDepth); |
930 | sets = IONew(typeof(sets[0]), maxDepth); |
931 | } |
932 | done = false; |
933 | level = 0; |
934 | idx = 0; |
935 | do |
936 | { |
937 | while (!done && (obj = set->getObject(idx++))) |
938 | { |
939 | if ((childSet = OSDynamicCast(OSOrderedSet, obj))) |
940 | { |
941 | if (level >= maxDepth) panic(">maxDepth" ); |
942 | sets[level] = set; |
943 | nextIndex[level] = idx; |
944 | level++; |
945 | set = childSet; |
946 | idx = 0; |
947 | break; |
948 | } |
949 | done = (*applier)(obj, context); |
950 | } |
951 | if (!obj) |
952 | { |
953 | if (!done && level) |
954 | { |
955 | level--; |
956 | set = sets[level]; |
957 | idx = nextIndex[level]; |
958 | } else done = true; |
959 | } |
960 | } |
961 | while (!done); |
962 | if (maxDepth > kLocalDepth) |
963 | { |
964 | IODelete(nextIndex, typeof(nextIndex[0]), maxDepth); |
965 | IODelete(sets, typeof(sets[0]), maxDepth); |
966 | } |
967 | } |
968 | |
969 | void |
970 | OSMetaClass::applyToInstances(OSMetaClassInstanceApplierFunction applier, |
971 | void * context) const |
972 | { |
973 | IOLockLock(sInstancesLock); |
974 | if (reserved->instances) applyToInstances(reserved->instances, applier, context); |
975 | IOLockUnlock(sInstancesLock); |
976 | } |
977 | |
978 | void |
979 | OSMetaClass::applyToInstancesOfClassName( |
980 | const OSSymbol * name, |
981 | OSMetaClassInstanceApplierFunction applier, |
982 | void * context) |
983 | { |
984 | OSMetaClass * meta; |
985 | OSOrderedSet * set = 0; |
986 | |
987 | IOLockLock(sAllClassesLock); |
988 | if (sAllClassesDict |
989 | && (meta = (OSMetaClass *) sAllClassesDict->getObject(name)) |
990 | && (set = meta->reserved->instances)) |
991 | { |
992 | set->retain(); |
993 | } |
994 | IOLockUnlock(sAllClassesLock); |
995 | |
996 | if (!set) return; |
997 | |
998 | IOLockLock(sInstancesLock); |
999 | applyToInstances(set, applier, context); |
1000 | IOLockUnlock(sInstancesLock); |
1001 | set->release(); |
1002 | } |
1003 | |
1004 | /********************************************************************* |
1005 | *********************************************************************/ |
1006 | void |
1007 | OSMetaClass::considerUnloads() |
1008 | { |
1009 | OSKext::considerUnloads(); |
1010 | } |
1011 | |
1012 | /********************************************************************* |
1013 | *********************************************************************/ |
1014 | bool |
1015 | OSMetaClass::removeClasses(OSCollection * metaClasses) |
1016 | { |
1017 | OSCollectionIterator * classIterator; |
1018 | OSMetaClass * checkClass; |
1019 | bool result; |
1020 | |
1021 | classIterator = OSCollectionIterator::withCollection(metaClasses); |
1022 | if (!classIterator) return (false); |
1023 | |
1024 | IOLockLock(sAllClassesLock); |
1025 | |
1026 | result = false; |
1027 | do |
1028 | { |
1029 | while ((checkClass = (OSMetaClass *)classIterator->getNextObject()) |
1030 | && !checkClass->getInstanceCount() |
1031 | && !checkClass->reserved->retain) {} |
1032 | if (checkClass) break; |
1033 | classIterator->reset(); |
1034 | while ((checkClass = (OSMetaClass *)classIterator->getNextObject())) |
1035 | { |
1036 | sAllClassesDict->removeObject(checkClass->className); |
1037 | } |
1038 | result = true; |
1039 | } |
1040 | while (false); |
1041 | |
1042 | IOLockUnlock(sAllClassesLock); |
1043 | OSSafeReleaseNULL(classIterator); |
1044 | |
1045 | return (result); |
1046 | } |
1047 | |
1048 | |
1049 | /********************************************************************* |
1050 | *********************************************************************/ |
1051 | const OSMetaClass * |
1052 | OSMetaClass::getMetaClassWithName(const OSSymbol * name) |
1053 | { |
1054 | OSMetaClass * retMeta = 0; |
1055 | |
1056 | if (!name) { |
1057 | return 0; |
1058 | } |
1059 | |
1060 | IOLockLock(sAllClassesLock); |
1061 | if (sAllClassesDict) { |
1062 | retMeta = (OSMetaClass *) sAllClassesDict->getObject(name); |
1063 | } |
1064 | IOLockUnlock(sAllClassesLock); |
1065 | |
1066 | return retMeta; |
1067 | } |
1068 | |
1069 | /********************************************************************* |
1070 | *********************************************************************/ |
1071 | const OSMetaClass * |
1072 | OSMetaClass::copyMetaClassWithName(const OSSymbol * name) |
1073 | { |
1074 | const OSMetaClass * meta; |
1075 | |
1076 | if (!name) return (0); |
1077 | |
1078 | meta = 0; |
1079 | IOLockLock(sAllClassesLock); |
1080 | if (sAllClassesDict) { |
1081 | meta = (OSMetaClass *) sAllClassesDict->getObject(name); |
1082 | if (meta) OSIncrementAtomic(&meta->reserved->retain); |
1083 | } |
1084 | IOLockUnlock(sAllClassesLock); |
1085 | |
1086 | return (meta); |
1087 | } |
1088 | |
1089 | /********************************************************************* |
1090 | *********************************************************************/ |
1091 | void |
1092 | OSMetaClass::releaseMetaClass() const |
1093 | { |
1094 | OSDecrementAtomic(&reserved->retain); |
1095 | } |
1096 | |
1097 | /********************************************************************* |
1098 | *********************************************************************/ |
1099 | OSObject * |
1100 | OSMetaClass::allocClassWithName(const OSSymbol * name) |
1101 | { |
1102 | const OSMetaClass * meta; |
1103 | OSObject * result; |
1104 | |
1105 | result = 0; |
1106 | meta = copyMetaClassWithName(name); |
1107 | if (meta) |
1108 | { |
1109 | result = meta->alloc(); |
1110 | meta->releaseMetaClass(); |
1111 | } |
1112 | |
1113 | return result; |
1114 | } |
1115 | |
1116 | /********************************************************************* |
1117 | *********************************************************************/ |
1118 | OSObject * |
1119 | OSMetaClass::allocClassWithName(const OSString * name) |
1120 | { |
1121 | const OSSymbol * tmpKey = OSSymbol::withString(name); |
1122 | OSObject * result = allocClassWithName(tmpKey); |
1123 | tmpKey->release(); |
1124 | return result; |
1125 | } |
1126 | |
1127 | /********************************************************************* |
1128 | *********************************************************************/ |
1129 | OSObject * |
1130 | OSMetaClass::allocClassWithName(const char * name) |
1131 | { |
1132 | const OSSymbol * tmpKey = OSSymbol::withCStringNoCopy(name); |
1133 | OSObject * result = allocClassWithName(tmpKey); |
1134 | tmpKey->release(); |
1135 | return result; |
1136 | } |
1137 | |
1138 | |
1139 | /********************************************************************* |
1140 | *********************************************************************/ |
1141 | OSMetaClassBase * |
1142 | OSMetaClass::checkMetaCastWithName( |
1143 | const OSSymbol * name, |
1144 | const OSMetaClassBase * in) |
1145 | { |
1146 | OSMetaClassBase * result = 0; |
1147 | |
1148 | const OSMetaClass * const meta = getMetaClassWithName(name); |
1149 | |
1150 | if (meta) { |
1151 | result = meta->checkMetaCast(in); |
1152 | } |
1153 | |
1154 | return result; |
1155 | } |
1156 | |
1157 | /********************************************************************* |
1158 | *********************************************************************/ |
1159 | OSMetaClassBase * OSMetaClass:: |
1160 | checkMetaCastWithName( |
1161 | const OSString * name, |
1162 | const OSMetaClassBase * in) |
1163 | { |
1164 | const OSSymbol * tmpKey = OSSymbol::withString(name); |
1165 | OSMetaClassBase * result = checkMetaCastWithName(tmpKey, in); |
1166 | |
1167 | tmpKey->release(); |
1168 | return result; |
1169 | } |
1170 | |
1171 | /********************************************************************* |
1172 | *********************************************************************/ |
1173 | OSMetaClassBase * |
1174 | OSMetaClass::checkMetaCastWithName( |
1175 | const char * name, |
1176 | const OSMetaClassBase * in) |
1177 | { |
1178 | const OSSymbol * tmpKey = OSSymbol::withCStringNoCopy(name); |
1179 | OSMetaClassBase * result = checkMetaCastWithName(tmpKey, in); |
1180 | |
1181 | tmpKey->release(); |
1182 | return result; |
1183 | } |
1184 | |
1185 | /********************************************************************* |
1186 | * OSMetaClass::checkMetaCast() |
1187 | * Check to see if the 'check' object has this object in its metaclass chain. |
1188 | * Returns check if it is indeed a kind of the current meta class, 0 otherwise. |
1189 | * |
1190 | * Generally this method is not invoked directly but is used to implement |
1191 | * the OSMetaClassBase::metaCast member function. |
1192 | * |
1193 | * See also OSMetaClassBase::metaCast |
1194 | *********************************************************************/ |
1195 | OSMetaClassBase * OSMetaClass::checkMetaCast( |
1196 | const OSMetaClassBase * check) const |
1197 | { |
1198 | const OSMetaClass * const toMeta = this; |
1199 | const OSMetaClass * fromMeta; |
1200 | |
1201 | for (fromMeta = check->getMetaClass(); ; fromMeta = fromMeta->superClassLink) { |
1202 | if (toMeta == fromMeta) { |
1203 | return const_cast<OSMetaClassBase *>(check); // Discard const |
1204 | } |
1205 | if (!fromMeta->superClassLink) { |
1206 | break; |
1207 | } |
1208 | } |
1209 | |
1210 | return 0; |
1211 | } |
1212 | |
1213 | /********************************************************************* |
1214 | *********************************************************************/ |
1215 | void |
1216 | OSMetaClass::reservedCalled(int ind) const |
1217 | { |
1218 | const char * cname = className->getCStringNoCopy(); |
1219 | panic("%s::_RESERVED%s%d called." , cname, cname, ind); |
1220 | } |
1221 | |
1222 | /********************************************************************* |
1223 | *********************************************************************/ |
1224 | const |
1225 | OSMetaClass * |
1226 | OSMetaClass::getSuperClass() const |
1227 | { |
1228 | return superClassLink; |
1229 | } |
1230 | |
1231 | /********************************************************************* |
1232 | * xxx - I want to rename this :-/ |
1233 | *********************************************************************/ |
1234 | const OSSymbol * |
1235 | OSMetaClass::getKmodName() const |
1236 | { |
1237 | OSKext * myKext = reserved ? reserved->kext : 0; |
1238 | if (myKext) { |
1239 | return myKext->getIdentifier(); |
1240 | } |
1241 | return OSSymbol::withCStringNoCopy("unknown" ); |
1242 | } |
1243 | |
1244 | /********************************************************************* |
1245 | *********************************************************************/ |
1246 | unsigned int |
1247 | OSMetaClass::getInstanceCount() const |
1248 | { |
1249 | return instanceCount; |
1250 | } |
1251 | |
1252 | /********************************************************************* |
1253 | *********************************************************************/ |
1254 | /* static */ |
1255 | void |
1256 | OSMetaClass::printInstanceCounts() |
1257 | { |
1258 | OSCollectionIterator * classes; |
1259 | OSSymbol * className; |
1260 | OSMetaClass * meta; |
1261 | |
1262 | IOLockLock(sAllClassesLock); |
1263 | classes = OSCollectionIterator::withCollection(sAllClassesDict); |
1264 | assert(classes); |
1265 | |
1266 | while( (className = (OSSymbol *)classes->getNextObject())) { |
1267 | meta = (OSMetaClass *)sAllClassesDict->getObject(className); |
1268 | assert(meta); |
1269 | |
1270 | printf("%24s count: %03d x 0x%03x = 0x%06x\n" , |
1271 | className->getCStringNoCopy(), |
1272 | meta->getInstanceCount(), |
1273 | meta->getClassSize(), |
1274 | meta->getInstanceCount() * meta->getClassSize() ); |
1275 | } |
1276 | printf("\n" ); |
1277 | classes->release(); |
1278 | IOLockUnlock(sAllClassesLock); |
1279 | return; |
1280 | } |
1281 | |
1282 | /********************************************************************* |
1283 | *********************************************************************/ |
1284 | OSDictionary * |
1285 | OSMetaClass::getClassDictionary() |
1286 | { |
1287 | panic("OSMetaClass::getClassDictionary() is obsoleted.\n" ); |
1288 | return 0; |
1289 | } |
1290 | |
1291 | /********************************************************************* |
1292 | *********************************************************************/ |
1293 | bool |
1294 | OSMetaClass::serialize(__unused OSSerialize * s) const |
1295 | { |
1296 | panic("OSMetaClass::serialize(): Obsoleted\n" ); |
1297 | return false; |
1298 | } |
1299 | |
1300 | /********************************************************************* |
1301 | *********************************************************************/ |
1302 | /* static */ |
1303 | void |
1304 | OSMetaClass::serializeClassDictionary(OSDictionary * serializeDictionary) |
1305 | { |
1306 | OSDictionary * classDict = NULL; |
1307 | |
1308 | IOLockLock(sAllClassesLock); |
1309 | |
1310 | classDict = OSDictionary::withCapacity(sAllClassesDict->getCount()); |
1311 | if (!classDict) { |
1312 | goto finish; |
1313 | } |
1314 | |
1315 | do { |
1316 | OSCollectionIterator * classes; |
1317 | const OSSymbol * className; |
1318 | |
1319 | classes = OSCollectionIterator::withCollection(sAllClassesDict); |
1320 | if (!classes) { |
1321 | break; |
1322 | } |
1323 | |
1324 | while ((className = (const OSSymbol *)classes->getNextObject())) { |
1325 | const OSMetaClass * meta; |
1326 | OSNumber * count; |
1327 | |
1328 | meta = (OSMetaClass *)sAllClassesDict->getObject(className); |
1329 | count = OSNumber::withNumber(meta->getInstanceCount(), 32); |
1330 | if (count) { |
1331 | classDict->setObject(className, count); |
1332 | count->release(); |
1333 | } |
1334 | } |
1335 | classes->release(); |
1336 | |
1337 | serializeDictionary->setObject("Classes" , classDict); |
1338 | } while (0); |
1339 | |
1340 | finish: |
1341 | OSSafeReleaseNULL(classDict); |
1342 | |
1343 | IOLockUnlock(sAllClassesLock); |
1344 | |
1345 | return; |
1346 | } |
1347 | |
1348 | |
1349 | /********************************************************************* |
1350 | *********************************************************************/ |
1351 | |
1352 | #if IOTRACKING |
1353 | |
1354 | void *OSMetaClass::trackedNew(size_t size) |
1355 | { |
1356 | IOTracking * mem; |
1357 | |
1358 | mem = (typeof(mem)) kalloc_tag_bt(size + sizeof(IOTracking), VM_KERN_MEMORY_LIBKERN); |
1359 | assert(mem); |
1360 | if (!mem) return (mem); |
1361 | |
1362 | memset(mem, 0, size + sizeof(IOTracking)); |
1363 | mem++; |
1364 | |
1365 | OSIVAR_ACCUMSIZE(size); |
1366 | |
1367 | return (mem); |
1368 | } |
1369 | |
1370 | void OSMetaClass::trackedDelete(void * instance, size_t size) |
1371 | { |
1372 | IOTracking * mem = (typeof(mem)) instance; mem--; |
1373 | |
1374 | kfree(mem, size + sizeof(IOTracking)); |
1375 | OSIVAR_ACCUMSIZE(-size); |
1376 | } |
1377 | |
1378 | void OSMetaClass::trackedInstance(OSObject * instance) const |
1379 | { |
1380 | IOTracking * mem = (typeof(mem)) instance; mem--; |
1381 | |
1382 | return (IOTrackingAdd(reserved->tracking, mem, classSize, false, VM_KERN_MEMORY_NONE)); |
1383 | } |
1384 | |
1385 | void OSMetaClass::trackedFree(OSObject * instance) const |
1386 | { |
1387 | IOTracking * mem = (typeof(mem)) instance; mem--; |
1388 | |
1389 | return (IOTrackingRemove(reserved->tracking, mem, classSize)); |
1390 | } |
1391 | |
1392 | void OSMetaClass::trackedAccumSize(OSObject * instance, size_t size) const |
1393 | { |
1394 | IOTracking * mem = (typeof(mem)) instance; mem--; |
1395 | |
1396 | return (IOTrackingAccumSize(reserved->tracking, mem, size)); |
1397 | } |
1398 | |
1399 | IOTrackingQueue * OSMetaClass::getTracking() const |
1400 | { |
1401 | return (reserved->tracking); |
1402 | } |
1403 | |
1404 | #endif /* IOTRACKING */ |
1405 | |