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