/*
- * Copyright (c) 2000-2006 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <IOKit/IOLib.h>
+#include <IOKit/IOKitDebug.h>
+
+
__BEGIN_DECLS
#include <sys/systm.h>
/*********************************************************************
* 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
} * sStalled;
IOLock * sStalledClassesLock = NULL;
-
struct ExpansionData {
- OSOrderedSet * instances;
- OSKext * kext;
+ OSOrderedSet * instances;
+ OSKext * kext;
+ uint32_t retain;
+#if IOTRACKING
+ IOTrackingQueue * tracking;
+#endif
};
reserved = IONew(ExpansionData, 1);
bzero(reserved, sizeof(ExpansionData));
+#if IOTRACKING
+ uint32_t numSiteQs = 0;
+ if ((this == &OSSymbol ::gMetaClass)
+ || (this == &OSString ::gMetaClass)
+ || (this == &OSNumber ::gMetaClass)
+ || (this == &OSString ::gMetaClass)
+ || (this == &OSData ::gMetaClass)
+ || (this == &OSDictionary::gMetaClass)
+ || (this == &OSArray ::gMetaClass)
+ || (this == &OSSet ::gMetaClass)) numSiteQs = 27;
+
+ reserved->tracking = IOTrackingQueueAlloc(inClassName, (uintptr_t) this,
+ inClassSize, 0, kIOTrackingQueueTypeAlloc,
+ numSiteQs);
+#endif
/* Hack alert: We are just casting inClassName and storing it in
* an OSString * instance variable. This may be because you can't
int newSize = oldSize
+ kKModCapacityIncrement * sizeof(OSMetaClass *);
- sStalled->classes = (OSMetaClass **)kalloc(newSize);
+ sStalled->classes = (OSMetaClass **)kalloc_tag(newSize, VM_KERN_MEMORY_OSKEXT);
if (!sStalled->classes) {
sStalled->classes = oldStalled;
sStalled->result = kOSMetaClassNoTempData;
sStalled->capacity += kKModCapacityIncrement;
memmove(sStalled->classes, oldStalled, oldSize);
kfree(oldStalled, oldSize);
- ACCUMSIZE(newSize - oldSize);
+ OSMETA_ACCUMSIZE(((size_t)newSize) - ((size_t)oldSize));
}
sStalled->classes[sStalled->count++] = this;
}
}
}
+#if IOTRACKING
+ IOTrackingQueueFree(reserved->tracking);
+#endif
+ IODelete(reserved, ExpansionData, 1);
}
/*********************************************************************
IOLockLock(sStalledClassesLock);
assert (sStalled == NULL);
- sStalled = (StalledData *)kalloc(sizeof(* sStalled));
+ sStalled = (StalledData *)kalloc_tag(sizeof(* sStalled), VM_KERN_MEMORY_OSKEXT);
if (sStalled) {
sStalled->classes = (OSMetaClass **)
- kalloc(kKModCapacityIncrement * sizeof(OSMetaClass *));
+ kalloc_tag(kKModCapacityIncrement * sizeof(OSMetaClass *), VM_KERN_MEMORY_OSKEXT);
if (!sStalled->classes) {
kfree(sStalled, sizeof(*sStalled));
return 0;
}
- ACCUMSIZE((kKModCapacityIncrement * sizeof(OSMetaClass *)) +
+ OSMETA_ACCUMSIZE((kKModCapacityIncrement * sizeof(OSMetaClass *)) +
sizeof(*sStalled));
sStalled->result = kOSReturnSuccess;
case kNoDictionaries:
sBootstrapState = kMakingDictionaries;
// No break; fall through
+ [[clang::fallthrough]];
case kMakingDictionaries:
sAllClassesDict = OSDictionary::withCapacity(kClassCapacityIncrement);
}
sAllClassesDict->setOptions(OSCollection::kSort, OSCollection::kSort);
- // No break; fall through
+ // No break; fall through
+ [[clang::fallthrough]];
case kCompletedBootstrap:
{
/* Log this error here so we can include the class name.
* xxx - we should look up the other kext that defines the class
*/
+#if CONFIG_EMBEDDED
+ panic(
+#else
OSKextLog(myKext, kOSMetaClassLogSpec,
+#endif /* CONFIG_EMBEDDED */
"OSMetaClass: Kext %s class %s is a duplicate;"
"kext %s already has a class by that name.",
sStalled->kextIdentifier, (const char *)me->className,
OSMetaClassLogErrorForKext(result, myKext);
}
- OSSafeRelease(myKextName);
- OSSafeRelease(myKext);
+ OSSafeReleaseNULL(myKextName);
+ OSSafeReleaseNULL(myKext);
if (sStalled) {
- ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +
+ OSMETA_ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +
sizeof(*sStalled)));
kfree(sStalled->classes, sStalled->capacity * sizeof(OSMetaClass *));
kfree(sStalled, sizeof(*sStalled));
result = theKext->hasOSMetaClassInstances();
finish:
- OSSafeRelease(theKext);
+ OSSafeReleaseNULL(theKext);
return result;
}
OSKext::considerUnloads();
}
+/*********************************************************************
+*********************************************************************/
+bool
+OSMetaClass::removeClasses(OSCollection * metaClasses)
+{
+ OSCollectionIterator * classIterator;
+ OSMetaClass * checkClass;
+ bool result;
+
+ classIterator = OSCollectionIterator::withCollection(metaClasses);
+ if (!classIterator) return (false);
+
+ IOLockLock(sAllClassesLock);
+
+ result = false;
+ do
+ {
+ while ((checkClass = (OSMetaClass *)classIterator->getNextObject())
+ && !checkClass->getInstanceCount()
+ && !checkClass->reserved->retain) {}
+ if (checkClass) break;
+ classIterator->reset();
+ while ((checkClass = (OSMetaClass *)classIterator->getNextObject()))
+ {
+ sAllClassesDict->removeObject(checkClass->className);
+ }
+ result = true;
+ }
+ while (false);
+
+ IOLockUnlock(sAllClassesLock);
+ OSSafeReleaseNULL(classIterator);
+
+ return (result);
+}
+
+
/*********************************************************************
*********************************************************************/
const OSMetaClass *
return retMeta;
}
+/*********************************************************************
+*********************************************************************/
+const OSMetaClass *
+OSMetaClass::copyMetaClassWithName(const OSSymbol * name)
+{
+ const OSMetaClass * meta;
+
+ if (!name) return (0);
+
+ meta = 0;
+ IOLockLock(sAllClassesLock);
+ if (sAllClassesDict) {
+ meta = (OSMetaClass *) sAllClassesDict->getObject(name);
+ if (meta) OSIncrementAtomic(&meta->reserved->retain);
+ }
+ IOLockUnlock(sAllClassesLock);
+
+ return (meta);
+}
+
+/*********************************************************************
+*********************************************************************/
+void
+OSMetaClass::releaseMetaClass() const
+{
+ OSDecrementAtomic(&reserved->retain);
+}
+
/*********************************************************************
*********************************************************************/
OSObject *
OSMetaClass::allocClassWithName(const OSSymbol * name)
{
- OSObject * result = 0;
+ const OSMetaClass * meta;
+ OSObject * result;
- const OSMetaClass * const meta = getMetaClassWithName(name);
-
- if (meta) {
+ result = 0;
+ meta = copyMetaClassWithName(name);
+ if (meta)
+ {
result = meta->alloc();
+ meta->releaseMetaClass();
}
return result;
} while (0);
finish:
- OSSafeRelease(classDict);
+ OSSafeReleaseNULL(classDict);
IOLockUnlock(sAllClassesLock);
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, VM_KERN_MEMORY_NONE));
+}
+
+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 */
projects / apple / xnu.git / blobdiff