Loading...
--- xnu/xnu-3248.50.21/libkern/c++/OSObject.cpp
+++ xnu/xnu-1228.3.13/libkern/c++/OSObject.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000 Apple Inc. All rights reserved.
+ * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
@@ -28,7 +28,6 @@
/* OSObject.cpp created by gvdl on Fri 1998-11-17 */
#include <libkern/c++/OSObject.h>
-#include <libkern/c++/OSString.h>
#include <libkern/c++/OSArray.h>
#include <libkern/c++/OSSerialize.h>
#include <libkern/c++/OSLib.h>
@@ -45,6 +44,11 @@
int debug_ivars_size;
__END_DECLS
+#if OSALLOCDEBUG
+#define ACCUMSIZE(s) do { debug_ivars_size += (s); } while(0)
+#else
+#define ACCUMSIZE(s)
+#endif
// OSDefineMetaClassAndAbstractStructors(OSObject, 0);
/* Class global data */
@@ -53,6 +57,8 @@
const OSMetaClass * const OSObject::superClass = 0;
/* Class member functions - Can't use defaults */
+OSObject::OSObject() { retainCount = 1; }
+OSObject::OSObject(const OSMetaClass *) { retainCount = 1; }
OSObject::~OSObject() { }
const OSMetaClass * OSObject::getMetaClass() const
{ return &gMetaClass; }
@@ -81,11 +87,49 @@
OSMetaClassDefineReservedUnused(OSObject, 14);
OSMetaClassDefineReservedUnused(OSObject, 15);
+#ifdef __ppc__
+OSMetaClassDefineReservedUnused(OSObject, 16);
+OSMetaClassDefineReservedUnused(OSObject, 17);
+OSMetaClassDefineReservedUnused(OSObject, 18);
+OSMetaClassDefineReservedUnused(OSObject, 19);
+OSMetaClassDefineReservedUnused(OSObject, 20);
+OSMetaClassDefineReservedUnused(OSObject, 21);
+OSMetaClassDefineReservedUnused(OSObject, 22);
+OSMetaClassDefineReservedUnused(OSObject, 23);
+OSMetaClassDefineReservedUnused(OSObject, 24);
+OSMetaClassDefineReservedUnused(OSObject, 25);
+OSMetaClassDefineReservedUnused(OSObject, 26);
+OSMetaClassDefineReservedUnused(OSObject, 27);
+OSMetaClassDefineReservedUnused(OSObject, 28);
+OSMetaClassDefineReservedUnused(OSObject, 29);
+OSMetaClassDefineReservedUnused(OSObject, 30);
+OSMetaClassDefineReservedUnused(OSObject, 31);
+#endif
+
static const char *getClassName(const OSObject *obj)
{
const OSMetaClass *meta = obj->getMetaClass();
return (meta) ? meta->getClassName() : "unknown class?";
}
+
+bool OSObject::init()
+ { return true; }
+
+#if (!__ppc__) || (__GNUC__ < 3)
+
+// Implemented in assembler in post gcc 3.x systems as we have a problem
+// where the destructor in gcc2.95 gets 2 arguments. The second argument
+// appears to be a flag argument. I have copied the assembler from Puma xnu
+// to OSRuntimeSupport.c So for 2.95 builds use the C
+void OSObject::free()
+{
+ const OSMetaClass *meta = getMetaClass();
+
+ if (meta)
+ meta->instanceDestructed();
+ delete this;
+}
+#endif /* (!__ppc__) || (__GNUC__ < 3) */
int OSObject::getRetainCount() const
{
@@ -121,7 +165,7 @@
#if !DEBUG
break; // Break out of update loop which pegs the reference
-#else /* DEBUG */
+#else DEBUG
// @@@ gvdl: eventually need to make this panic optional
// based on a boot argument i.e. debug= boot flag
msg = "About to wrap the reference count, reference leak?";
@@ -131,7 +175,7 @@
}
newCount = origCount + inc;
- } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
+ } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
}
void OSObject::taggedRelease(const void *tag) const
@@ -168,7 +212,7 @@
#if !DEBUG
return; // return out of function which pegs the reference
-#else /* DEBUG */
+#else DEBUG
// @@@ gvdl: eventually need to make this panic optional
// based on a boot argument i.e. debug= boot flag
panic("OSObject::refcount: %s",
@@ -182,128 +226,137 @@
else
newCount = actualCount;
- } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
+ } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
//
// This panic means that we have just attempted to release an object
- // whose retain count has gone to less than the number of collections
+ // who's retain count has gone to less than the number of collections
// it is a member off. Take a panic immediately.
- // In fact the panic MAY not be a registry corruption but it is
+ // In Fact the panic MAY not be a registry corruption but it is
// ALWAYS the wrong thing to do. I call it a registry corruption 'cause
// the registry is the biggest single use of a network of collections.
//
-// xxx - this error message is overly-specific;
-// xxx - any code in the kernel could trip this,
-// xxx - and it applies as noted to all collections, not just the registry
- if ((UInt16) actualCount < (actualCount >> 16)) {
- panic("A kext releasing a(n) %s has corrupted the registry.",
- getClassName(this));
+ if ((UInt16) actualCount < (actualCount >> 16))
+ panic("A driver releasing a(n) %s has corrupted the registry\n",
+ getClassName(this));
+
+ // Check for a 'free' condition and that if we are first through
+ if (newCount == 0xffff)
+ ((OSObject *) this)->free();
+}
+
+void OSObject::release() const
+{
+ taggedRelease(0);
+}
+
+void OSObject::retain() const
+{
+ taggedRetain(0);
+}
+
+void OSObject::release(int when) const
+{
+ taggedRelease(0, when);
+}
+
+bool OSObject::serialize(OSSerialize *s) const
+{
+ if (s->previouslySerialized(this)) return true;
+
+ if (!s->addXMLStartTag(this, "string")) return false;
+
+ if (!s->addString(getClassName(this))) return false;
+ if (!s->addString(" is not serializable")) return false;
+
+ return s->addXMLEndTag("string");
+}
+
+
+thread_t gOSObjectTrackThread;
+
+queue_head_t gOSObjectTrackList =
+ { (queue_t) &gOSObjectTrackList, (queue_t) &gOSObjectTrackList };
+
+lck_spin_t gOSObjectTrackLock;
+
+OSArray * OSFlushObjectTrackList(void)
+{
+ OSArray * array;
+ queue_entry_t next;
+
+ array = OSArray::withCapacity(16);
+
+ lck_spin_lock(&gOSObjectTrackLock);
+ while (!queue_empty(&gOSObjectTrackList))
+ {
+ next = queue_first(&gOSObjectTrackList);
+ remque(next);
+ lck_spin_unlock(&gOSObjectTrackLock);
+ array->setObject((OSObject *) (next + 1));
+ lck_spin_lock(&gOSObjectTrackLock);
}
-
- // Check for a 'free' condition and that if we are first through
- if (newCount == 0xffff) {
- (const_cast<OSObject *>(this))->free();
+ lck_spin_unlock(&gOSObjectTrackLock);
+
+ return (array);
+}
+
+struct OSObjectTracking
+{
+ queue_chain_t link;
+ void * bt[14];
+};
+
+void *OSObject::operator new(size_t size)
+{
+ size_t tracking = (gIOKitDebug & kOSTraceObjectAlloc)
+ ? sizeof(OSObjectTracking) : 0;
+ OSObjectTracking * mem = (OSObjectTracking *) kalloc(size + tracking);
+
+ assert(mem);
+
+ if (tracking)
+ {
+ if ((((thread_t) 1) == gOSObjectTrackThread) || (current_thread() == gOSObjectTrackThread))
+ {
+ (void) OSBacktrace(&mem->bt[0], sizeof(mem->bt) / sizeof(mem->bt[0]));
+ lck_spin_lock(&gOSObjectTrackLock);
+ enqueue_tail(&gOSObjectTrackList, &mem->link);
+ lck_spin_unlock(&gOSObjectTrackLock);
+ }
+ else
+ mem->link.next = 0;
+ mem++;
}
-}
-
-void OSObject::release() const
-{
- taggedRelease(0);
-}
-
-void OSObject::retain() const
-{
- taggedRetain(0);
-}
-
-void OSObject::release(int when) const
-{
- taggedRelease(0, when);
-}
-
-bool OSObject::serialize(OSSerialize *s) const
-{
- char cstr[128];
- bool ok;
-
- snprintf(cstr, sizeof(cstr), "%s is not serializable", getClassName(this));
-
- OSString * str;
- str = OSString::withCStringNoCopy(cstr);
- if (!str) return false;
-
- ok = str->serialize(s);
- str->release();
-
- return (ok);
-}
-
-void *OSObject::operator new(size_t size)
-{
-#if IOTRACKING
- if (kIOTracking & gIOKitDebug) return (OSMetaClass::trackedNew(size));
-#endif
-
- void * mem = kalloc_tag_bt(size, VM_KERN_MEMORY_LIBKERN);
- assert(mem);
+
bzero(mem, size);
- OSIVAR_ACCUMSIZE(size);
+
+ ACCUMSIZE(size);
return (void *) mem;
}
-void OSObject::operator delete(void * mem, size_t size)
-{
- if (!mem) return;
-
-#if IOTRACKING
- if (kIOTracking & gIOKitDebug) return (OSMetaClass::trackedDelete(mem, size));
-#endif
-
- kfree(mem, size);
- OSIVAR_ACCUMSIZE(-size);
-}
-
-bool OSObject::init()
-{
-#if IOTRACKING
- if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this);
-#endif
- return true;
-}
-
-void OSObject::free()
-{
- const OSMetaClass *meta = getMetaClass();
-
- if (meta)
+void OSObject::operator delete(void *_mem, size_t size)
+{
+ size_t tracking = (gIOKitDebug & kOSTraceObjectAlloc)
+ ? sizeof(OSObjectTracking) : 0;
+ OSObjectTracking * mem = (OSObjectTracking *) _mem;
+
+ if (!mem)
+ return;
+
+ if (tracking)
{
- meta->instanceDestructed();
-#if IOTRACKING
- if (kIOTracking & gIOKitDebug) getMetaClass()->trackedFree(this);
-#endif
+ mem--;
+ if (mem->link.next)
+ {
+ lck_spin_lock(&gOSObjectTrackLock);
+ remque(&mem->link);
+ lck_spin_unlock(&gOSObjectTrackLock);
+ }
}
- delete this;
-}
-
-#if IOTRACKING
-void OSObject::trackingAccumSize(size_t size)
-{
- if (kIOTracking & gIOKitDebug) getMetaClass()->trackedAccumSize(this, size);
-}
-#endif
-
-/* Class member functions - Can't use defaults */
-/* During constructor vtable is always OSObject's - can't call any subclass */
-
-OSObject::OSObject()
-{
- retainCount = 1;
-// if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this);
-}
-
-OSObject::OSObject(const OSMetaClass *)
-{
- retainCount = 1;
-// if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this);
-}
+
+ kfree(mem, size + tracking);
+
+ ACCUMSIZE(-size);
+}