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