#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>
#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
OSObject::MetaClass OSObject::gMetaClass;
const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass;
const OSMetaClass * const OSObject::superClass = 0;
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);
static const char *getClassName(const OSObject *obj)
{
const OSMetaClass *meta = obj->getMetaClass();
return (meta) ? meta->getClassName() : "unknown class?";
}
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
{
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);
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)
{
meta->instanceDestructed();
#if IOTRACKING
if (kIOTracking & gIOKitDebug) getMetaClass()->trackedFree(this);
#endif
}
delete this;
}
#if IOTRACKING
void OSObject::trackingAccumSize(size_t size)
{
if (kIOTracking & gIOKitDebug) getMetaClass()->trackedAccumSize(this, size);
}
#endif
OSObject::OSObject()
{
retainCount = 1;
}
OSObject::OSObject(const OSMetaClass *)
{
retainCount = 1;
}