libkern/c++/OSObject.cpp

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