Loading...
--- xnu/xnu-3248.50.21/libkern/c++/OSMetaClass.cpp
+++ xnu/xnu-1504.9.37/libkern/c++/OSMetaClass.cpp
@@ -46,10 +46,9 @@
#include <libkern/c++/OSLib.h>
#include <libkern/OSAtomic.h>
+#include <IOKit/pwr_mgt/RootDomain.h>
+#include <IOKit/IOMessage.h>
#include <IOKit/IOLib.h>
-
-#include <IOKit/IOKitDebug.h>
-
__BEGIN_DECLS
@@ -67,6 +66,13 @@
/*********************************************************************
* Macros
*********************************************************************/
+#if OSALLOCDEBUG
+extern int debug_container_malloc_size;
+#define ACCUMSIZE(s) do { debug_container_malloc_size += (s); } while (0)
+#else
+#define ACCUMSIZE(s)
+#endif /* OSALLOCDEBUG */
+
__END_DECLS
#if PRAGMA_MARK
@@ -89,9 +95,7 @@
static const int kClassCapacityIncrement = 40;
static const int kKModCapacityIncrement = 10;
static OSDictionary * sAllClassesDict;
-static unsigned int sDeepestClass;
IOLock * sAllClassesLock = NULL;
-IOLock * sInstancesLock = NULL;
/*
* While loading a kext and running all its constructors to register
@@ -107,15 +111,6 @@
} * sStalled;
IOLock * sStalledClassesLock = NULL;
-struct ExpansionData {
- OSOrderedSet * instances;
- OSKext * kext;
-#if IOTRACKING
- IOTrackingQueue * tracking;
-#endif
-};
-
-
#if PRAGMA_MARK
#pragma mark OSMetaClassBase
#endif /* PRAGMA_MARK */
@@ -123,7 +118,6 @@
* OSMetaClassBase.
*********************************************************************/
-#if APPLE_KEXT_VTABLE_PADDING
/*********************************************************************
* Reserved vtable functions.
*********************************************************************/
@@ -145,8 +139,7 @@
{ panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called.", 5); }
void OSMetaClassBase::_RESERVEDOSMetaClassBase6()
{ panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called.", 6); }
-#endif
-
+
/*********************************************************************
* These used to be inline in the header but gcc didn't believe us
* Now we MUST pull the inline out at least until the compiler is
@@ -183,10 +176,8 @@
{
sAllClassesLock = IOLockAlloc();
sStalledClassesLock = IOLockAlloc();
- sInstancesLock = IOLockAlloc();
-}
-
-#if APPLE_KEXT_VTABLE_PADDING
+}
+
/*********************************************************************
* If you need this slot you had better setup an IOCTL style interface.
* 'Cause the whole kernel world depends on OSMetaClassBase and YOU
@@ -195,7 +186,6 @@
void
OSMetaClassBase::_RESERVEDOSMetaClassBase7()
{ panic("OSMetaClassBase::_RESERVEDOSMetaClassBase%d called.", 7); }
-#endif
/*********************************************************************
*********************************************************************/
@@ -295,7 +285,6 @@
* OSMetaClass
*********************************************************************/
-#if APPLE_KEXT_VTABLE_PADDING
/*********************************************************************
* Reserved functions.
*********************************************************************/
@@ -315,7 +304,6 @@
{ panic("OSMetaClass::_RESERVEDOSMetaClass%d called", 6); }
void OSMetaClass::_RESERVEDOSMetaClass7()
{ panic("OSMetaClass::_RESERVEDOSMetaClass%d called", 7); }
-#endif
/*********************************************************************
*********************************************************************/
@@ -389,12 +377,6 @@
classSize = inClassSize;
superClassLink = inSuperClass;
- reserved = IONew(ExpansionData, 1);
- bzero(reserved, sizeof(ExpansionData));
-#if IOTRACKING
- reserved->tracking = IOTrackingQueueAlloc(inClassName, inClassSize, 0, true);
-#endif
-
/* Hack alert: We are just casting inClassName and storing it in
* an OSString * instance variable. This may be because you can't
* create C++ objects in static constructors, but I really don't know!
@@ -417,7 +399,7 @@
int newSize = oldSize
+ kKModCapacityIncrement * sizeof(OSMetaClass *);
- sStalled->classes = (OSMetaClass **)kalloc_tag(newSize, VM_KERN_MEMORY_OSKEXT);
+ sStalled->classes = (OSMetaClass **)kalloc(newSize);
if (!sStalled->classes) {
sStalled->classes = oldStalled;
sStalled->result = kOSMetaClassNoTempData;
@@ -427,7 +409,7 @@
sStalled->capacity += kKModCapacityIncrement;
memmove(sStalled->classes, oldStalled, oldSize);
kfree(oldStalled, oldSize);
- OSMETA_ACCUMSIZE(((size_t)newSize) - ((size_t)oldSize));
+ ACCUMSIZE(newSize - oldSize);
}
sStalled->classes[sStalled->count++] = this;
@@ -438,7 +420,7 @@
*********************************************************************/
OSMetaClass::~OSMetaClass()
{
- OSKext * myKext = reserved ? reserved->kext : 0; // do not release
+ OSKext * myKext = (OSKext *)reserved; // do not release
/* Hack alert: 'className' is a C string during early C++ init, and
* is converted to a real OSSymbol only when we record the OSKext in
@@ -490,15 +472,12 @@
}
}
}
-#if IOTRACKING
- IOTrackingQueueFree(reserved->tracking);
-#endif
- IODelete(reserved, ExpansionData, 1);
}
/*********************************************************************
* Empty overrides.
*********************************************************************/
+void * OSMetaClass::operator new(__unused size_t size) { return 0; }
void OSMetaClass::retain() const { }
void OSMetaClass::release() const { }
void OSMetaClass::release(__unused int when) const { }
@@ -512,16 +491,9 @@
const char *
OSMetaClass::getClassName() const
{
- if (!className) return NULL;
return className->getCStringNoCopy();
}
-/*********************************************************************
-*********************************************************************/
-const OSSymbol *
-OSMetaClass::getClassNameSymbol() const
-{
- return className;
-}
+
/*********************************************************************
*********************************************************************/
unsigned int
@@ -538,15 +510,15 @@
IOLockLock(sStalledClassesLock);
assert (sStalled == NULL);
- sStalled = (StalledData *)kalloc_tag(sizeof(* sStalled), VM_KERN_MEMORY_OSKEXT);
+ sStalled = (StalledData *)kalloc(sizeof(* sStalled));
if (sStalled) {
sStalled->classes = (OSMetaClass **)
- kalloc_tag(kKModCapacityIncrement * sizeof(OSMetaClass *), VM_KERN_MEMORY_OSKEXT);
+ kalloc(kKModCapacityIncrement * sizeof(OSMetaClass *));
if (!sStalled->classes) {
kfree(sStalled, sizeof(*sStalled));
return 0;
}
- OSMETA_ACCUMSIZE((kKModCapacityIncrement * sizeof(OSMetaClass *)) +
+ ACCUMSIZE((kKModCapacityIncrement * sizeof(OSMetaClass *)) +
sizeof(*sStalled));
sStalled->result = kOSReturnSuccess;
@@ -598,7 +570,6 @@
result = kOSMetaClassNoDicts;
break;
}
- sAllClassesDict->setOptions(OSCollection::kSort, OSCollection::kSort);
// No break; fall through
@@ -633,7 +604,7 @@
*/
IOLockLock(sAllClassesLock);
for (i = 0; i < sStalled->count; i++) {
- const OSMetaClass * me = sStalled->classes[i];
+ OSMetaClass * me = sStalled->classes[i];
OSMetaClass * orig = OSDynamicCast(OSMetaClass,
sAllClassesDict->getObject((const char *)me->className));
@@ -646,13 +617,10 @@
"OSMetaClass: Kext %s class %s is a duplicate;"
"kext %s already has a class by that name.",
sStalled->kextIdentifier, (const char *)me->className,
- ((OSKext *)orig->reserved->kext)->getIdentifierCString());
+ ((OSKext *)orig->reserved)->getIdentifierCString());
result = kOSMetaClassDuplicateClass;
break;
}
- unsigned int depth = 1;
- while ((me = me->superClassLink)) depth++;
- if (depth > sDeepestClass) sDeepestClass = depth;
}
IOLockUnlock(sAllClassesLock);
@@ -680,7 +648,7 @@
/* Do not retain the kext object here.
*/
- me->reserved->kext = myKext;
+ me->reserved = (ExpansionData *)myKext;
if (myKext) {
result = myKext->addClass(me, sStalled->count);
if (result != kOSReturnSuccess) {
@@ -715,7 +683,7 @@
OSSafeRelease(myKext);
if (sStalled) {
- OSMETA_ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +
+ ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +
sizeof(*sStalled)));
kfree(sStalled->classes, sStalled->capacity * sizeof(OSMetaClass *));
kfree(sStalled, sizeof(*sStalled));
@@ -749,7 +717,7 @@
}
if (((int)instanceCount) < 0) {
- OSKext * myKext = reserved->kext;
+ OSKext * myKext = (OSKext *)reserved;
OSKextLog(myKext, kOSMetaClassLogSpec,
// xxx - this phrasing is rather cryptic
@@ -786,140 +754,6 @@
OSKext::reportOSMetaClassInstances(kextIdentifier,
kOSKextLogExplicitLevel);
return;
-}
-/*********************************************************************
-*********************************************************************/
-
-void
-OSMetaClass::addInstance(const OSObject * instance, bool super) const
-{
- if (!super) IOLockLock(sInstancesLock);
-
- if (!reserved->instances) {
- reserved->instances = OSOrderedSet::withCapacity(16);
- if (superClassLink) {
- superClassLink->addInstance(reserved->instances, true);
- }
- }
- reserved->instances->setLastObject(instance);
-
- if (!super) IOLockUnlock(sInstancesLock);
-}
-
-void
-OSMetaClass::removeInstance(const OSObject * instance, bool super) const
-{
- if (!super) IOLockLock(sInstancesLock);
-
- if (reserved->instances) {
- reserved->instances->removeObject(instance);
- if (0 == reserved->instances->getCount()) {
- if (superClassLink) {
- superClassLink->removeInstance(reserved->instances, true);
- }
- IOLockLock(sAllClassesLock);
- reserved->instances->release();
- reserved->instances = 0;
- IOLockUnlock(sAllClassesLock);
- }
- }
-
- if (!super) IOLockUnlock(sInstancesLock);
-}
-
-void
-OSMetaClass::applyToInstances(OSOrderedSet * set,
- OSMetaClassInstanceApplierFunction applier,
- void * context)
-{
- enum { kLocalDepth = 24 };
- unsigned int _nextIndex[kLocalDepth];
- OSOrderedSet * _sets[kLocalDepth];
- unsigned int * nextIndex = &_nextIndex[0];
- OSOrderedSet ** sets = &_sets[0];
- OSObject * obj;
- OSOrderedSet * childSet;
- unsigned int maxDepth;
- unsigned int idx;
- unsigned int level;
- bool done;
-
- maxDepth = sDeepestClass;
- if (maxDepth > kLocalDepth)
- {
- nextIndex = IONew(typeof(nextIndex[0]), maxDepth);
- sets = IONew(typeof(sets[0]), maxDepth);
- }
- done = false;
- level = 0;
- idx = 0;
- do
- {
- while (!done && (obj = set->getObject(idx++)))
- {
- if ((childSet = OSDynamicCast(OSOrderedSet, obj)))
- {
- if (level >= maxDepth) panic(">maxDepth");
- sets[level] = set;
- nextIndex[level] = idx;
- level++;
- set = childSet;
- idx = 0;
- break;
- }
- done = (*applier)(obj, context);
- }
- if (!obj)
- {
- if (!done && level)
- {
- level--;
- set = sets[level];
- idx = nextIndex[level];
- } else done = true;
- }
- }
- while (!done);
- if (maxDepth > kLocalDepth)
- {
- IODelete(nextIndex, typeof(nextIndex[0]), maxDepth);
- IODelete(sets, typeof(sets[0]), maxDepth);
- }
-}
-
-void
-OSMetaClass::applyToInstances(OSMetaClassInstanceApplierFunction applier,
- void * context) const
-{
- IOLockLock(sInstancesLock);
- if (reserved->instances) applyToInstances(reserved->instances, applier, context);
- IOLockUnlock(sInstancesLock);
-}
-
-void
-OSMetaClass::applyToInstancesOfClassName(
- const OSSymbol * name,
- OSMetaClassInstanceApplierFunction applier,
- void * context)
-{
- OSMetaClass * meta;
- OSOrderedSet * set = 0;
-
- IOLockLock(sAllClassesLock);
- if (sAllClassesDict
- && (meta = (OSMetaClass *) sAllClassesDict->getObject(name))
- && (set = meta->reserved->instances))
- {
- set->retain();
- }
- IOLockUnlock(sAllClassesLock);
-
- if (!set) return;
-
- IOLockLock(sInstancesLock);
- applyToInstances(set, applier, context);
- IOLockUnlock(sInstancesLock);
- set->release();
}
/*********************************************************************
@@ -1087,7 +921,7 @@
const OSSymbol *
OSMetaClass::getKmodName() const
{
- OSKext * myKext = reserved ? reserved->kext : 0;
+ OSKext * myKext = (OSKext *)reserved;
if (myKext) {
return myKext->getIdentifier();
}
@@ -1197,61 +1031,3 @@
return;
}
-
-
-/*********************************************************************
-*********************************************************************/
-
-#if IOTRACKING
-
-void *OSMetaClass::trackedNew(size_t size)
-{
- IOTracking * mem;
-
- mem = (typeof(mem)) kalloc_tag_bt(size + sizeof(IOTracking), VM_KERN_MEMORY_LIBKERN);
- assert(mem);
- if (!mem) return (mem);
-
- memset(mem, 0, size + sizeof(IOTracking));
- mem++;
-
- OSIVAR_ACCUMSIZE(size);
-
- return (mem);
-}
-
-void OSMetaClass::trackedDelete(void * instance, size_t size)
-{
- IOTracking * mem = (typeof(mem)) instance; mem--;
-
- kfree(mem, size + sizeof(IOTracking));
- OSIVAR_ACCUMSIZE(-size);
-}
-
-void OSMetaClass::trackedInstance(OSObject * instance) const
-{
- IOTracking * mem = (typeof(mem)) instance; mem--;
-
- return (IOTrackingAdd(reserved->tracking, mem, classSize, false));
-}
-
-void OSMetaClass::trackedFree(OSObject * instance) const
-{
- IOTracking * mem = (typeof(mem)) instance; mem--;
-
- return (IOTrackingRemove(reserved->tracking, mem, classSize));
-}
-
-void OSMetaClass::trackedAccumSize(OSObject * instance, size_t size) const
-{
- IOTracking * mem = (typeof(mem)) instance; mem--;
-
- return (IOTrackingAccumSize(reserved->tracking, mem, size));
-}
-
-IOTrackingQueue * OSMetaClass::getTracking() const
-{
- return (reserved->tracking);
-}
-
-#endif /* IOTRACKING */