IOStatisticsPrivate.h
1 /* 2 * Copyright (c) 2010 Apple Computer, 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 29 #ifndef __IOKIT_STATISTICS_PRIVATE_H 30 #define __IOKIT_STATISTICS_PRIVATE_H 31 32 #if IOKITSTATS 33 34 #include <sys/queue.h> 35 #include <sys/tree.h> 36 37 #include <libkern/c++/OSKext.h> 38 #include <libkern/OSDebug.h> 39 40 #include <IOKit/IOMemoryDescriptor.h> 41 #include <IOKit/IOStatistics.h> 42 43 #ifndef KERNEL 44 #error IOStatisticsPrivate.h is for kernel use only 45 #endif 46 47 /* Defines */ 48 #define IOKIT_STATISTICS_RECORDED_USERCLIENT_PROCS 20 49 50 #ifndef __probable 51 #define __probable(x) x 52 #endif 53 54 /* Forward declarations */ 55 class IOWorkLoop; 56 class IOUserClient; 57 class IOEventSource; 58 59 struct IOEventSourceCounter; 60 struct IOUserClientCounter; 61 struct IOWorkLoopCounter; 62 struct IOUserClientProcessEntry; 63 64 struct KextNode; 65 66 /* Allocation tracking */ 67 68 enum { 69 kIOStatisticsMalloc = 0, 70 kIOStatisticsFree, 71 kIOStatisticsMallocAligned, 72 kIOStatisticsFreeAligned, 73 kIOStatisticsMallocContiguous, 74 kIOStatisticsFreeContiguous, 75 kIOStatisticsMallocPageable, 76 kIOStatisticsFreePageable, 77 kIOStatisticsAllocCount 78 }; 79 80 TAILQ_HEAD(ProcessEntryList, IOUserClientProcessEntry); 81 82 /* Tree and list structs */ 83 84 typedef struct ClassNode { 85 RB_ENTRY(ClassNode) tLink; 86 SLIST_ENTRY(ClassNode) lLink; 87 struct KextNode *parentKext; 88 uint32_t classID; 89 uint32_t superClassID; 90 const OSMetaClass *metaClass; 91 SLIST_HEAD(, IOEventSourceCounter) counterList; 92 SLIST_HEAD(, IOUserClientCounter) userClientList; 93 } ClassNode; 94 95 typedef struct KextNode { 96 RB_ENTRY(KextNode) link; 97 RB_ENTRY(KextNode) addressLink; 98 OSKext *kext; 99 OSKextLoadTag loadTag; 100 vm_offset_t address; 101 vm_offset_t address_end; 102 uint32_t memoryCounters[kIOStatisticsAllocCount]; 103 uint32_t classes; 104 SLIST_HEAD(, ClassNode) classList; 105 SLIST_HEAD(, IOWorkLoopCounter) workLoopList; 106 ProcessEntryList userClientCallList; 107 } KextNode; 108 109 /* User client tracing */ 110 111 typedef struct IOUserClientProcessEntry { 112 TAILQ_ENTRY(IOUserClientProcessEntry) link; 113 char processName[kIOStatisticsProcessNameLength]; 114 int32_t pid; 115 uint32_t calls; 116 } IOUserClientProcessEntry; 117 118 /* Counters */ 119 120 typedef struct IOInterruptEventSourceCounter { 121 uint32_t produced; 122 uint32_t checksForWork; 123 } IOInterruptEventSourceCounter; 124 125 typedef struct IOTimerEventSourceCounter { 126 uint32_t timeouts; 127 uint32_t checksForWork; 128 } IOTimerEventSourceCounter; 129 130 typedef struct IOCommandGateCounter { 131 uint32_t actionCalls; 132 } IOCommandGateCounter; 133 134 typedef struct IOCommandQueueCounter { 135 uint32_t actionCalls; 136 } IOCommandQueueCounter; 137 138 typedef struct IOEventSourceCounter { 139 SLIST_ENTRY(IOEventSourceCounter) link; 140 ClassNode *parentClass; 141 IOStatisticsCounterType type; 142 uint64_t startTimeStamp; 143 uint64_t timeOnGate; 144 uint32_t closeGateCalls; 145 uint32_t openGateCalls; 146 union { 147 IOInterruptEventSourceCounter interrupt; 148 IOInterruptEventSourceCounter filter; 149 IOTimerEventSourceCounter timer; 150 IOCommandGateCounter commandGate; 151 IOCommandQueueCounter commandQueue; 152 } u; 153 } IOEventSourceCounter; 154 155 typedef struct IOWorkLoopDependency { 156 RB_ENTRY(IOWorkLoopDependency) link; 157 OSKextLoadTag loadTag; 158 } IOWorkLoopDependency; 159 160 typedef struct IOWorkLoopCounter { 161 SLIST_ENTRY(IOWorkLoopCounter) link; 162 KextNode *parentKext; 163 int attachedEventSources; 164 IOWorkLoop *workLoop; 165 uint64_t startTimeStamp; 166 uint64_t timeOnGate; 167 uint32_t closeGateCalls; 168 uint32_t openGateCalls; 169 typedef RB_HEAD(DependencyTree, IOWorkLoopDependency) DependencyTreeHead; 170 DependencyTreeHead dependencyHead; 171 static int loadTagCompare(IOWorkLoopDependency *e1, IOWorkLoopDependency *e2); 172 RB_PROTOTYPE_SC(static, DependencyTree, IOWorkLoopDependency, dependencyLink, KextTagCompare); 173 } IOWorkLoopCounter; 174 175 typedef struct IOUserClientCounter { 176 SLIST_ENTRY(IOUserClientCounter) link; 177 ClassNode *parentClass; 178 uint32_t clientCalls; 179 } IOUserClientCounter; 180 181 class IOStatistics { 182 static bool enabled; 183 184 static IORWLock *lock; 185 186 static uint32_t sequenceID; 187 188 static uint32_t lastKextIndex; 189 static uint32_t lastClassIndex; 190 191 static uint32_t loadedKexts; 192 static uint32_t registeredClasses; 193 static uint32_t registeredCounters; 194 static uint32_t registeredWorkloops; 195 196 static uint32_t attachedEventSources; 197 198 static KextNode *kextHint; 199 200 static IOWorkLoopDependency *nextWorkLoopDependency; 201 202 typedef RB_HEAD(KextTree, KextNode) KextTreeHead; 203 static KextTreeHead kextHead; 204 static int kextNodeCompare(KextNode *e1, KextNode *e2); 205 RB_PROTOTYPE_SC(static, KextTree, KextNode, link, kextNodeCompare); 206 207 typedef RB_HEAD(KextAddressTree, KextNode) KextAddressTreeHead; 208 static KextAddressTreeHead kextAddressHead; 209 static int kextAddressNodeCompare(KextNode *e1, KextNode *e2); 210 RB_PROTOTYPE_SC(static, KextAddressTree, KextNode, addressLink, kextAddressNodeCompare); 211 212 typedef RB_HEAD(ClassTree, ClassNode) ClassTreeHead; 213 static ClassTreeHead classHead; 214 static int classNodeCompare(ClassNode *e1, ClassNode *e2); 215 RB_PROTOTYPE_SC(static, ClassTree, ClassNode, tLink, classNodeCompare); 216 217 static int oid_sysctl(__unused struct sysctl_oid *oidp, __unused void *arg1, int arg2, struct sysctl_req *req); 218 219 static uint32_t copyGlobalStatistics(IOStatisticsGlobal *stats); 220 static uint32_t copyKextStatistics(IOStatisticsKext *stats); 221 static uint32_t copyMemoryStatistics(IOStatisticsMemory *stats); 222 static uint32_t copyClassStatistics(IOStatisticsClass *stats); 223 static uint32_t copyCounterStatistics(IOStatisticsCounter *stats); 224 static uint32_t copyKextIdentifiers(IOStatisticsKextIdentifier *kextIDs); 225 static uint32_t copyClassNames(IOStatisticsClassName *classNames); 226 227 static uint32_t copyWorkLoopStatistics(IOStatisticsWorkLoop *workLoopStats); 228 229 static uint32_t copyUserClientStatistics(IOStatisticsUserClientHeader *stats, uint32_t loadTag); 230 231 static void updateAllocationCounter(vm_offset_t address, uint32_t index, vm_size_t size); 232 233 static void storeUserClientCallInfo(IOUserClient *userClient, IOUserClientCounter *counter); 234 235 static KextNode *getKextNodeFromBacktrace(boolean_t write); 236 static void releaseKextNode(KextNode *node); 237 238 public: 239 240 static void initialize(); 241 242 inline static bool 243 isEnabled() 244 { 245 return enabled; 246 } 247 248 static void onKextLoad(OSKext *kext, kmod_info_t *kmod_info); 249 static void onKextUnload(OSKext *kext); 250 static void onClassAdded(OSKext *parentKext, OSMetaClass *metaClass); 251 static void onClassRemoved(OSKext *parentKext, OSMetaClass *metaClass); 252 253 static IOEventSourceCounter *registerEventSource(OSObject *inOwner); 254 static void unregisterEventSource(IOEventSourceCounter *counter); 255 256 static IOWorkLoopCounter *registerWorkLoop(IOWorkLoop *workLoop); 257 static void unregisterWorkLoop(IOWorkLoopCounter *counter); 258 259 static IOUserClientCounter *registerUserClient(IOUserClient *userClient); 260 static void unregisterUserClient(IOUserClientCounter *counter); 261 262 static int getStatistics(sysctl_req *req); 263 static int getWorkLoopStatistics(sysctl_req *req); 264 static int getUserClientStatistics(sysctl_req *req); 265 266 /* Inlines for counter manipulation. 267 * 268 * NOTE: counter access is not expressly guarded here so as not to incur performance penalties 269 * in the instrumented parent objects. Writes are arranged so as to be protected by pre-existing 270 * locks in the parent where appropriate, but reads have no such guarantee. Counters should 271 * therefore be regarded as providing an indication of current state, rather than precisely 272 * accurate statistics. 273 */ 274 275 static inline void 276 setCounterType(IOEventSourceCounter *counter, IOStatisticsCounterType type) 277 { 278 if (counter) { 279 counter->type = type; 280 } 281 } 282 283 static inline void 284 countOpenGate(IOEventSourceCounter *counter) 285 { 286 if (counter) { 287 counter->timeOnGate += mach_absolute_time() - counter->startTimeStamp; 288 counter->openGateCalls++; 289 } 290 } 291 292 static inline void 293 countCloseGate(IOEventSourceCounter *counter) 294 { 295 if (counter) { 296 counter->startTimeStamp = mach_absolute_time(); 297 counter->closeGateCalls++; 298 } 299 } 300 301 /* Interrupt */ 302 static inline void 303 countInterruptCheckForWork(IOEventSourceCounter *counter) 304 { 305 if (counter) { 306 counter->u.interrupt.checksForWork++; 307 } 308 } 309 310 static inline void 311 countInterrupt(IOEventSourceCounter *counter) 312 { 313 if (counter) { 314 counter->u.interrupt.produced++; 315 } 316 } 317 318 /* CommandQueue */ 319 static inline void 320 countCommandQueueActionCall(IOEventSourceCounter *counter) 321 { 322 if (counter) { 323 counter->u.commandQueue.actionCalls++; 324 } 325 } 326 327 /* CommandGate */ 328 static inline void 329 countCommandGateActionCall(IOEventSourceCounter *counter) 330 { 331 if (counter) { 332 counter->u.commandGate.actionCalls++; 333 } 334 } 335 336 /* Timer */ 337 static inline void 338 countTimerTimeout(IOEventSourceCounter *counter) 339 { 340 if (counter) { 341 counter->u.timer.timeouts++; 342 } 343 } 344 345 /* WorkLoop */ 346 static void attachWorkLoopEventSource(IOWorkLoopCounter *wlc, IOEventSourceCounter *esc); 347 static void detachWorkLoopEventSource(IOWorkLoopCounter *wlc, IOEventSourceCounter *esc); 348 349 static inline void 350 countWorkLoopOpenGate(IOWorkLoopCounter *counter) 351 { 352 if (counter) { 353 counter->timeOnGate += mach_absolute_time() - counter->startTimeStamp; 354 counter->openGateCalls++; 355 } 356 } 357 358 static inline void 359 countWorkLoopCloseGate(IOWorkLoopCounter *counter) 360 { 361 if (counter) { 362 counter->startTimeStamp = mach_absolute_time(); 363 counter->closeGateCalls++; 364 } 365 } 366 367 /* IOLib allocations */ 368 static void countAlloc(uint32_t index, vm_size_t size); 369 370 /* UserClient */ 371 static void countUserClientCall(IOUserClient *client); 372 }; 373 374 #else 375 376 /* Statistics disabled */ 377 378 class IOStatistics { 379 public: 380 static void 381 initialize() 382 { 383 } 384 }; 385 386 #endif /* IOKITSTATS */ 387 388 #endif /* __IOKIT_STATISTICS_PRIVATE_H */