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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* OSObject.cpp created by gvdl on Fri 1998-11-17 */

#include <libkern/c++/OSObject.h>
#include <libkern/c++/OSSerialize.h>
#include <libkern/c++/OSLib.h>
#include <libkern/c++/OSCPPDebug.h>
#include <libkern/OSAtomic.h>

#include <libkern/c++/OSCollection.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

// OSDefineMetaClassAndAbstractStructors(OSObject, 0);
/* Class global data */
OSObject::MetaClass OSObject::gMetaClass;
const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass;
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; }
OSObject *OSObject::MetaClass::alloc() const { return 0; }

/* The OSObject::MetaClass constructor */
OSObject::MetaClass::MetaClass()
    : OSMetaClass("OSObject", OSObject::superClass, sizeof(OSObject))
    { }

// Virtual Padding
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);
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);

static const char *getClassName(const OSObject *obj)
{
    const OSMetaClass *meta = obj->getMetaClass();
    return (meta) ? meta->getClassName() : "unknown class?";
}

bool OSObject::init()
    { return true; }

void OSObject::free()
{
    const OSMetaClass *meta = getMetaClass();

    if (meta)
	meta->instanceDestructed();
    delete this;
}

int OSObject::getRetainCount() const
{
    return (int) ((UInt16) retainCount);
}

void OSObject::taggedRetain(const void *tag) const
{
#if !DEBUG
    volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
    UInt32 inc = 1;
    UInt32 origCount;
    UInt32 newCount;

    // Increment the collecion bucket.
    if ((const void *) OSTypeID(OSCollection) == tag)
	inc |= (1UL<<16);

    do {
	origCount = *countP;
	if (-1UL == origCount)
	    // @@@ Pinot: panic("Attempting to retain a freed object");
	    return;

	newCount = origCount + inc;
    } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
#else
    volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
    UInt32 inc = 1;
    UInt32 origCount;
    UInt32 newCount;

    // Increment the collecion bucket.
    if ((const void *) OSTypeID(OSCollection) == tag)
	inc |= (1UL<<16);

    do {
	origCount = *countP;
	if (-1UL == origCount)
	    return;	// We are freeing so leave now.

	newCount = origCount + inc;
    } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
#endif
}

void OSObject::taggedRelease(const void *tag) const
{
    taggedRelease(tag, 1);
}

void OSObject::taggedRelease(const void *tag, const int when) const
{
#if !DEBUG
    volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
    UInt32 dec = 1;
    UInt32 origCount;
    UInt32 newCount;
    UInt32 actualCount;

    // Increment the collecion bucket.
    if ((const void *) OSTypeID(OSCollection) == tag)
	dec |= (1UL<<16);

    do {
	origCount = *countP;
	if (-1UL == origCount)
	    return;	// We are freeing already leave now.

	actualCount = origCount - dec;
        if ((SInt16) actualCount < when)
            newCount = (UInt32) -1;
        else
            newCount = actualCount;

    } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));

    //
    // This panic means that we have just attempted to release an object
    // 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 
    // 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.
    //
    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 ((UInt32) -1 == newCount)
	((OSObject *) this)->free();
#else
    // @@@ Pinot:  Need to update the debug build release code.
    volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
    UInt32 dec = 1;
    UInt32 origCount;
    UInt32 newCount;

    // Increment the collecion bucket.
    if ((const void *) OSTypeID(OSCollection) == tag)
	dec |= (1UL<<16);

    do {
	origCount = *countP;
	if (-1UL == origCount)
	    return;	// We are freeing already leave now.

	newCount = origCount - dec;
    } while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));

    //
    // This panic means that we have just attempted to release an object
    // 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 
    // 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.
    //
    if ((UInt16) newCount < (newCount >> 16))
	panic("A driver releasing a(n) %s has corrupted the registry\n",
	    getClassName(this));

    // Check for a release too many
    if ((SInt16) newCount < 0)
	panic("An object has had a release too many\n",
	    getClassName(this));

    // Check for a 'free' condition and that if we are first through
    if ((SInt16) newCount < when
    && OSCompareAndSwap(newCount, -1UL, (UInt32 *) countP))
	((OSObject *) this)->free();
