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 | |
49 | // OSDefineMetaClassAndAbstractStructors(OSObject, 0); |
50 | /* Class global data */ |
51 | OSObject::MetaClass OSObject::gMetaClass; |
52 | const OSMetaClass * const OSObject::metaClass = &OSObject::gMetaClass; |
53 | const OSMetaClass * const OSObject::superClass = 0; |
54 | |
55 | /* Class member functions - Can't use defaults */ |
56 | OSObject::~OSObject() { } |
57 | const OSMetaClass * OSObject::getMetaClass() const |
58 | { return &gMetaClass; } |
59 | OSObject *OSObject::MetaClass::alloc() const { return 0; } |
60 | |
61 | /* The OSObject::MetaClass constructor */ |
62 | OSObject::MetaClass::MetaClass() |
63 | : OSMetaClass("OSObject" , OSObject::superClass, sizeof(OSObject)) |
64 | { } |
65 | |
66 | // Virtual Padding |
67 | OSMetaClassDefineReservedUnused(OSObject, 0); |
68 | OSMetaClassDefineReservedUnused(OSObject, 1); |
69 | OSMetaClassDefineReservedUnused(OSObject, 2); |
70 | OSMetaClassDefineReservedUnused(OSObject, 3); |
71 | OSMetaClassDefineReservedUnused(OSObject, 4); |
72 | OSMetaClassDefineReservedUnused(OSObject, 5); |
73 | OSMetaClassDefineReservedUnused(OSObject, 6); |
74 | OSMetaClassDefineReservedUnused(OSObject, 7); |
75 | OSMetaClassDefineReservedUnused(OSObject, 8); |
76 | OSMetaClassDefineReservedUnused(OSObject, 9); |
77 | OSMetaClassDefineReservedUnused(OSObject, 10); |
78 | OSMetaClassDefineReservedUnused(OSObject, 11); |
79 | OSMetaClassDefineReservedUnused(OSObject, 12); |
80 | OSMetaClassDefineReservedUnused(OSObject, 13); |
81 | OSMetaClassDefineReservedUnused(OSObject, 14); |
82 | OSMetaClassDefineReservedUnused(OSObject, 15); |
83 | |
84 | static const char *getClassName(const OSObject *obj) |
85 | { |
86 | const OSMetaClass *meta = obj->getMetaClass(); |
87 | return (meta) ? meta->getClassName() : "unknown class?" ; |
88 | } |
89 | |
90 | int OSObject::getRetainCount() const |
91 | { |
92 | return (int) ((UInt16) retainCount); |
93 | } |
94 | |
95 | void OSObject::taggedRetain(const void *tag) const |
96 | { |
97 | volatile UInt32 *countP = (volatile UInt32 *) &retainCount; |
98 | UInt32 inc = 1; |
99 | UInt32 origCount; |
100 | UInt32 newCount; |
101 | |
102 | // Increment the collection bucket. |
103 | if ((const void *) OSTypeID(OSCollection) == tag) |
104 | inc |= (1UL<<16); |
105 | |
106 | do { |
107 | origCount = *countP; |
108 | if ( ((UInt16) origCount | 0x1) == 0xffff ) { |
109 | const char *msg; |
110 | if (origCount & 0x1) { |
111 | // If count == 0xffff that means we are freeing now so we can |
112 | // just return obviously somebody is cleaning up dangling |
113 | // references. |
114 | msg = "Attempting to retain a freed object" ; |
115 | } |
116 | else { |
117 | // If count == 0xfffe then we have wrapped our reference count. |
118 | // We should stop counting now as this reference must be |
119 | // leaked rather than accidently wrapping around the clock and |
120 | // freeing a very active object later. |
121 | |
122 | #if !DEBUG |
123 | break; // Break out of update loop which pegs the reference |
124 | #else /* DEBUG */ |
125 | // @@@ gvdl: eventually need to make this panic optional |
126 | // based on a boot argument i.e. debug= boot flag |
127 | msg = "About to wrap the reference count, reference leak?" ; |
128 | #endif /* !DEBUG */ |
129 | } |
130 | panic("OSObject::refcount: %s" , msg); |
131 | } |
132 | |
133 | newCount = origCount + inc; |
134 | } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP))); |
135 | } |
136 | |
137 | void OSObject::taggedRelease(const void *tag) const |
138 | { |
139 | taggedRelease(tag, 1); |
140 | } |
141 | |
142 | void OSObject::taggedRelease(const void *tag, const int when) const |
143 | { |
144 | volatile UInt32 *countP = (volatile UInt32 *) &retainCount; |
145 | UInt32 dec = 1; |
146 | UInt32 origCount; |
147 | UInt32 newCount; |
148 | UInt32 actualCount; |
149 | |
150 | // Increment the collection bucket. |
151 | if ((const void *) OSTypeID(OSCollection) == tag) |
152 | dec |= (1UL<<16); |
153 | |
154 | do { |
155 | origCount = *countP; |
156 | |
157 | if ( ((UInt16) origCount | 0x1) == 0xffff ) { |
158 | if (origCount & 0x1) { |
159 | // If count == 0xffff that means we are freeing now so we can |
160 | // just return obviously somebody is cleaning up some dangling |
161 | // references. So we blow out immediately. |
162 | return; |
163 | } |
164 | else { |
165 | // If count == 0xfffe then we have wrapped our reference |
166 | // count. We should stop counting now as this reference must be |
167 | // leaked rather than accidently freeing an active object later. |
168 | |
169 | #if !DEBUG |
170 | return; // return out of function which pegs the reference |
171 | #else /* DEBUG */ |
172 | // @@@ gvdl: eventually need to make this panic optional |
173 | // based on a boot argument i.e. debug= boot flag |
174 | panic("OSObject::refcount: %s" , |
175 | "About to unreference a pegged object, reference leak?" ); |
176 | #endif /* !DEBUG */ |
177 | } |
178 | } |
179 | actualCount = origCount - dec; |
180 | if ((UInt16) actualCount < when) |
181 | newCount = 0xffff; |
182 | else |
183 | newCount = actualCount; |
184 | |
185 | } while (!OSCompareAndSwap(origCount, newCount, const_cast<UInt32 *>(countP))); |
186 | |
187 | // |
188 | // This panic means that we have just attempted to release an object |
189 | // whose retain count has gone to less than the number of collections |
190 | // it is a member off. Take a panic immediately. |
191 | // In fact the panic MAY not be a registry corruption but it is |
192 | // ALWAYS the wrong thing to do. I call it a registry corruption 'cause |
193 | // the registry is the biggest single use of a network of collections. |
194 | // |
195 | // xxx - this error message is overly-specific; |
196 | // xxx - any code in the kernel could trip this, |
197 | // xxx - and it applies as noted to all collections, not just the registry |
198 | if ((UInt16) actualCount < (actualCount >> 16)) { |
199 | panic("A kext releasing a(n) %s has corrupted the registry." , |
200 | getClassName(this)); |
201 | } |
202 | |
203 | // Check for a 'free' condition and that if we are first through |
204 | if (newCount == 0xffff) { |
205 | (const_cast<OSObject *>(this))->free(); |
206 | } |
207 | } |
208 | |
209 | void OSObject::release() const |
210 | { |
211 | taggedRelease(0); |
212 | } |
213 | |
214 | void OSObject::retain() const |
215 | { |
216 | taggedRetain(0); |
217 | } |
218 | |
219 | extern "C" void |
220 | osobject_retain(void * object) |
221 | { |
222 | ((OSObject *)object)->retain(); |
223 | } |
224 | |
225 | extern "C" void |
226 | osobject_release(void * object) |
227 | { |
228 | ((OSObject *)object)->release(); |
229 | } |
230 | |
231 | void OSObject::release(int when) const |
232 | { |
233 | taggedRelease(0, when); |
234 | } |
235 | |
236 | bool OSObject::serialize(OSSerialize *s) const |
237 | { |
238 | char cstr[128]; |
239 | bool ok; |
240 | |
241 | snprintf(cstr, sizeof(cstr), "%s is not serializable" , getClassName(this)); |
242 | |
243 | OSString * str; |
244 | str = OSString::withCStringNoCopy(cstr); |
245 | if (!str) return false; |
246 | |
247 | ok = str->serialize(s); |
248 | str->release(); |
249 | |
250 | return (ok); |
251 | } |
252 | |
253 | void *OSObject::operator new(size_t size) |
254 | { |
255 | #if IOTRACKING |
256 | if (kIOTracking & gIOKitDebug) return (OSMetaClass::trackedNew(size)); |
257 | #endif |
258 | |
259 | void * mem = kalloc_tag_bt(size, VM_KERN_MEMORY_LIBKERN); |
260 | assert(mem); |
261 | bzero(mem, size); |
262 | OSIVAR_ACCUMSIZE(size); |
263 | |
264 | return (void *) mem; |
265 | } |
266 | |
267 | void OSObject::operator delete(void * mem, size_t size) |
268 | { |
269 | if (!mem) return; |
270 | |
271 | #if IOTRACKING |
272 | if (kIOTracking & gIOKitDebug) return (OSMetaClass::trackedDelete(mem, size)); |
273 | #endif |
274 | |
275 | kfree(mem, size); |
276 | OSIVAR_ACCUMSIZE(-size); |
277 | } |
278 | |
279 | bool OSObject::init() |
280 | { |
281 | #if IOTRACKING |
282 | if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this); |
283 | #endif |
284 | return true; |
285 | } |
286 | |
287 | void OSObject::free() |
288 | { |
289 | const OSMetaClass *meta = getMetaClass(); |
290 | |
291 | if (meta) |
292 | { |
293 | meta->instanceDestructed(); |
294 | #if IOTRACKING |
295 | if (kIOTracking & gIOKitDebug) getMetaClass()->trackedFree(this); |
296 | #endif |
297 | } |
298 | delete this; |
299 | } |
300 | |
301 | #if IOTRACKING |
302 | void OSObject::trackingAccumSize(size_t size) |
303 | { |
304 | if (kIOTracking & gIOKitDebug) getMetaClass()->trackedAccumSize(this, size); |
305 | } |
306 | #endif |
307 | |
308 | /* Class member functions - Can't use defaults */ |
309 | /* During constructor vtable is always OSObject's - can't call any subclass */ |
310 | |
311 | OSObject::OSObject() |
312 | { |
313 | retainCount = 1; |
314 | // if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this); |
315 | } |
316 | |
317 | OSObject::OSObject(const OSMetaClass *) |
318 | { |
319 | retainCount = 1; |
320 | // if (kIOTracking & gIOKitDebug) getMetaClass()->trackedInstance(this); |
321 | } |
322 | |