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 };
 146
 147 struct IODMACommandInternal
 148 {
 149     IOMDDMAWalkSegmentState fState;
 150     IOMDDMACharacteristics  fMDSummary;
 151
 152     UInt64 fPreparedOffset;
 153     UInt64 fPreparedLength;
 154
 155     UInt32 fSourceAlignMask;
 156
 157     UInt8  fCursor;
 158     UInt8  fCheckAddressing;
 159     UInt8  fIterateOnly;
 160     UInt8  fMisaligned;
 161     UInt8  fMapContig;
 162     UInt8  fPrepared;
 163     UInt8  fDoubleBuffer;
 164     UInt8  fNewMD;
 165     UInt8  fLocalMapper;
 166
 167     vm_page_t fCopyPageAlloc;
 168     vm_page_t fCopyNext;
 169     vm_page_t fNextRemapPage;
 170
 171     ppnum_t  fCopyPageCount;
 172
 173     addr64_t  fLocalMapperPageAlloc;
 174     ppnum_t  fLocalMapperPageCount;
 175
 176     class IOBufferMemoryDescriptor * fCopyMD;
 177
 178     IOService * fDevice;
 179
 180     // IODMAEventSource use
 181     IOReturn fStatus;
 182     UInt64   fActualByteCount;
 183 };
 184
 185 struct IOMemoryDescriptorDevicePager {
 186     void *                       devicePager;
 187     unsigned int             pagerContig:1;
 188     unsigned int             unused:31;
 189     IOMemoryDescriptor * memory;
 190 };
 191
 192 struct IOMemoryDescriptorReserved {
 193     IOMemoryDescriptorDevicePager dp;
 194     uint64_t                      preparationID;
 195     // for kernel IOMD subclasses... they have no expansion
 196     uint64_t                      kernReserved[4];
 197 };
 198
 199
 200 extern "C" struct timeval gIOLastSleepTime;
 201 extern "C" struct timeval gIOLastWakeTime;
 202
 203 extern clock_sec_t gIOConsoleLockTime;
 204
 205 extern "C" void IOKitResetTime( void );
 206 extern "C" void IOKitInitializeTime( void );
 207
 208 extern "C" OSString * IOCopyLogNameForPID(int pid);
 209
 210 #if defined(__i386__) || defined(__x86_64__)
 211 extern "C" void IOSetKeyStoreData(IOMemoryDescriptor * data);
 212 #endif
 213
 214 void IOScreenLockTimeUpdate(clock_sec_t secs);
 215
 216
 217 #endif /* ! _IOKIT_KERNELINTERNAL_H */