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
  41 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  42
  43 #if (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD)
  44
  45 #define IOServiceTrace(csc, a, b, c, d) do {                            \
  46     if(kIOTraceIOService & gIOKitDebug) {                               \
  47         KERNEL_DEBUG_CONSTANT(IODBG_IOSERVICE(csc), a, b, c, d, 0);     \
  48     }                                                                   \
  49 } while(0)
  50
  51 #else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
  52
  53 #define IOServiceTrace(csc, a, b, c, d) do {    \
  54   (void)a;                                      \
  55   (void)b;                                      \
  56   (void)c;                                      \
  57   (void)d;                                      \
  58 } while (0)
  59
  60 #endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
  61
  62 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  63
  64 typedef kern_return_t (*IOIteratePageableMapsCallback)(vm_map_t map, void * ref);
  65
  66 void IOLibInit(void);
  67 kern_return_t IOIteratePageableMaps(vm_size_t size,
  68                     IOIteratePageableMapsCallback callback, void * ref);
  69 vm_map_t IOPageableMapForAddress(uintptr_t address);
  70
  71 kern_return_t
  72 IOMemoryDescriptorMapMemEntry(vm_map_t * map, ipc_port_t entry, IOOptionBits options, bool pageable,
  73                                 mach_vm_size_t offset, mach_vm_address_t * address, mach_vm_size_t length);
  74 kern_return_t
  75 IOMemoryDescriptorMapCopy(vm_map_t * map,
  76                                 IOOptionBits options,
  77                                 mach_vm_size_t offset,
  78                                 mach_vm_address_t * address, mach_vm_size_t length);
  79
  80 mach_vm_address_t
  81 IOKernelAllocateWithPhysicalRestrict(mach_vm_size_t size, mach_vm_address_t maxPhys,
  82                                         mach_vm_size_t alignment, bool contiguous);
  83 void
  84 IOKernelFreePhysical(mach_vm_address_t address, mach_vm_size_t size);
  85
  86
  87 extern vm_size_t debug_iomallocpageable_size;
  88
  89 // osfmk/device/iokit_rpc.c
  90 extern kern_return_t IOMapPages(vm_map_t map, mach_vm_address_t va, mach_vm_address_t pa,
  91                                  mach_vm_size_t length, unsigned int mapFlags);
  92 extern kern_return_t IOUnmapPages(vm_map_t map, mach_vm_address_t va, mach_vm_size_t length);
  93
  94 extern kern_return_t IOProtectCacheMode(vm_map_t map, mach_vm_address_t va,
  95                                         mach_vm_size_t length, unsigned int mapFlags);
  96
  97 extern ppnum_t IOGetLastPageNumber(void);
  98
  99 extern ppnum_t gIOLastPage;
 100
 101 extern IOSimpleLock * gIOPageAllocLock;
 102 extern queue_head_t   gIOPageAllocList;
 103
 104 /* Physical to physical copy (ints must be disabled) */
 105 extern void bcopy_phys(addr64_t from, addr64_t to, vm_size_t size);
 106
 107 __END_DECLS
 108
 109 // Used for dedicated communications for IODMACommand
 110 enum  {
 111     kIOMDWalkSegments             = 0x01000000,
 112     kIOMDFirstSegment             = 1 | kIOMDWalkSegments,
 113     kIOMDGetCharacteristics       = 0x02000000,
 114     kIOMDGetCharacteristicsMapped = 1 | kIOMDGetCharacteristics,
 115     kIOMDDMAActive                = 0x03000000,
 116     kIOMDSetDMAActive             = 1 | kIOMDDMAActive,
 117     kIOMDSetDMAInactive           = kIOMDDMAActive,
 118     kIOMDAddDMAMapSpec            = 0x04000000,
 119     kIOMDDMAMap                   = 0x05000000,
 120     kIOMDDMACommandOperationMask  = 0xFF000000,
 121 };
 122 struct IOMDDMACharacteristics {
 123     UInt64 fLength;
 124     UInt32 fSGCount;
 125     UInt32 fPages;
 126     UInt32 fPageAlign;
 127     ppnum_t fHighestPage;
 128     IODirection fDirection;
 129     UInt8 fIsPrepared;
 130 };
 131 struct IOMDDMAWalkSegmentArgs {
 132     UInt64 fOffset;                     // Input/Output offset
 133     UInt64 fIOVMAddr, fLength;          // Output variables
 134     UInt8 fMapped;                      // Input Variable, Require mapped IOVMA
 135 };
 136 typedef UInt8 IOMDDMAWalkSegmentState[128];
 137
 138 struct IOMDDMAMapArgs {
 139     IOMapper *            fMapper;
 140     IODMAMapSpecification fMapSpec;
 141     uint64_t              fOffset;
 142     uint64_t              fLength;
 143     uint64_t              fAlloc;
 144     ppnum_t               fAllocCount;
 145     uint8_t               fMapContig;
 146 };
 147
 148 struct IODMACommandInternal
 149 {
 150     IOMDDMAWalkSegmentState fState;
 151     IOMDDMACharacteristics  fMDSummary;
 152
 153     UInt64 fPreparedOffset;
 154     UInt64 fPreparedLength;
 155
 156     UInt32 fSourceAlignMask;
 157
 158     UInt8  fCursor;
 159     UInt8  fCheckAddressing;
 160     UInt8  fIterateOnly;
 161     UInt8  fMisaligned;
 162     UInt8  fMapContig;
 163     UInt8  fPrepared;
 164     UInt8  fDoubleBuffer;
 165     UInt8  fNewMD;
 166     UInt8  fLocalMapper;
 167
 168     vm_page_t fCopyPageAlloc;
 169     vm_page_t fCopyNext;
 170     vm_page_t fNextRemapPage;
 171
 172     ppnum_t  fCopyPageCount;
 173
 174     addr64_t  fLocalMapperPageAlloc;
 175     ppnum_t  fLocalMapperPageCount;
 176
 177     class IOBufferMemoryDescriptor * fCopyMD;
 178
 179     IOService * fDevice;
 180
 181     // IODMAEventSource use
 182     IOReturn fStatus;
 183     UInt64   fActualByteCount;
 184     AbsoluteTime    fTimeStamp;
 185 };
 186
 187 struct IOMemoryDescriptorDevicePager {
 188     void *                       devicePager;
 189     unsigned int             pagerContig:1;
 190     unsigned int             unused:31;
 191     IOMemoryDescriptor * memory;
 192 };
 193
 194 struct IOMemoryDescriptorReserved {
 195     IOMemoryDescriptorDevicePager dp;
 196     uint64_t                      preparationID;
 197     // for kernel IOMD subclasses... they have no expansion
 198     uint64_t                      kernReserved[4];
 199 };
 200
 201 struct iopa_t
 202 {
 203     IOLock       * lock;
 204     queue_head_t   list;
 205     vm_size_t      pagecount;
 206     vm_size_t      bytecount;
 207 };
 208
 209 struct iopa_page_t
 210 {
 211     queue_chain_t link;
 212     uint64_t      avail;
 213     uint32_t      signature;
 214 };
 215 typedef struct iopa_page_t iopa_page_t;
 216
 217 typedef uintptr_t (*iopa_proc_t)(iopa_t * a);
 218
 219 enum
 220 {
 221     kIOPageAllocChunkBytes = (PAGE_SIZE / 64),
 222     kIOPageAllocSignature  = 'iopa'
 223 };
 224
 225 extern "C" void      iopa_init(iopa_t * a);
 226 extern "C" uintptr_t iopa_alloc(iopa_t * a, iopa_proc_t alloc, vm_size_t bytes, uint32_t balign);
 227 extern "C" uintptr_t iopa_free(iopa_t * a, uintptr_t addr, vm_size_t bytes);
 228
 229 extern "C" iopa_t    gIOBMDPageAllocator;
 230
 231 extern "C" struct timeval gIOLastSleepTime;
 232 extern "C" struct timeval gIOLastWakeTime;
 233
 234 extern clock_sec_t gIOConsoleLockTime;
 235
 236 extern "C" void IOKitResetTime( void );
 237 extern "C" void IOKitInitializeTime( void );
 238
 239 extern "C" OSString * IOCopyLogNameForPID(int pid);
 240
 241 #if defined(__i386__) || defined(__x86_64__)
 242 extern "C" void IOSetKeyStoreData(IOMemoryDescriptor * data);
 243 #endif
 244
 245 void IOScreenLockTimeUpdate(clock_sec_t secs);
 246
 247
 248 #endif /* ! _IOKIT_KERNELINTERNAL_H */