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