iokit/Kernel/IOKitKernelInternal.h

   1 /*
   2  * Copyright (c) 1998-2000 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
  30 #ifndef _IOKIT_KERNELINTERNAL_H
  31 #define _IOKIT_KERNELINTERNAL_H
  32
  33 #include <sys/cdefs.h>
  34
  35 __BEGIN_DECLS
  36
  37 #include <vm/vm_pageout.h>
  38 #include <mach/memory_object_types.h>
  39 #include <device/device_port.h>
  40 #include <IOKit/IODMACommand.h>
  41 #include <IOKit/IOKitServer.h>
  42
  43 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  44
  45 #if (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD)
  46
  47 #define IOServiceTrace(csc, a, b, c, d) do {                            \
  48     if(kIOTraceIOService & gIOKitTrace) {                               \
  49         KERNEL_DEBUG_CONSTANT(IODBG_IOSERVICE(csc), a, b, c, d, 0);     \
  50     }                                                                   \
  51 } while(0)
  52
  53 #else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
  54
  55 #define IOServiceTrace(csc, a, b, c, d) do {    \
  56   (void)a;                                      \
  57   (void)b;                                      \
  58   (void)c;                                      \
  59   (void)d;                                      \
  60 } while (0)
  61
  62 #endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
  63
  64 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  65
  66 typedef kern_return_t (*IOIteratePageableMapsCallback)(vm_map_t map, void * ref);
  67
  68 void IOLibInit(void);
  69 kern_return_t IOIteratePageableMaps(vm_size_t size,
  70                     IOIteratePageableMapsCallback callback, void * ref);
  71 vm_map_t IOPageableMapForAddress(uintptr_t address);
  72
  73 struct IOMemoryDescriptorMapAllocRef
  74 {
  75     vm_map_t          map;
  76     mach_vm_address_t mapped;
  77     mach_vm_size_t    size;
  78     vm_prot_t         prot;
  79     vm_tag_t          tag;
  80     IOOptionBits      options;
  81 };
  82
  83 kern_return_t
  84 IOMemoryDescriptorMapAlloc(vm_map_t map, void * ref);
  85
  86
  87 mach_vm_address_t
  88 IOKernelAllocateWithPhysicalRestrict(mach_vm_size_t size, mach_vm_address_t maxPhys,
  89                                         mach_vm_size_t alignment, bool contiguous);
  90 void
  91 IOKernelFreePhysical(mach_vm_address_t address, mach_vm_size_t size);
  92
  93 #if IOTRACKING
  94 IOReturn
  95 IOMemoryMapTracking(IOTrackingUser * tracking, task_t * task,
  96                     mach_vm_address_t * address, mach_vm_size_t * size);
  97 #endif /* IOTRACKING */
  98
  99 extern vm_size_t debug_iomallocpageable_size;
 100
 101 extern ppnum_t gIOLastPage;
 102
 103 extern IOSimpleLock * gIOPageAllocLock;
 104 extern queue_head_t   gIOPageAllocList;
 105
 106 /* Physical to physical copy (ints must be disabled) */
 107 extern void bcopy_phys(addr64_t from, addr64_t to, vm_size_t size);
 108
 109 __END_DECLS
 110
 111 #define __IODEQUALIFY(type, expr)                               \
 112    ({ typeof(expr) expr_ = (type)(uintptr_t)(expr);             \
 113        (type)(uintptr_t)(expr_); })
 114
 115
 116 struct IODMACommandInternal
 117 {
 118     IOMDDMAWalkSegmentState      fState;
 119     IOMDDMACharacteristics       fMDSummary;
 120
 121     UInt64 fPreparedOffset;
 122     UInt64 fPreparedLength;
 123
 124     UInt32 fSourceAlignMask;
 125
 126     UInt8  fCursor;
 127     UInt8  fCheckAddressing;
 128     UInt8  fIterateOnly;
 129     UInt8  fMisaligned;
 130     UInt8  fMapContig;
 131     UInt8  fPrepared;
 132     UInt8  fDoubleBuffer;
 133     UInt8  fNewMD;
 134     UInt8  fLocalMapper;
 135     UInt8  fLocalMapperAllocValid;
 136     UInt8  fIOVMAddrValid;
 137     UInt8  fForceDoubleBuffer;
 138
 139     vm_page_t fCopyPageAlloc;
 140     vm_page_t fCopyNext;
 141     vm_page_t fNextRemapPage;
 142
 143     ppnum_t  fCopyPageCount;
 144
 145     uint64_t  fLocalMapperAlloc;
 146     uint64_t  fLocalMapperAllocLength;
 147
 148     class IOBufferMemoryDescriptor * fCopyMD;
 149
 150     IOService * fDevice;
 151
 152     // IODMAEventSource use
 153     IOReturn fStatus;
 154     UInt64   fActualByteCount;
 155     AbsoluteTime    fTimeStamp;
 156 };
 157
 158 struct IOMemoryDescriptorDevicePager {
 159     void *                       devicePager;
 160     unsigned int             pagerContig:1;
 161     unsigned int             unused:31;
 162     IOMemoryDescriptor * memory;
 163 };
 164
 165 struct IOMemoryDescriptorReserved {
 166     IOMemoryDescriptorDevicePager dp;
 167     uint64_t                      preparationID;
 168     // for kernel IOMD subclasses... they have no expansion
 169     uint64_t                      kernReserved[4];
 170     vm_tag_t                      kernelTag;
 171     vm_tag_t                      userTag;
 172 };
 173
 174 struct iopa_t
 175 {
 176     IOLock       * lock;
 177     queue_head_t   list;
 178     vm_size_t      pagecount;
 179     vm_size_t      bytecount;
 180 };
 181
 182 struct iopa_page_t
 183 {
 184     queue_chain_t link;
 185     uint64_t      avail;
 186     uint32_t      signature;
 187 };
 188 typedef struct iopa_page_t iopa_page_t;
 189
 190 typedef uintptr_t (*iopa_proc_t)(iopa_t * a);
 191
 192 enum
 193 {
 194     kIOPageAllocSignature  = 'iopa'
 195 };
 196
 197 extern "C" void      iopa_init(iopa_t * a);
 198 extern "C" uintptr_t iopa_alloc(iopa_t * a, iopa_proc_t alloc, vm_size_t bytes, uint32_t balign);
 199 extern "C" uintptr_t iopa_free(iopa_t * a, uintptr_t addr, vm_size_t bytes);
 200 extern "C" uint32_t  gIOPageAllocChunkBytes;
 201
 202 extern "C" iopa_t    gIOBMDPageAllocator;
 203
 204 extern "C" struct timeval gIOLastSleepTime;
 205 extern "C" struct timeval gIOLastWakeTime;
 206
 207 extern clock_sec_t gIOConsoleLockTime;
 208
 209 extern bool gCPUsRunning;
 210
 211 extern OSSet * gIORemoveOnReadProperties;
 212
 213 extern "C" void IOKitInitializeTime( void );
 214
 215 extern "C" OSString * IOCopyLogNameForPID(int pid);
 216
 217 #if defined(__i386__) || defined(__x86_64__)
 218 #ifndef __cplusplus
 219 #error xx
 220 #endif
 221
 222 extern const OSSymbol * gIOCreateEFIDevicePathSymbol;
 223 extern "C" void IOSetKeyStoreData(IOMemoryDescriptor * data);
 224 extern "C" void IOSetAPFSKeyStoreData(IOMemoryDescriptor* data);
 225 #endif
 226 extern const  OSSymbol * gAKSGetKey;
 227
 228 void IOScreenLockTimeUpdate(clock_sec_t secs);
 229
 230 void     IOCPUInitialize(void);
 231 IOReturn IOInstallServicePlatformActions(IOService * service);
 232 IOReturn IORemoveServicePlatformActions(IOService * service);
 233
 234 #endif /* ! _IOKIT_KERNELINTERNAL_H */