#endif
}

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");
}

void *OSObject::operator new(size_t size)
{
    void *mem = (void *) kalloc(size);
    assert(mem);
    bzero(mem, size);

    ACCUMSIZE(size);

    return mem;
}

void OSObject::operator delete(void *mem, size_t size)
{
    kfree((vm_offset_t) mem, size);

    ACCUMSIZE(-size);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
d7e50217	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
d7e50217 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
d7e50217 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/* OSObject.cpp created by gvdl on Fri 1998-11-17 */
	26
	27	#include <libkern/c++/OSObject.h>
	28	#include <libkern/c++/OSSerialize.h>
1c79356b A	29	#include <libkern/c++/OSLib.h>
	30	#include <libkern/c++/OSCPPDebug.h>
	31	#include <libkern/OSAtomic.h>
	32
9bccf70c A	33	#include <libkern/c++/OSCollection.h>
9bccf70c A	34
1c79356b A	35	__BEGIN_DECLS
	36	int debug_ivars_size;
	37	__END_DECLS
	38
	39	#if OSALLOCDEBUG
	40	#define ACCUMSIZE(s) do { debug_ivars_size += (s); } while(0)
	41	#else
	42	#define ACCUMSIZE(s)
	43	#endif
	44
	45	// OSDefineMetaClassAndAbstractStructors(OSObject, 0);
	46	/* Class global data */
	47	OSObject::MetaClass OSObject::gMetaClass;
	48	const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass;
	49	const OSMetaClass * const OSObject::superClass = 0;
	50
	51	/* Class member functions - Can't use defaults */
	52	OSObject::OSObject() { retainCount = 1; }
	53	OSObject::OSObject(const OSMetaClass *) { retainCount = 1; }
	54	OSObject::~OSObject() { }
	55	const OSMetaClass * OSObject::getMetaClass() const
	56	{ return &gMetaClass; }
	57	OSObject *OSObject::MetaClass::alloc() const { return 0; }
	58
	59	/* The OSObject::MetaClass constructor */
	60	OSObject::MetaClass::MetaClass()
	61	: OSMetaClass("OSObject", OSObject::superClass, sizeof(OSObject))
	62	{ }
	63
	64	// Virtual Padding
	65	OSMetaClassDefineReservedUnused(OSObject, 0);
	66	OSMetaClassDefineReservedUnused(OSObject, 1);
	67	OSMetaClassDefineReservedUnused(OSObject, 2);
	68	OSMetaClassDefineReservedUnused(OSObject, 3);
	69	OSMetaClassDefineReservedUnused(OSObject, 4);
	70	OSMetaClassDefineReservedUnused(OSObject, 5);
	71	OSMetaClassDefineReservedUnused(OSObject, 6);
	72	OSMetaClassDefineReservedUnused(OSObject, 7);
	73	OSMetaClassDefineReservedUnused(OSObject, 8);
	74	OSMetaClassDefineReservedUnused(OSObject, 9);
	75	OSMetaClassDefineReservedUnused(OSObject, 10);
	76	OSMetaClassDefineReservedUnused(OSObject, 11);
	77	OSMetaClassDefineReservedUnused(OSObject, 12);
	78	OSMetaClassDefineReservedUnused(OSObject, 13);
	79	OSMetaClassDefineReservedUnused(OSObject, 14);
	80	OSMetaClassDefineReservedUnused(OSObject, 15);
	81	OSMetaClassDefineReservedUnused(OSObject, 16);
	82	OSMetaClassDefineReservedUnused(OSObject, 17);
	83	OSMetaClassDefineReservedUnused(OSObject, 18);
	84	OSMetaClassDefineReservedUnused(OSObject, 19);
	85	OSMetaClassDefineReservedUnused(OSObject, 20);
	86	OSMetaClassDefineReservedUnused(OSObject, 21);
	87	OSMetaClassDefineReservedUnused(OSObject, 22);
	88	OSMetaClassDefineReservedUnused(OSObject, 23);
	89	OSMetaClassDefineReservedUnused(OSObject, 24);
	90	OSMetaClassDefineReservedUnused(OSObject, 25);
	91	OSMetaClassDefineReservedUnused(OSObject, 26);
	92	OSMetaClassDefineReservedUnused(OSObject, 27);
	93	OSMetaClassDefineReservedUnused(OSObject, 28);
	94	OSMetaClassDefineReservedUnused(OSObject, 29);
	95	OSMetaClassDefineReservedUnused(OSObject, 30);
	96	OSMetaClassDefineReservedUnused(OSObject, 31);
	97
9bccf70c A	98	static const char getClassName(const OSObject obj)
	99	{
	100	const OSMetaClass *meta = obj->getMetaClass();
	101	return (meta) ? meta->getClassName() : "unknown class?";
	102	}
	103
	104	bool OSObject::init()
	105	{ return true; }
1c79356b	106
1c79356b A	107	void OSObject::free()
	108	{
	109	const OSMetaClass *meta = getMetaClass();
	110
	111	if (meta)
	112	meta->instanceDestructed();
	113	delete this;
	114	}
	115
	116	int OSObject::getRetainCount() const
	117	{
9bccf70c	118	return (int) ((UInt16) retainCount);
1c79356b A	119	}
1c79356b A	120
9bccf70c	121	void OSObject::taggedRetain(const void *tag) const
1c79356b	122	{
9bccf70c A	123	#if !DEBUG
	124	volatile UInt32 countP = (volatile UInt32 ) &retainCount;
	125	UInt32 inc = 1;
	126	UInt32 origCount;
	127	UInt32 newCount;
	128
	129	// Increment the collecion bucket.
	130	if ((const void *) OSTypeID(OSCollection) == tag)
	131	inc \|= (1UL<<16);
	132
	133	do {
	134	origCount = *countP;
	135	if (-1UL == origCount)
	136	// @@@ Pinot: panic("Attempting to retain a freed object");
	137	return;
	138
	139	newCount = origCount + inc;
	140	} while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
	141	#else
	142	volatile UInt32 countP = (volatile UInt32 ) &retainCount;
	143	UInt32 inc = 1;
	144	UInt32 origCount;
	145	UInt32 newCount;
	146
	147	// Increment the collecion bucket.
	148	if ((const void *) OSTypeID(OSCollection) == tag)
	149	inc \|= (1UL<<16);
	150
	151	do {
	152	origCount = *countP;
	153	if (-1UL == origCount)
	154	return; // We are freeing so leave now.
	155
	156	newCount = origCount + inc;
	157	} while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
	158	#endif
1c79356b A	159	}
1c79356b A	160
9bccf70c A	161	void OSObject::taggedRelease(const void *tag) const
	162	{
	163	taggedRelease(tag, 1);
	164	}
	165
	166	void OSObject::taggedRelease(const void *tag, const int when) const
1c79356b	167	{
9bccf70c A	168	#if !DEBUG
	169	volatile UInt32 countP = (volatile UInt32 ) &retainCount;
	170	UInt32 dec = 1;
	171	UInt32 origCount;
	172	UInt32 newCount;
	173	UInt32 actualCount;
	174
	175	// Increment the collecion bucket.
	176	if ((const void *) OSTypeID(OSCollection) == tag)
	177	dec \|= (1UL<<16);
	178
	179	do {
	180	origCount = *countP;
	181	if (-1UL == origCount)
	182	return; // We are freeing already leave now.
	183
	184	actualCount = origCount - dec;
	185	if ((SInt16) actualCount < when)
	186	newCount = (UInt32) -1;
	187	else
	188	newCount = actualCount;
	189
	190	} while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
	191
	192	//
	193	// This panic means that we have just attempted to release an object
	194	// who's retain count has gone to less than the number of collections
	195	// it is a member off. Take a panic immediately.
	196	// In Fact the panic MAY not be a registry corruption but it is
	197	// ALWAYS the wrong thing to do. I call it a registry corruption 'cause
	198	// the registry is the biggest single use of a network of collections.
	199	//
	200	if ((UInt16) actualCount < (actualCount >> 16))
	201	panic("A driver releasing a(n) %s has corrupted the registry\n",
	202	getClassName(this));
	203
	204	// Check for a 'free' condition and that if we are first through
	205	if ((UInt32) -1 == newCount)
1c79356b	206	((OSObject *) this)->free();
9bccf70c A	207	#else
	208	// @@@ Pinot: Need to update the debug build release code.
	209	volatile UInt32 countP = (volatile UInt32 ) &retainCount;
	210	UInt32 dec = 1;
	211	UInt32 origCount;
	212	UInt32 newCount;
	213
	214	// Increment the collecion bucket.
	215	if ((const void *) OSTypeID(OSCollection) == tag)
	216	dec \|= (1UL<<16);
	217
	218	do {
	219	origCount = *countP;
	220	if (-1UL == origCount)
	221	return; // We are freeing already leave now.
	222
	223	newCount = origCount - dec;
	224	} while (!OSCompareAndSwap(origCount, newCount, (UInt32 *) countP));
	225
	226	//
	227	// This panic means that we have just attempted to release an object
	228	// who's retain count has gone to less than the number of collections
	229	// it is a member off. Take a panic immediately.
	230	// In Fact the panic MAY not be a registry corruption but it is
	231	// ALWAYS the wrong thing to do. I call it a registry corruption 'cause
	232	// the registry is the biggest single use of a network of collections.
	233	//
	234	if ((UInt16) newCount < (newCount >> 16))
	235	panic("A driver releasing a(n) %s has corrupted the registry\n",
	236	getClassName(this));
	237
	238	// Check for a release too many
	239	if ((SInt16) newCount < 0)
	240	panic("An object has had a release too many\n",
	241	getClassName(this));
	242
	243	// Check for a 'free' condition and that if we are first through
	244	if ((SInt16) newCount < when
	245	&& OSCompareAndSwap(newCount, -1UL, (UInt32 *) countP))
	246	((OSObject *) this)->free();
	247	#endif
1c79356b A	248	}
	249
	250	void OSObject::release() const
	251	{
9bccf70c A	252	taggedRelease(0);
	253	}
	254
	255	void OSObject::retain() const
	256	{
	257	taggedRetain(0);
	258	}
	259
	260	void OSObject::release(int when) const
	261	{
	262	taggedRelease(0, when);
1c79356b A	263	}
	264
	265	bool OSObject::serialize(OSSerialize *s) const
	266	{
	267	if (s->previouslySerialized(this)) return true;
	268
	269	if (!s->addXMLStartTag(this, "string")) return false;
	270
9bccf70c	271	if (!s->addString(getClassName(this))) return false;
1c79356b A	272	if (!s->addString(" is not serializable")) return false;
	273
	274	return s->addXMLEndTag("string");
	275	}
	276
	277	void *OSObject::operator new(size_t size)
	278	{
	279	void mem = (void ) kalloc(size);
	280	assert(mem);
	281	bzero(mem, size);
	282
	283	ACCUMSIZE(size);
	284
	285	return mem;
	286	}
	287
	288	void OSObject::operator delete(void *mem, size_t size)
	289	{
	290	kfree((vm_offset_t) mem, size);
	291
	292	ACCUMSIZE(-size);
	293	}