xnu-4570.1.46.tar.gz

[apple/xnu.git] / libkern / c++ / OSMetaClass.cpp

diff --git a/libkern/c++/OSMetaClass.cpp b/libkern/c++/OSMetaClass.cpp
index b32ab8c9b7a6dd3c9a17566b873de32a8df4edcc..3d7c2f6e44ab396d48646f2a90bb09bcffbcf065 100644 (file)
--- a/libkern/c++/OSMetaClass.cpp
+++ b/libkern/c++/OSMetaClass.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2006 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2016 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -110,6 +110,7 @@ IOLock * sStalledClassesLock = NULL;
 struct ExpansionData {
     OSOrderedSet    * instances;
     OSKext          * kext;
 struct ExpansionData {
     OSOrderedSet    * instances;
     OSKext          * kext;

+    uint32_t          retain;

 #if IOTRACKING
     IOTrackingQueue * tracking;
 #endif
 #if IOTRACKING
     IOTrackingQueue * tracking;
 #endif


@@ -392,7 +393,19 @@ OSMetaClass::OSMetaClass(
     reserved = IONew(ExpansionData, 1);
     bzero(reserved, sizeof(ExpansionData));
 #if IOTRACKING
     reserved = IONew(ExpansionData, 1);
     bzero(reserved, sizeof(ExpansionData));
 #if IOTRACKING

-    reserved->tracking = IOTrackingQueueAlloc(inClassName, inClassSize, 0, true);
+    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
 #endif
 
    /* Hack alert: We are just casting inClassName and storing it in


@@ -591,6 +604,7 @@ OSMetaClass::postModLoad(void * loadHandle)
         case kNoDictionaries:
             sBootstrapState = kMakingDictionaries;
             // No break; fall through
         case kNoDictionaries:
             sBootstrapState = kMakingDictionaries;
             // No break; fall through

+           [[clang::fallthrough]];

             
         case kMakingDictionaries:
             sAllClassesDict = OSDictionary::withCapacity(kClassCapacityIncrement);
             
         case kMakingDictionaries:
             sAllClassesDict = OSDictionary::withCapacity(kClassCapacityIncrement);


@@ -600,7 +614,8 @@ OSMetaClass::postModLoad(void * loadHandle)
             }
             sAllClassesDict->setOptions(OSCollection::kSort, OSCollection::kSort);
 
             }
             sAllClassesDict->setOptions(OSCollection::kSort, OSCollection::kSort);
 

-        // No break; fall through
+           // No break; fall through
+           [[clang::fallthrough]];

 
         case kCompletedBootstrap:
         {
 
         case kCompletedBootstrap:
         {


@@ -642,7 +657,11 @@ OSMetaClass::postModLoad(void * loadHandle)
                    /* Log this error here so we can include the class name.
                     * xxx - we should look up the other kext that defines the class
                     */
                    /* 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,
                     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,
                         "OSMetaClass: Kext %s class %s is a duplicate;"
                         "kext %s already has a class by that name.",
                          sStalled->kextIdentifier, (const char *)me->className,


@@ -711,8 +730,8 @@ finish:
         OSMetaClassLogErrorForKext(result, myKext);
     }
 
         OSMetaClassLogErrorForKext(result, myKext);
     }
 

-    OSSafeRelease(myKextName);
-    OSSafeRelease(myKext);
+    OSSafeReleaseNULL(myKextName);
+    OSSafeReleaseNULL(myKext);

 
     if (sStalled) {
         OSMETA_ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +
 
     if (sStalled) {
         OSMETA_ACCUMSIZE(-(sStalled->capacity * sizeof(OSMetaClass *) +


@@ -774,7 +793,7 @@ OSMetaClass::modHasInstance(const char * kextIdentifier)
     result = theKext->hasOSMetaClassInstances();
 
 finish:
     result = theKext->hasOSMetaClassInstances();
 
 finish:

-    OSSafeRelease(theKext);
+    OSSafeReleaseNULL(theKext);

     return result;
 }
 
     return result;
 }
 


@@ -930,6 +949,43 @@ OSMetaClass::considerUnloads()
     OSKext::considerUnloads();
 }
 
     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 *
 /*********************************************************************
 *********************************************************************/
 const OSMetaClass *


@@ -950,17 +1006,48 @@ OSMetaClass::getMetaClassWithName(const OSSymbol * name)
     return retMeta;
 }
 
     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 *
 OSMetaClass::allocClassWithName(const OSSymbol * name)
 {

-    OSObject * result = 0;
-
-    const OSMetaClass * const meta = getMetaClassWithName(name);
+    const OSMetaClass * meta;
+    OSObject          * result;

 
 

-    if (meta) {
+    result = 0;
+    meta = copyMetaClassWithName(name);
+    if (meta)
+    {

         result = meta->alloc();
         result = meta->alloc();

+        meta->releaseMetaClass();

     }
 
     return result;
     }
 
     return result;


@@ -1191,7 +1278,7 @@ OSMetaClass::serializeClassDictionary(OSDictionary * serializeDictionary)
     } while (0);
 
 finish:
     } while (0);
 
 finish:

-    OSSafeRelease(classDict);
+    OSSafeReleaseNULL(classDict);

 
     IOLockUnlock(sAllClassesLock);
 
 
     IOLockUnlock(sAllClassesLock);
 


@@ -1232,7 +1319,7 @@ void OSMetaClass::trackedInstance(OSObject * instance) const
 {
     IOTracking * mem = (typeof(mem)) instance; mem--;
 
 {
     IOTracking * mem = (typeof(mem)) instance; mem--;
 

-    return (IOTrackingAdd(reserved->tracking, mem, classSize, false));
+    return (IOTrackingAdd(reserved->tracking, mem, classSize, false, VM_KERN_MEMORY_NONE));

 }
 
 void OSMetaClass::trackedFree(OSObject * instance) const
 }
 
 void OSMetaClass::trackedFree(OSObject * instance) const


@@ -1254,4 +1341,4 @@ IOTrackingQueue * OSMetaClass::getTracking() const
     return (reserved->tracking);
 }
 
     return (reserved->tracking);
 }
 

-#endif /* IOTRACKING */
\ No newline at end of file
+#endif /* IOTRACKING */