#include <libkern/c++/OSObject.h>
#include <libkern/c++/OSArray.h>
#include <libkern/c++/OSSerialize.h>
#include <libkern/c++/OSLib.h>
#include <libkern/OSDebug.h>
#include <libkern/c++/OSCPPDebug.h>
#include <IOKit/IOKitDebug.h>
#include <libkern/OSAtomic.h>
#include <libkern/c++/OSCollection.h>
#include <kern/queue.h>
__BEGIN_DECLS
int debug_ivars_size;
__END_DECLS
#if OSALLOCDEBUG
#define ACCUMSIZE(s) do { debug_ivars_size += (s); } while(0)
#else
#define ACCUMSIZE(s)
#endif
OSObject::MetaClass OSObject::gMetaClass;
const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass;
const OSMetaClass * const OSObject::superClass = 0;
OSObject::OSObject() { retainCount = 1; }
OSObject::OSObject(const OSMetaClass *) { retainCount = 1; }
OSObject::~OSObject() { }
const OSMetaClass * OSObject::getMetaClass() const
{ return &gMetaClass; }
OSObject *OSObject::MetaClass::alloc() const { return 0; }
OSObject::MetaClass::MetaClass()
: OSMetaClass("OSObject", OSObject::superClass, sizeof(OSObject))
{ }
OSMetaClassDefineReservedUnused(OSObject, 0);
OSMetaClassDefineReservedUnused(OSObject, 1);
OSMetaClassDefineReservedUnused(OSObject, 2);
OSMetaClassDefineReservedUnused(OSObject, 3);
OSMetaClassDefineReservedUnused(OSObject, 4);
OSMetaClassDefineReservedUnused(OSObject, 5);
OSMetaClassDefineReservedUnused(OSObject, 6);
OSMetaClassDefineReservedUnused(OSObject, 7);
OSMetaClassDefineReservedUnused(OSObject, 8);
OSMetaClassDefineReservedUnused(OSObject, 9);
OSMetaClassDefineReservedUnused(OSObject, 10);
OSMetaClassDefineReservedUnused(OSObject, 11);
OSMetaClassDefineReservedUnused(OSObject, 12);
OSMetaClassDefineReservedUnused(OSObject, 13);
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)
void OSObject::free()
{
const OSMetaClass *meta = getMetaClass();
if (meta)
meta->instanceDestructed();
delete this;
}
#endif
int OSObject::getRetainCount() const
{
return (int) ((UInt16) retainCount);
}
void OSObject::taggedRetain(const void *tag) const
{
volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
UInt32 inc = 1;
UInt32 origCount;
UInt32 newCount;
if ((const void *) OSTypeID(OSCollection) == tag)
inc |= (1UL<<16);
do {
origCount = *countP;
if ( ((UInt16) origCount | 0x1) == 0xffff ) {
const char *msg;
if (origCount & 0x1) {
msg = "Attempting to retain a freed object";
}
else {
#if !DEBUG
break; #else
msg = "About to wrap the reference count, reference leak?";
#endif
}
panic("OSObject::refcount: %s", msg);
}
newCount = origCount + inc;
} while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
}
void OSObject::taggedRelease(const void *tag) const
{
taggedRelease(tag, 1);
}
void OSObject::taggedRelease(const void *tag, const int when) const
{
volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
UInt32 dec = 1;
UInt32 origCount;
UInt32 newCount;
UInt32 actualCount;
if ((const void *) OSTypeID(OSCollection) == tag)
dec |= (1UL<<16);
do {
origCount = *countP;
if ( ((UInt16) origCount | 0x1) == 0xffff ) {
if (origCount & 0x1) {
return;
}
else {
#if !DEBUG
return; #else
panic("OSObject::refcount: %s",
"About to unreference a pegged object, reference leak?");
#endif
}
}
actualCount = origCount - dec;
if ((UInt16) actualCount < when)
newCount = 0xffff;
else
newCount = actualCount;
} while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
if ((UInt16) actualCount < (actualCount >> 16)) {
panic("A kext releasing a(n) %s has corrupted the registry.",
getClassName(this));
}
if (newCount == 0xffff) {
(const_cast<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);
}
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++;
}
bzero(mem, size);
ACCUMSIZE(size);
return (void *) mem;
}
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)
{
mem--;
if (mem->link.next)
{
lck_spin_lock(&gOSObjectTrackLock);
remque(&mem->link);
lck_spin_unlock(&gOSObjectTrackLock);
}
}
kfree(mem, size + tracking);
ACCUMSIZE(-size);
}