libkern/c++/OSObject.cpp

   1 /*
   2  * Copyright (c) 2000 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /* OSObject.cpp created by gvdl on Fri 1998-11-17 */
  29
  30 #include <libkern/c++/OSObject.h>
  31 #include <libkern/c++/OSString.h>
  32 #include <libkern/c++/OSArray.h>
  33 #include <libkern/c++/OSSerialize.h>
  34 #include <libkern/c++/OSLib.h>
  35 #include <libkern/OSDebug.h>
  36 #include <libkern/c++/OSCPPDebug.h>
  37 #include <IOKit/IOKitDebug.h>
  38 #include <libkern/OSAtomic.h>
  39
  40 #include <libkern/c++/OSCollection.h>
  41
  42 #include <kern/queue.h>
  43
  44 __BEGIN_DECLS
  45 int debug_ivars_size;
  46 __END_DECLS
  47
  48 #if OSALLOCDEBUG
  49 #define ACCUMSIZE(s) do { debug_ivars_size += (s); } while(0)
  50 #else
  51 #define ACCUMSIZE(s)
  52 #endif
  53
  54 // OSDefineMetaClassAndAbstractStructors(OSObject, 0);
  55 /* Class global data */
  56 OSObject::MetaClass OSObject::gMetaClass;
  57 const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass;
  58 const OSMetaClass * const OSObject::superClass = 0;
  59
  60 /* Class member functions - Can't use defaults */
  61 OSObject::OSObject()                    { retainCount = 1; }
  62 OSObject::OSObject(const OSMetaClass *) { retainCount = 1; }
  63 OSObject::~OSObject()                   { }
  64 const OSMetaClass * OSObject::getMetaClass() const
  65     { return &gMetaClass; }
  66 OSObject *OSObject::MetaClass::alloc() const { return 0; }
  67
  68 /* The OSObject::MetaClass constructor */
  69 OSObject::MetaClass::MetaClass()
  70     : OSMetaClass("OSObject", OSObject::superClass, sizeof(OSObject))
  71     { }
  72
  73 // Virtual Padding
  74 OSMetaClassDefineReservedUnused(OSObject,  0);
  75 OSMetaClassDefineReservedUnused(OSObject,  1);
  76 OSMetaClassDefineReservedUnused(OSObject,  2);
  77 OSMetaClassDefineReservedUnused(OSObject,  3);
  78 OSMetaClassDefineReservedUnused(OSObject,  4);
  79 OSMetaClassDefineReservedUnused(OSObject,  5);
  80 OSMetaClassDefineReservedUnused(OSObject,  6);
  81 OSMetaClassDefineReservedUnused(OSObject,  7);
  82 OSMetaClassDefineReservedUnused(OSObject,  8);
  83 OSMetaClassDefineReservedUnused(OSObject,  9);
  84 OSMetaClassDefineReservedUnused(OSObject, 10);
  85 OSMetaClassDefineReservedUnused(OSObject, 11);
  86 OSMetaClassDefineReservedUnused(OSObject, 12);
  87 OSMetaClassDefineReservedUnused(OSObject, 13);
  88 OSMetaClassDefineReservedUnused(OSObject, 14);
  89 OSMetaClassDefineReservedUnused(OSObject, 15);
  90
  91 static const char *getClassName(const OSObject *obj)
  92 {
  93     const OSMetaClass *meta = obj->getMetaClass();
  94     return (meta) ? meta->getClassName() : "unknown class?";
  95 }
  96
  97 bool OSObject::init()
  98     { return true; }
  99
 100 void OSObject::free()
 101 {
 102     const OSMetaClass *meta = getMetaClass();
 103
 104     if (meta)
 105         meta->instanceDestructed();
 106     delete this;
 107 }
 108
 109 int OSObject::getRetainCount() const
 110 {
 111     return (int) ((UInt16) retainCount);
 112 }
 113
 114 void OSObject::taggedRetain(const void *tag) const
 115 {
 116     volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
 117     UInt32 inc = 1;
 118     UInt32 origCount;
 119     UInt32 newCount;
 120
 121     // Increment the collection bucket.
 122     if ((const void *) OSTypeID(OSCollection) == tag)
 123         inc |= (1UL<<16);
 124
 125     do {
 126         origCount = *countP;
 127         if ( ((UInt16) origCount | 0x1) == 0xffff ) {
 128             const char *msg;
 129             if (origCount & 0x1) {
 130                 // If count == 0xffff that means we are freeing now so we can
 131                 // just return obviously somebody is cleaning up dangling
 132                 // references.
 133                 msg = "Attempting to retain a freed object";
 134             }
 135             else {
 136                 // If count == 0xfffe then we have wrapped our reference count.
 137                 // We should stop counting now as this reference must be
 138                 // leaked rather than accidently wrapping around the clock and
 139                 // freeing a very active object later.
 140
 141 #if !DEBUG
 142                 break;  // Break out of update loop which pegs the reference
 143 #else /* DEBUG */
 144                 // @@@ gvdl: eventually need to make this panic optional
 145                 // based on a boot argument i.e. debug= boot flag
 146                 msg = "About to wrap the reference count, reference leak?";
 147 #endif /* !DEBUG */
 148             }
 149             panic("OSObject::refcount: %s", msg);
 150         }
 151
 152         newCount = origCount + inc;
 153     } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
 154 }
 155
 156 void OSObject::taggedRelease(const void *tag) const
 157 {
 158     taggedRelease(tag, 1);
 159 }
 160
 161 void OSObject::taggedRelease(const void *tag, const int when) const
 162 {
 163     volatile UInt32 *countP = (volatile UInt32 *) &retainCount;
 164     UInt32 dec = 1;
 165     UInt32 origCount;
 166     UInt32 newCount;
 167     UInt32 actualCount;
 168
 169     // Increment the collection bucket.
 170     if ((const void *) OSTypeID(OSCollection) == tag)
 171         dec |= (1UL<<16);
 172
 173     do {
 174         origCount = *countP;
 175
 176         if ( ((UInt16) origCount | 0x1) == 0xffff ) {
 177             if (origCount & 0x1) {
 178                 // If count == 0xffff that means we are freeing now so we can
 179                 // just return obviously somebody is cleaning up some dangling
 180                 // references.  So we blow out immediately.
 181                 return;
 182             }
 183             else {
 184                 // If count == 0xfffe then we have wrapped our reference
 185                 // count.  We should stop counting now as this reference must be
 186                 // leaked rather than accidently freeing an active object later.
 187
 188 #if !DEBUG
 189                 return; // return out of function which pegs the reference
 190 #else /* DEBUG */
 191                 // @@@ gvdl: eventually need to make this panic optional
 192                 // based on a boot argument i.e. debug= boot flag
 193                 panic("OSObject::refcount: %s",
 194                       "About to unreference a pegged object, reference leak?");
 195 #endif /* !DEBUG */
 196             }
 197         }
 198         actualCount = origCount - dec;
 199         if ((UInt16) actualCount < when)
 200             newCount = 0xffff;
 201         else
 202             newCount = actualCount;
 203
 204     } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP)));
 205
 206     //
 207     // This panic means that we have just attempted to release an object
 208     // whose retain count has gone to less than the number of collections
 209     // it is a member off.  Take a panic immediately.
 210     // In fact the panic MAY not be a registry corruption but it is
 211     // ALWAYS the wrong thing to do.  I call it a registry corruption 'cause
 212     // the registry is the biggest single use of a network of collections.
 213     //
 214 // xxx - this error message is overly-specific;
 215 // xxx - any code in the kernel could trip this,
 216 // xxx - and it applies as noted to all collections, not just the registry
 217     if ((UInt16) actualCount < (actualCount >> 16)) {
 218         panic("A kext releasing a(n) %s has corrupted the registry.",
 219             getClassName(this));
 220     }
 221
 222     // Check for a 'free' condition and that if we are first through
 223     if (newCount == 0xffff) {
 224         (const_cast<OSObject *>(this))->free();
 225     }
 226 }
 227
 228 void OSObject::release() const
 229 {
 230     taggedRelease(0);
 231 }
 232
 233 void OSObject::retain() const
 234 {
 235     taggedRetain(0);
 236 }
 237
 238 void OSObject::release(int when) const
 239 {
 240     taggedRelease(0, when);
 241 }
 242
 243 bool OSObject::serialize(OSSerialize *s) const
 244 {
 245     char cstr[128];
 246     bool ok;
 247
 248     snprintf(cstr, sizeof(cstr), "%s is not serializable", getClassName(this));
 249
 250     OSString * str;
 251     str = OSString::withCStringNoCopy(cstr);
 252     if (!str) return false;
 253
 254     ok = str->serialize(s);
 255     str->release();
 256
 257     return (ok);
 258 }
 259
 260
 261 thread_t gOSObjectTrackThread;
 262
 263 queue_head_t gOSObjectTrackList =
 264     { (queue_t) &gOSObjectTrackList, (queue_t) &gOSObjectTrackList };
 265
 266 lck_spin_t gOSObjectTrackLock;
 267
 268 OSArray * OSFlushObjectTrackList(void)
 269 {
 270     OSArray *     array;
 271     queue_entry_t next;
 272
 273     array = OSArray::withCapacity(16);
 274
 275     lck_spin_lock(&gOSObjectTrackLock);
 276     while (!queue_empty(&gOSObjectTrackList))
 277     {
 278         next = queue_first(&gOSObjectTrackList);
 279         remque(next);
 280         lck_spin_unlock(&gOSObjectTrackLock);
 281         array->setObject((OSObject *) (next + 1));
 282         lck_spin_lock(&gOSObjectTrackLock);
 283     }
 284     lck_spin_unlock(&gOSObjectTrackLock);
 285
 286     return (array);
 287 }
 288
 289 struct OSObjectTracking
 290 {
 291     queue_chain_t link;
 292     void *        bt[14];
 293 };
 294
 295 void *OSObject::operator new(size_t size)
 296 {
 297     size_t tracking        = (gIOKitDebug & kOSTraceObjectAlloc)
 298                            ? sizeof(OSObjectTracking) : 0;
 299     OSObjectTracking * mem = (OSObjectTracking *) kalloc(size + tracking);
 300
 301     assert(mem);
 302
 303     if (tracking)
 304     {
 305         if ((((thread_t) 1) == gOSObjectTrackThread) || (current_thread() == gOSObjectTrackThread))
 306         {
 307             (void) OSBacktrace(&mem->bt[0], sizeof(mem->bt) / sizeof(mem->bt[0]));
 308             lck_spin_lock(&gOSObjectTrackLock);
 309             enqueue_tail(&gOSObjectTrackList, &mem->link);
 310             lck_spin_unlock(&gOSObjectTrackLock);
 311         }
 312         else
 313             mem->link.next = 0;
 314         mem++;
 315     }
 316
 317     bzero(mem, size);
 318
 319     ACCUMSIZE(size);
 320
 321     return (void *) mem;
 322 }
 323
 324 void OSObject::operator delete(void *_mem, size_t size)
 325 {
 326     size_t             tracking = (gIOKitDebug & kOSTraceObjectAlloc)
 327                                 ? sizeof(OSObjectTracking) : 0;
 328     OSObjectTracking * mem      = (OSObjectTracking *) _mem;
 329
 330     if (!mem)
 331         return;
 332
 333     if (tracking)
 334     {
 335         mem--;
 336         if (mem->link.next)
 337         {
 338             lck_spin_lock(&gOSObjectTrackLock);
 339             remque(&mem->link);
 340             lck_spin_unlock(&gOSObjectTrackLock);
 341         }
 342     }
 343
 344     kfree(mem, size + tracking);
 345
 346     ACCUMSIZE(-size);
 347 }