iokit/IOKit/IOKitDebug.h

   1 /*
   2  * Copyright (c) 1998-2019 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
  29 #ifndef _IOKIT_IOKITDEBUG_H
  30 #define _IOKIT_IOKITDEBUG_H
  31
  32 #include <IOKit/IOTypes.h>
  33
  34
  35 #ifdef __cplusplus
  36
  37 #include <libkern/c++/OSObject.h>
  38 #include <libkern/c++/OSDictionary.h>
  39 #include <libkern/c++/OSSerialize.h>
  40
  41 class IOKitDiagnostics : public OSObject
  42 {
  43         OSDeclareDefaultStructors(IOKitDiagnostics);
  44
  45 public:
  46         static OSObject * diagnostics( void );
  47         virtual bool serialize(OSSerialize *s) const APPLE_KEXT_OVERRIDE;
  48 private:
  49         static void updateOffset( OSDictionary * dict,
  50             UInt64 value, const char * name );
  51 };
  52
  53 #endif /* __cplusplus */
  54
  55 enum {
  56         // loggage
  57         kIOLogAttach        =         0x00000001ULL,
  58         kIOLogProbe         =         0x00000002ULL,
  59         kIOLogStart         =         0x00000004ULL,
  60         kIOLogRegister      =         0x00000008ULL,
  61         kIOLogMatch         =         0x00000010ULL,
  62         kIOLogConfig        =         0x00000020ULL,
  63         kIOLogYield         =         0x00000040ULL,
  64         kIOLogPower         =         0x00000080ULL,
  65         kIOLogMapping       =         0x00000100ULL,
  66         kIOLogCatalogue     =         0x00000200ULL,
  67         kIOLogTracePower    =         0x00000400ULL,  // Obsolete: Use iotrace=0x00000400ULL to enable now
  68         kIOLogDebugPower    =         0x00000800ULL,
  69         kIOLogServiceTree   =         0x00001000ULL,
  70         kIOLogDTree         =         0x00002000ULL,
  71         kIOLogMemory        =         0x00004000ULL,
  72         kIOLogKextMemory    =         0x00008000ULL,
  73         kOSLogRegistryMods  =         0x00010000ULL,// Log attempts to modify registry collections
  74         kIOLogPMRootDomain  =         0x00020000ULL,
  75         kOSRegistryModsMode =         0x00040000ULL,// Change default registry modification handling - panic vs. log
  76 //    kIOTraceIOService   =         0x00080000ULL,  // Obsolete: Use iotrace=0x00080000ULL to enable now
  77         kIOLogHibernate     =         0x00100000ULL,
  78         kIOStatistics       =         0x04000000ULL,
  79         kIOSleepWakeWdogOff =         0x40000000ULL,
  80         kIOKextSpinDump     =         0x80000000ULL,
  81
  82         // debug aids - change behaviour
  83         kIONoFreeObjects    =         0x00100000ULL,
  84 //    kIOLogSynchronous   =         0x00200000ULL,  // IOLog completes synchronously -- obsolete
  85         kIOTracking         =         0x00400000ULL,
  86         kIOWaitQuietPanics  =         0x00800000ULL,
  87         kIOWaitQuietBeforeRoot =      0x01000000ULL,
  88         kIOTrackingBoot     =         0x02000000ULL,
  89
  90         _kIODebugTopFlag    = 0x8000000000000000ULL// force enum to be 64 bits
  91 };
  92
  93 enum {
  94         kIOKitDebugUserOptions = 0
  95             | kIOLogAttach
  96             | kIOLogProbe
  97             | kIOLogStart
  98             | kIOLogRegister
  99             | kIOLogMatch
 100             | kIOLogConfig
 101             | kIOLogYield
 102             | kIOLogPower
 103             | kIOLogMapping
 104             | kIOLogCatalogue
 105             | kIOLogTracePower
 106             | kIOLogDebugPower
 107             | kOSLogRegistryMods
 108             | kIOLogPMRootDomain
 109             | kOSRegistryModsMode
 110             | kIOLogHibernate
 111             | kIOSleepWakeWdogOff
 112             | kIOKextSpinDump
 113             | kIOWaitQuietPanics
 114 };
 115
 116 enum {
 117         kIOTraceInterrupts              =               0x00000001ULL,  // Trace primary interrupts
 118         kIOTraceWorkLoops               =               0x00000002ULL,  // Trace workloop activity
 119         kIOTraceEventSources    =               0x00000004ULL,  // Trace non-passive event sources
 120         kIOTraceIntEventSource  =               0x00000008ULL,  // Trace IOIES and IOFIES sources
 121         kIOTraceCommandGates    =               0x00000010ULL,  // Trace command gate activity
 122         kIOTraceTimers                  =               0x00000020ULL,  // Trace timer event source activity
 123
 124         kIOTracePowerMgmt               =               0x00000400ULL,  // Trace power management changes
 125
 126         kIOTraceIOService       =               0x00080000ULL,  // registerService/termination
 127
 128         kIOTraceCompatBootArgs  =               kIOTraceIOService | kIOTracePowerMgmt
 129 };
 130
 131 enum {
 132         kIODKEnable             = 0x00000001ULL,
 133         kIODKLogSetup   = 0x00000002ULL,
 134         kIODKLogIPC             = 0x00000004ULL,
 135         kIODKLogPM             = 0x00000008ULL,
 136         kIODKLogMessages = 0x00000010ULL,
 137
 138         kIODKDisablePM = 0x000000100ULL,
 139         kIODKDisableDextLaunch = 0x00001000ULL,
 140         kIODKDisableDextTag    = 0x00002000ULL,
 141         kIODKDisableCDHashChecking  = 0x00004000ULL,
 142         kIODKDisableEntitlementChecking = 0x00008000ULL,
 143         kIODKDisableCheckInTokenVerification = 0x00010000ULL,
 144 };
 145
 146 #if XNU_KERNEL_PRIVATE
 147
 148 #define DKLOG(fmt, args...) { IOLog("DK: " fmt, ## args); }
 149 #define DKS                "%s-0x%qx"
 150 #define DKN(s)              s->getName(), s->getRegistryEntryID()
 151
 152 #endif /* XNU_KERNEL_PRIVATE */
 153
 154 extern SInt64    gIOKitDebug;
 155 extern SInt64    gIOKitTrace;
 156 extern SInt64    gIODKDebug;
 157
 158 #ifdef __cplusplus
 159 extern "C" {
 160 #endif
 161
 162 #ifdef __cplusplus
 163 class IORegistryPlane;
 164 #endif
 165
 166 extern void    IOPrintPlane(
 167 #ifdef __cplusplus
 168         const IORegistryPlane * plane
 169 #else
 170         const struct IORegistryPlane * plane
 171 #endif
 172         );
 173 #ifndef _OSCPPDEBUG_H
 174 extern void    OSPrintMemory( void );
 175 #endif
 176 #define IOPrintMemory OSPrintMemory
 177
 178
 179
 180 #define kIOKitDiagnosticsClientClassName "IOKitDiagnosticsClient"
 181
 182 enum{
 183         kIOKitDiagnosticsClientType = 0x99000002
 184 };
 185
 186
 187 struct IOKitDiagnosticsParameters {
 188         size_t    size;
 189         uint64_t  value;
 190         uint32_t  options;
 191         uint32_t  tag;
 192         uint32_t  zsize;
 193         uint32_t  reserved[8];
 194 };
 195 typedef struct IOKitDiagnosticsParameters IOKitDiagnosticsParameters;
 196
 197 enum{
 198         kIOTrackingCallSiteBTs = 16,
 199 };
 200
 201 struct IOTrackingCallSiteInfo {
 202         uint32_t          count;
 203         pid_t             addressPID;
 204         mach_vm_address_t address;
 205         mach_vm_size_t    size[2];
 206         pid_t             btPID;
 207         mach_vm_address_t bt[2][kIOTrackingCallSiteBTs];
 208 };
 209
 210 #define kIOMallocTrackingName   "IOMalloc"
 211 #define kIOWireTrackingName     "IOWire"
 212 #define kIOMapTrackingName      "IOMap"
 213
 214 #if XNU_KERNEL_PRIVATE && IOTRACKING
 215
 216 struct IOTrackingQueue;
 217 struct IOTrackingCallSite;
 218
 219 struct IOTracking {
 220         queue_chain_t        link;
 221         IOTrackingCallSite * site;
 222 #if !defined(__LP64__)
 223         uint32_t             flags;
 224 #endif
 225 };
 226
 227 struct IOTrackingAddress {
 228         IOTracking    tracking;
 229         uintptr_t     address;
 230         size_t        size;
 231 #if defined(__LP64__)
 232         uint32_t      flags;
 233 #endif
 234 };
 235
 236 struct IOTrackingUser {
 237         queue_chain_t link;
 238         pid_t         btPID;
 239         uint8_t       user32;
 240         uint8_t       userCount;
 241         uintptr_t     bt[kIOTrackingCallSiteBTs];
 242         uintptr_t     btUser[kIOTrackingCallSiteBTs];
 243 };
 244
 245 enum{
 246         kIOTrackingQueueTypeDefaultOn = 0x00000001,
 247         kIOTrackingQueueTypeAlloc     = 0x00000002,
 248         kIOTrackingQueueTypeMap       = 0x00000004,
 249         kIOTrackingQueueTypeUser      = 0x00000008,
 250 };
 251
 252
 253 void              IOTrackingInit(void);
 254 IOTrackingQueue * IOTrackingQueueAlloc(const char * name, uintptr_t btEntry,
 255     size_t allocSize, size_t minCaptureSize,
 256     uint32_t type, uint32_t numSiteQs);
 257 void              IOTrackingQueueFree(IOTrackingQueue * head);
 258 void              IOTrackingQueueCollectUser(IOTrackingQueue * queue);
 259 void              IOTrackingAdd(IOTrackingQueue * head, IOTracking * mem, size_t size, bool address, vm_tag_t tag);
 260 void              IOTrackingRemove(IOTrackingQueue * head, IOTracking * mem, size_t size);
 261 void              IOTrackingAddUser(IOTrackingQueue * queue, IOTrackingUser * mem, vm_size_t size);
 262 void              IOTrackingRemoveUser(IOTrackingQueue * head, IOTrackingUser * tracking);
 263
 264 void              IOTrackingAlloc(IOTrackingQueue * head, uintptr_t address, size_t size);
 265 void              IOTrackingFree(IOTrackingQueue * head, uintptr_t address, size_t size);
 266 void              IOTrackingReset(IOTrackingQueue * head);
 267 void              IOTrackingAccumSize(IOTrackingQueue * head, IOTracking * mem, size_t size);
 268 kern_return_t     IOTrackingDebug(uint32_t selector, uint32_t options,
 269     const char * names, size_t namesLen,
 270     size_t size, OSObject ** result);
 271
 272 extern IOTrackingQueue * gIOMallocTracking;
 273 extern IOTrackingQueue * gIOWireTracking;
 274 extern IOTrackingQueue * gIOMapTracking;
 275
 276 #endif /* XNU_KERNEL_PRIVATE && IOTRACKING */
 277
 278 enum{
 279         kIOTrackingExcludeNames      = 0x00000001,
 280 };
 281
 282 enum{
 283         kIOTrackingGetTracking       = 0x00000001,
 284         kIOTrackingGetMappings       = 0x00000002,
 285         kIOTrackingResetTracking     = 0x00000003,
 286         kIOTrackingStartCapture      = 0x00000004,
 287         kIOTrackingStopCapture       = 0x00000005,
 288         kIOTrackingSetMinCaptureSize = 0x00000006,
 289         kIOTrackingLeaks             = 0x00000007,
 290         kIOTrackingInvalid           = 0xFFFFFFFE,
 291 };
 292
 293
 294 #ifdef __cplusplus
 295 } /* extern "C" */
 296 #endif /* __cplusplus */
 297
 298 #endif /* ! _IOKIT_IOKITDEBUG_H */