cpu_capabilities.h
1 /* 2 * Copyright (c) 2007 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 #ifdef PRIVATE 29 30 #ifndef _ARM_CPU_CAPABILITIES_H 31 #define _ARM_CPU_CAPABILITIES_H 32 33 #ifndef __ASSEMBLER__ 34 #include <stdint.h> 35 #include <mach/vm_types.h> 36 #endif 37 38 39 #define USER_TIMEBASE_NONE 0 40 #define USER_TIMEBASE_SPEC 1 41 42 /* 43 * This is the authoritative way to determine from user mode what 44 * implementation-specific processor features are available. 45 * This API only supported for Apple internal use. 46 * 47 */ 48 49 /* 50 * Bit definitions for _cpu_capabilities: 51 */ 52 #define kHasNeonFP16 0x00000008 // ARM v8.2 NEON FP16 supported 53 #define kCache32 0x00000010 // cache line size is 32 bytes 54 #define kCache64 0x00000020 // cache line size is 64 bytes 55 #define kCache128 0x00000040 // cache line size is 128 bytes 56 #define kFastThreadLocalStorage 0x00000080 // TLS ptr is kept in a user-mode-readable register 57 #define kHasNeon 0x00000100 // Advanced SIMD is supported 58 #define kHasNeonHPFP 0x00000200 // Advanced SIMD half-precision 59 #define kHasVfp 0x00000400 // VFP is supported 60 #define kHasUCNormalMemory 0x00000800 // Uncacheable normal memory type supported 61 #define kHasEvent 0x00001000 // WFE/SVE and period event wakeup 62 #define kHasFMA 0x00002000 // Fused multiply add is supported 63 #define kHasARMv82FHM 0x00004000 // Optional ARMv8.2 FMLAL/FMLSL instructions (required in ARMv8.4) 64 #define kUP 0x00008000 // set if (kNumCPUs == 1) 65 #define kNumCPUs 0x00FF0000 // number of CPUs (see _NumCPUs() below) 66 #define kHasARMv8Crypto 0x01000000 // Optional ARMv8 Crypto extensions 67 #define kHasARMv81Atomics 0x02000000 // ARMv8.1 Atomic instructions supported 68 #define kHasARMv8Crc32 0x04000000 // Optional ARMv8 crc32 instructions (required in ARMv8.1) 69 #define kHasARMv82SHA512 0x80000000 // Optional ARMv8.2 SHA512 instructions 70 /* Extending into 64-bits from here: */ 71 #define kHasARMv82SHA3 0x0000000100000000 // Optional ARMv8.2 SHA3 instructions 72 73 #define kNumCPUsShift 16 // see _NumCPUs() below 74 /* 75 * Bit definitions for multiuser_config: 76 */ 77 #define kIsMultiUserDevice 0x80000000 // this device is in multiuser mode 78 #define kMultiUserCurrentUserMask 0x7fffffff // the current user UID of the multiuser device 79 80 #ifndef __ASSEMBLER__ 81 #include <sys/commpage.h> 82 83 __BEGIN_DECLS 84 extern uint64_t _get_cpu_capabilities( void ); 85 __END_DECLS 86 87 __inline static 88 int 89 _NumCPUs( void ) 90 { 91 return (_get_cpu_capabilities() & kNumCPUs) >> kNumCPUsShift; 92 } 93 94 95 typedef struct { 96 volatile uint64_t TimeBase; 97 volatile uint32_t TimeStamp_sec; 98 volatile uint32_t TimeStamp_usec; 99 volatile uint32_t TimeBaseTicks_per_sec; 100 volatile uint32_t TimeBaseTicks_per_usec; 101 volatile uint64_t TimeBase_magic; 102 volatile uint32_t TimeBase_add; 103 volatile uint32_t TimeBase_shift; 104 } commpage_timeofday_data_t; 105 106 __BEGIN_DECLS 107 extern vm_address_t _get_commpage_priv_address(void); 108 extern vm_address_t _get_commpage_text_priv_address(void); 109 __END_DECLS 110 111 #endif /* __ASSEMBLER__ */ 112 113 114 /* 115 * The shared kernel/user "comm page(s)": 116 */ 117 118 #if defined(__LP64__) 119 120 #define _COMM_PAGE64_BASE_ADDRESS (0x0000000FFFFFC000ULL) /* In TTBR0 */ 121 #if defined(ARM_LARGE_MEMORY) 122 #define _COMM_HIGH_PAGE64_BASE_ADDRESS (0xFFFFFE00001FC000ULL) /* Just below the kernel, safely in TTBR1; only used for testing */ 123 #else 124 #define _COMM_HIGH_PAGE64_BASE_ADDRESS (0xFFFFFFF0001FC000ULL) /* Just below the kernel, safely in TTBR1; only used for testing */ 125 #endif 126 127 #define _COMM_PAGE64_AREA_LENGTH (_COMM_PAGE32_AREA_LENGTH) 128 #define _COMM_PAGE64_AREA_USED (-1) 129 130 #define _COMM_PAGE_PRIV(_addr_) ((_addr_) - (_COMM_PAGE_START_ADDRESS) + _get_commpage_priv_address()) 131 132 #ifdef KERNEL_PRIVATE 133 #define _COMM_PAGE_RW_OFFSET (0) 134 #define _COMM_PAGE_AREA_LENGTH (PAGE_SIZE) 135 136 #define _COMM_PAGE_BASE_ADDRESS (_get_commpage_priv_address()) 137 #define _COMM_PAGE_START_ADDRESS (_get_commpage_priv_address()) 138 139 /** 140 * This represents the size of the memory region that the commpage is nested in. 141 * On 4K page systems, this is 1GB, and on 16KB page systems this is technically 142 * only 32MB, but to keep consistency across address spaces we always reserve 143 * 1GB for the commpage on ARM devices. 144 * 145 * The commpage itself only takes up a single page, but its page tables are 146 * being shared across every user process. Entries should not be allowed to 147 * be created in those shared tables, which is why the VM uses these values to 148 * reserve the entire nesting region in every user process address space. 149 * 150 * If the commpage base address changes, these values might also need to be 151 * updated. 152 */ 153 #define _COMM_PAGE64_NESTING_START (0x0000000FC0000000ULL) 154 #define _COMM_PAGE64_NESTING_SIZE (0x40000000ULL) /* 1GiB */ 155 _Static_assert((_COMM_PAGE64_BASE_ADDRESS >= _COMM_PAGE64_NESTING_START) && 156 (_COMM_PAGE64_BASE_ADDRESS < (_COMM_PAGE64_NESTING_START + _COMM_PAGE64_NESTING_SIZE)), 157 "_COMM_PAGE64_BASE_ADDRESS is not within the nesting region. Commpage nesting " 158 "region probably needs to be updated."); 159 160 #else /* KERNEL_PRIVATE */ 161 /* 162 * <sys/commpage.h> defines a couple of conveniency macros 163 * to help read data from the commpage. 164 */ 165 #define _COMM_PAGE_AREA_LENGTH (4096) 166 167 #define _COMM_PAGE_BASE_ADDRESS _COMM_PAGE64_BASE_ADDRESS 168 #define _COMM_PAGE_START_ADDRESS _COMM_PAGE64_BASE_ADDRESS 169 #endif /* KERNEL_PRIVATE */ 170 171 #else /* __LP64__ */ 172 173 #define _COMM_PAGE64_BASE_ADDRESS (-1) 174 #define _COMM_PAGE64_AREA_LENGTH (-1) 175 #define _COMM_PAGE64_AREA_USED (-1) 176 177 // macro to change a user comm page address to one that is accessible from privileged mode 178 // this macro is stubbed as PAN is not available on AARCH32, 179 // but this may still be required for compatibility 180 #define _COMM_PAGE_PRIV(_addr_) (_addr_) 181 182 #ifdef KERNEL_PRIVATE 183 #define _COMM_PAGE_RW_OFFSET (_get_commpage_priv_address()-_COMM_PAGE_BASE_ADDRESS) 184 #define _COMM_PAGE_AREA_LENGTH (PAGE_SIZE) 185 #else /* KERNEL_PRIVATE */ 186 #define _COMM_PAGE_AREA_LENGTH (4096) 187 #endif /* KERNEL_PRIVATE */ 188 189 #define _COMM_PAGE_BASE_ADDRESS _COMM_PAGE32_BASE_ADDRESS 190 #define _COMM_PAGE_START_ADDRESS _COMM_PAGE32_BASE_ADDRESS 191 192 #endif /* __LP64__ */ 193 194 #define _COMM_PAGE32_BASE_ADDRESS (0xFFFF4000) /* Must be outside of normal map bounds */ 195 #define _COMM_PAGE32_AREA_LENGTH (_COMM_PAGE_AREA_LENGTH) 196 #define _COMM_PAGE32_TEXT_START (-1) 197 198 #define _COMM_PAGE32_OBJC_SIZE 0ULL 199 #define _COMM_PAGE32_OBJC_BASE 0ULL 200 #define _COMM_PAGE64_OBJC_SIZE 0ULL 201 #define _COMM_PAGE64_OBJC_BASE 0ULL 202 203 /* 204 * data in the comm pages 205 * apply _COMM_PAGE_PRIV macro to use these in privileged mode 206 */ 207 #define _COMM_PAGE_SIGNATURE (_COMM_PAGE_START_ADDRESS+0x000) // first few bytes are a signature 208 #define _COMM_PAGE_SIGNATURELEN (0x10) 209 #define _COMM_PAGE_CPU_CAPABILITIES64 (_COMM_PAGE_START_ADDRESS+0x010) /* uint64_t _cpu_capabilities */ 210 #define _COMM_PAGE_UNUSED (_COMM_PAGE_START_ADDRESS+0x018) /* 6 unused bytes */ 211 #define _COMM_PAGE_VERSION (_COMM_PAGE_START_ADDRESS+0x01E) // 16-bit version# 212 #define _COMM_PAGE_THIS_VERSION 3 // version of the commarea format 213 214 #define _COMM_PAGE_CPU_CAPABILITIES (_COMM_PAGE_START_ADDRESS+0x020) // uint32_t _cpu_capabilities 215 #define _COMM_PAGE_NCPUS (_COMM_PAGE_START_ADDRESS+0x022) // uint8_t number of configured CPUs 216 #define _COMM_PAGE_USER_PAGE_SHIFT_32 (_COMM_PAGE_START_ADDRESS+0x024) // VM page shift for 32-bit processes 217 #define _COMM_PAGE_USER_PAGE_SHIFT_64 (_COMM_PAGE_START_ADDRESS+0x025) // VM page shift for 64-bit processes 218 #define _COMM_PAGE_CACHE_LINESIZE (_COMM_PAGE_START_ADDRESS+0x026) // uint16_t cache line size 219 #define _COMM_PAGE_UNUSED4 (_COMM_PAGE_START_ADDRESS+0x028) // used to be _COMM_PAGE_SCHED_GEN: uint32_t scheduler generation number (count of pre-emptions) 220 #define _COMM_PAGE_UNUSED3 (_COMM_PAGE_START_ADDRESS+0x02C) // used to be _COMM_PAGE_SPIN_COUNT: uint32_t max spin count for mutex's 221 #define _COMM_PAGE_MEMORY_PRESSURE (_COMM_PAGE_START_ADDRESS+0x030) // uint32_t copy of vm_memory_pressure 222 #define _COMM_PAGE_ACTIVE_CPUS (_COMM_PAGE_START_ADDRESS+0x034) // uint8_t number of active CPUs (hw.activecpu) 223 #define _COMM_PAGE_PHYSICAL_CPUS (_COMM_PAGE_START_ADDRESS+0x035) // uint8_t number of physical CPUs (hw.physicalcpu_max) 224 #define _COMM_PAGE_LOGICAL_CPUS (_COMM_PAGE_START_ADDRESS+0x036) // uint8_t number of logical CPUs (hw.logicalcpu_max) 225 #define _COMM_PAGE_KERNEL_PAGE_SHIFT (_COMM_PAGE_START_ADDRESS+0x037) // uint8_t kernel vm page shift */ 226 #define _COMM_PAGE_MEMORY_SIZE (_COMM_PAGE_START_ADDRESS+0x038) // uint64_t max memory size */ 227 #define _COMM_PAGE_TIMEOFDAY_DATA (_COMM_PAGE_START_ADDRESS+0x040) // used by gettimeofday(). Currently, sizeof(commpage_timeofday_data_t) = 40. A new struct is used on gettimeofday but space is reserved on the commpage for compatibility 228 #define _COMM_PAGE_CPUFAMILY (_COMM_PAGE_START_ADDRESS+0x080) // used by memcpy() resolver 229 #define _COMM_PAGE_DEV_FIRM (_COMM_PAGE_START_ADDRESS+0x084) // uint32_t handle on PE_i_can_has_debugger 230 #define _COMM_PAGE_TIMEBASE_OFFSET (_COMM_PAGE_START_ADDRESS+0x088) // uint64_t timebase offset for constructing mach_absolute_time() 231 #define _COMM_PAGE_USER_TIMEBASE (_COMM_PAGE_START_ADDRESS+0x090) // uint8_t is userspace mach_absolute_time supported (can read the timebase) 232 #define _COMM_PAGE_CONT_HWCLOCK (_COMM_PAGE_START_ADDRESS+0x091) // uint8_t is always-on hardware clock present for mach_continuous_time() 233 #define _COMM_PAGE_DTRACE_DOF_ENABLED (_COMM_PAGE_START_ADDRESS+0x092) // uint8_t 0 if userspace DOF disable, 1 if enabled 234 #define _COMM_PAGE_UNUSED0 (_COMM_PAGE_START_ADDRESS+0x093) // 5 unused bytes 235 #define _COMM_PAGE_CONT_TIMEBASE (_COMM_PAGE_START_ADDRESS+0x098) // uint64_t base for mach_continuous_time() relative to mach_absolute_time() 236 #define _COMM_PAGE_BOOTTIME_USEC (_COMM_PAGE_START_ADDRESS+0x0A0) // uint64_t boottime in microseconds 237 #define _COMM_PAGE_CONT_HW_TIMEBASE (_COMM_PAGE_START_ADDRESS+0x0A8) // uint64_t base for mach_continuous_time() relative to CNT[PV]CT 238 239 // aligning to 64byte for cacheline size 240 #define _COMM_PAGE_APPROX_TIME (_COMM_PAGE_START_ADDRESS+0x0C0) // uint64_t last known mach_absolute_time() 241 #define _COMM_PAGE_APPROX_TIME_SUPPORTED (_COMM_PAGE_START_ADDRESS+0x0C8) // uint8_t is mach_approximate_time supported 242 #define _COMM_PAGE_UNUSED1 (_COMM_PAGE_START_ADDRESS+0x0C9) // 55 unused bytes, align next mutable value to a separate cache line 243 244 #define _COMM_PAGE_KDEBUG_ENABLE (_COMM_PAGE_START_ADDRESS+0x100) // uint32_t export kdebug status bits to userspace 245 #define _COMM_PAGE_ATM_DIAGNOSTIC_CONFIG (_COMM_PAGE_START_ADDRESS+0x104) // uint32_t export "atm_diagnostic_config" to userspace 246 #define _COMM_PAGE_MULTIUSER_CONFIG (_COMM_PAGE_START_ADDRESS+0x108) // uint32_t export "multiuser_config" to userspace 247 248 249 #define _COMM_PAGE_NEWTIMEOFDAY_DATA (_COMM_PAGE_START_ADDRESS+0x120) // used by gettimeofday(). Currently, sizeof(new_commpage_timeofday_data_t) = 40. 250 #define _COMM_PAGE_REMOTETIME_PARAMS (_COMM_PAGE_START_ADDRESS+0x148) // used by mach_bridge_remote_time(). Currently, sizeof(struct bt_params) = 24 251 #define _COMM_PAGE_DYLD_FLAGS (_COMM_PAGE_START_ADDRESS+0x160) // uint64_t export kern.dyld_system_flags to userspace 252 253 // aligning to 128 bytes for cacheline/fabric size 254 #define _COMM_PAGE_CPU_QUIESCENT_COUNTER (_COMM_PAGE_START_ADDRESS+0x180) // uint64_t, but reserve the whole 128 (0x80) bytes 255 256 #define _COMM_PAGE_END (_COMM_PAGE_START_ADDRESS+0xfff) // end of common page 257 258 #if defined(__LP64__) 259 #if KERNEL_PRIVATE 260 #define _COMM_PAGE64_TEXT_START_ADDRESS (_get_commpage_text_priv_address()) // Address through physical aperture 261 #endif 262 /* Offset in bytes from start of text comm page to get to these functions. Start 263 * address to text comm page is from apple array */ 264 #define _COMM_PAGE_TEXT_ATOMIC_ENQUEUE (0x0) 265 #define _COMM_PAGE_TEXT_ATOMIC_DEQUEUE (0x4) 266 267 #else /* __LP64__ */ 268 /* No 32 bit text region */ 269 #endif /* __LP64__ */ 270 271 #endif /* _ARM_CPU_CAPABILITIES_H */ 272 #endif /* PRIVATE */