1 /*
2 * Copyright (c) 2000-2020 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 * @OSF_COPYRIGHT@
30 */
31 /*
32 * Mach Operating System
33 * Copyright (c) 1991,1990,1989 Carnegie Mellon University
34 * All Rights Reserved.
35 *
36 * Permission to use, copy, modify and distribute this software and its
37 * documentation is hereby granted, provided that both the copyright
38 * notice and this permission notice appear in all copies of the
39 * software, derivative works or modified versions, and any portions
40 * thereof, and that both notices appear in supporting documentation.
41 *
42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
43 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
45 *
46 * Carnegie Mellon requests users of this software to return to
47 *
48 * Software Distribution Coordinator or [email protected]
49 * School of Computer Science
50 * Carnegie Mellon University
51 * Pittsburgh PA 15213-3890
52 *
53 * any improvements or extensions that they make and grant Carnegie Mellon
54 * the rights to redistribute these changes.
55 */
56 /*
57 */
58 /*
59 * File: thread_status.h
60 * Author: Avadis Tevanian, Jr.
61 * Date: 1985
62 *
63 * This file contains the structure definitions for the thread
64 * state as applied to I386 processors.
65 */
66
67 #ifndef _MACH_I386_THREAD_STATUS_H_
68 #define _MACH_I386_THREAD_STATUS_H_
69
70 #if defined (__i386__) || defined (__x86_64__)
71
72 #include <mach/machine/_structs.h>
73 #include <mach/machine/thread_state.h>
74 #include <mach/message.h>
75 #include <mach/i386/fp_reg.h>
76 #include <i386/eflags.h>
77
78 #ifdef KERNEL_PRIVATE
79 #include <i386/proc_reg.h>
80 #endif
81
82 /*
83 * the i386_xxxx form is kept for legacy purposes since these types
84 * are externally known... eventually they should be deprecated.
85 * our internal implementation has moved to the following naming convention
86 *
87 * x86_xxxx32 names are used to deal with 32 bit states
88 * x86_xxxx64 names are used to deal with 64 bit states
89 * x86_xxxx names are used to deal with either 32 or 64 bit states
90 * via a self-describing mechanism
91 */
92
93 /*
94 * these are the legacy names which should be deprecated in the future
95 * they are externally known which is the only reason we don't just get
96 * rid of them
97 */
98 #define i386_THREAD_STATE 1
99 #define i386_FLOAT_STATE 2
100 #define i386_EXCEPTION_STATE 3
101
102 /*
103 * THREAD_STATE_FLAVOR_LIST 0
104 * these are the supported flavors
105 */
106 #define x86_THREAD_STATE32 1
107 #define x86_FLOAT_STATE32 2
108 #define x86_EXCEPTION_STATE32 3
109 #define x86_THREAD_STATE64 4
110 #define x86_FLOAT_STATE64 5
111 #define x86_EXCEPTION_STATE64 6
112 #define x86_THREAD_STATE 7
113 #define x86_FLOAT_STATE 8
114 #define x86_EXCEPTION_STATE 9
115 #define x86_DEBUG_STATE32 10
116 #define x86_DEBUG_STATE64 11
117 #define x86_DEBUG_STATE 12
118 #define THREAD_STATE_NONE 13
119 /* 14 and 15 are used for the internal x86_SAVED_STATE flavours */
120 /* Arrange for flavors to take sequential values, 32-bit, 64-bit, non-specific */
121 #define x86_AVX_STATE32 16
122 #define x86_AVX_STATE64 (x86_AVX_STATE32 + 1)
123 #define x86_AVX_STATE (x86_AVX_STATE32 + 2)
124 #define x86_AVX512_STATE32 19
125 #define x86_AVX512_STATE64 (x86_AVX512_STATE32 + 1)
126 #define x86_AVX512_STATE (x86_AVX512_STATE32 + 2)
127 #define x86_PAGEIN_STATE 22
128 #define x86_THREAD_FULL_STATE64 23
129 #define x86_INSTRUCTION_STATE 24
130 #define x86_LAST_BRANCH_STATE 25
131 #define THREAD_STATE_FLAVORS 26 /* This must be updated to 1 more than the highest numerical state flavor */
132
133 /*
134 * Largest state on this machine:
135 * (be sure mach/machine/thread_state.h matches!)
136 */
137 #define THREAD_MACHINE_STATE_MAX THREAD_STATE_MAX
138
139 #define FLAVOR_MODIFIES_CORE_CPU_REGISTERS(x) \
140 ((x == x86_THREAD_STATE) || \
141 (x == x86_THREAD_STATE32) || \
142 (x == x86_THREAD_STATE64) || \
143 (x == x86_THREAD_FULL_STATE64))
144
145 /*
146 * VALID_THREAD_STATE_FLAVOR is a platform specific macro that when passed
147 * an exception flavor will return if that is a defined flavor for that
148 * platform. The macro must be manually updated to include all of the valid
149 * exception flavors as defined above.
150 */
151 #define VALID_THREAD_STATE_FLAVOR(x) \
152 ((x == x86_THREAD_STATE32) || \
153 (x == x86_FLOAT_STATE32) || \
154 (x == x86_EXCEPTION_STATE32) || \
155 (x == x86_DEBUG_STATE32) || \
156 (x == x86_THREAD_STATE64) || \
157 (x == x86_THREAD_FULL_STATE64) || \
158 (x == x86_FLOAT_STATE64) || \
159 (x == x86_EXCEPTION_STATE64) || \
160 (x == x86_DEBUG_STATE64) || \
161 (x == x86_THREAD_STATE) || \
162 (x == x86_FLOAT_STATE) || \
163 (x == x86_EXCEPTION_STATE) || \
164 (x == x86_DEBUG_STATE) || \
165 (x == x86_AVX_STATE32) || \
166 (x == x86_AVX_STATE64) || \
167 (x == x86_AVX_STATE) || \
168 (x == x86_AVX512_STATE32) || \
169 (x == x86_AVX512_STATE64) || \
170 (x == x86_AVX512_STATE) || \
171 (x == x86_PAGEIN_STATE) || \
172 (x == x86_INSTRUCTION_STATE) || \
173 (x == x86_LAST_BRANCH_STATE) || \
174 (x == THREAD_STATE_NONE))
175
176 struct x86_state_hdr {
177 uint32_t flavor;
178 uint32_t count;
179 };
180 typedef struct x86_state_hdr x86_state_hdr_t;
181
182 /*
183 * Default segment register values.
184 */
185
186 #define USER_CODE_SELECTOR 0x0017
187 #define USER_DATA_SELECTOR 0x001f
188 #define KERN_CODE_SELECTOR 0x0008
189 #define KERN_DATA_SELECTOR 0x0010
190
191 /*
192 * to be deprecated in the future
193 */
194 typedef _STRUCT_X86_THREAD_STATE32 i386_thread_state_t;
195 #define i386_THREAD_STATE_COUNT ((mach_msg_type_number_t) \
196 ( sizeof (i386_thread_state_t) / sizeof (int) ))
197
198 typedef _STRUCT_X86_THREAD_STATE32 x86_thread_state32_t;
199 #define x86_THREAD_STATE32_COUNT ((mach_msg_type_number_t) \
200 ( sizeof (x86_thread_state32_t) / sizeof (int) ))
201
202 /*
203 * to be deprecated in the future
204 */
205 typedef _STRUCT_X86_FLOAT_STATE32 i386_float_state_t;
206 #define i386_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \
207 (sizeof(i386_float_state_t)/sizeof(unsigned int)))
208
209 typedef _STRUCT_X86_FLOAT_STATE32 x86_float_state32_t;
210 #define x86_FLOAT_STATE32_COUNT ((mach_msg_type_number_t) \
211 (sizeof(x86_float_state32_t)/sizeof(unsigned int)))
212
213 typedef _STRUCT_X86_AVX_STATE32 x86_avx_state32_t;
214 #define x86_AVX_STATE32_COUNT ((mach_msg_type_number_t) \
215 (sizeof(x86_avx_state32_t)/sizeof(unsigned int)))
216
217 typedef _STRUCT_X86_AVX512_STATE32 x86_avx512_state32_t;
218 #define x86_AVX512_STATE32_COUNT ((mach_msg_type_number_t) \
219 (sizeof(x86_avx512_state32_t)/sizeof(unsigned int)))
220
221 /*
222 * to be deprecated in the future
223 */
224 typedef _STRUCT_X86_EXCEPTION_STATE32 i386_exception_state_t;
225 #define i386_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \
226 ( sizeof (i386_exception_state_t) / sizeof (int) ))
227
228 typedef _STRUCT_X86_EXCEPTION_STATE32 x86_exception_state32_t;
229 #define x86_EXCEPTION_STATE32_COUNT ((mach_msg_type_number_t) \
230 ( sizeof (x86_exception_state32_t) / sizeof (int) ))
231
232 #define I386_EXCEPTION_STATE_COUNT i386_EXCEPTION_STATE_COUNT
233
234 typedef _STRUCT_X86_DEBUG_STATE32 x86_debug_state32_t;
235 #define x86_DEBUG_STATE32_COUNT ((mach_msg_type_number_t) \
236 ( sizeof (x86_debug_state32_t) / sizeof (int) ))
237
238 #define X86_DEBUG_STATE32_COUNT x86_DEBUG_STATE32_COUNT
239
240 typedef _STRUCT_X86_THREAD_STATE64 x86_thread_state64_t;
241 #define x86_THREAD_STATE64_COUNT ((mach_msg_type_number_t) \
242 ( sizeof (x86_thread_state64_t) / sizeof (int) ))
243
244 typedef _STRUCT_X86_THREAD_FULL_STATE64 x86_thread_full_state64_t;
245 #define x86_THREAD_FULL_STATE64_COUNT ((mach_msg_type_number_t) \
246 ( sizeof (x86_thread_full_state64_t) / sizeof (int) ))
247
248 typedef _STRUCT_X86_FLOAT_STATE64 x86_float_state64_t;
249 #define x86_FLOAT_STATE64_COUNT ((mach_msg_type_number_t) \
250 (sizeof(x86_float_state64_t)/sizeof(unsigned int)))
251
252 typedef _STRUCT_X86_AVX_STATE64 x86_avx_state64_t;
253 #define x86_AVX_STATE64_COUNT ((mach_msg_type_number_t) \
254 (sizeof(x86_avx_state64_t)/sizeof(unsigned int)))
255
256 typedef _STRUCT_X86_AVX512_STATE64 x86_avx512_state64_t;
257 #define x86_AVX512_STATE64_COUNT ((mach_msg_type_number_t) \
258 (sizeof(x86_avx512_state64_t)/sizeof(unsigned int)))
259
260 typedef _STRUCT_X86_EXCEPTION_STATE64 x86_exception_state64_t;
261 #define x86_EXCEPTION_STATE64_COUNT ((mach_msg_type_number_t) \
262 ( sizeof (x86_exception_state64_t) / sizeof (int) ))
263
264 #define X86_EXCEPTION_STATE64_COUNT x86_EXCEPTION_STATE64_COUNT
265
266 typedef _STRUCT_X86_DEBUG_STATE64 x86_debug_state64_t;
267 #define x86_DEBUG_STATE64_COUNT ((mach_msg_type_number_t) \
268 ( sizeof (x86_debug_state64_t) / sizeof (int) ))
269
270 #define X86_DEBUG_STATE64_COUNT x86_DEBUG_STATE64_COUNT
271
272 typedef _STRUCT_X86_PAGEIN_STATE x86_pagein_state_t;
273 #define x86_PAGEIN_STATE_COUNT \
274 ((mach_msg_type_number_t)(sizeof(x86_pagein_state_t) / sizeof(int)))
275
276 #define X86_PAGEIN_STATE_COUNT x86_PAGEIN_STATE_COUNT
277
278 typedef _STRUCT_X86_INSTRUCTION_STATE x86_instruction_state_t;
279 #define x86_INSTRUCTION_STATE_COUNT \
280 ((mach_msg_type_number_t)(sizeof(x86_instruction_state_t) / sizeof(int)))
281
282 #define X86_INSTRUCTION_STATE_COUNT x86_INSTRUCTION_STATE_COUNT
283
284 typedef _STRUCT_LAST_BRANCH_STATE last_branch_state_t;
285 #define x86_LAST_BRANCH_STATE_COUNT \
286 ((mach_msg_type_number_t)(sizeof(last_branch_state_t) / sizeof(int)))
287
288 #define X86_LAST_BRANCH_STATE_COUNT x86_LAST_BRANCH_STATE_COUNT
289
290
291 /*
292 * Combined thread, float and exception states
293 */
294 struct x86_thread_state {
295 x86_state_hdr_t tsh;
296 union {
297 x86_thread_state32_t ts32;
298 x86_thread_state64_t ts64;
299 } uts;
300 };
301
302 struct x86_float_state {
303 x86_state_hdr_t fsh;
304 union {
305 x86_float_state32_t fs32;
306 x86_float_state64_t fs64;
307 } ufs;
308 };
309
310 struct x86_exception_state {
311 x86_state_hdr_t esh;
312 union {
313 x86_exception_state32_t es32;
314 x86_exception_state64_t es64;
315 } ues;
316 };
317
318 struct x86_debug_state {
319 x86_state_hdr_t dsh;
320 union {
321 x86_debug_state32_t ds32;
322 x86_debug_state64_t ds64;
323 } uds;
324 };
325
326 struct x86_avx_state {
327 x86_state_hdr_t ash;
328 union {
329 x86_avx_state32_t as32;
330 x86_avx_state64_t as64;
331 } ufs;
332 };
333
334 struct x86_avx512_state {
335 x86_state_hdr_t ash;
336 union {
337 x86_avx512_state32_t as32;
338 x86_avx512_state64_t as64;
339 } ufs;
340 };
341
342 typedef struct x86_thread_state x86_thread_state_t;
343 #define x86_THREAD_STATE_COUNT ((mach_msg_type_number_t) \
344 ( sizeof (x86_thread_state_t) / sizeof (int) ))
345
346 typedef struct x86_float_state x86_float_state_t;
347 #define x86_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \
348 (sizeof(x86_float_state_t)/sizeof(unsigned int)))
349
350 typedef struct x86_exception_state x86_exception_state_t;
351 #define x86_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \
352 (sizeof(x86_exception_state_t)/sizeof(unsigned int)))
353
354 typedef struct x86_debug_state x86_debug_state_t;
355 #define x86_DEBUG_STATE_COUNT ((mach_msg_type_number_t) \
356 (sizeof(x86_debug_state_t)/sizeof(unsigned int)))
357
358 typedef struct x86_avx_state x86_avx_state_t;
359 #define x86_AVX_STATE_COUNT ((mach_msg_type_number_t) \
360 (sizeof(x86_avx_state_t)/sizeof(unsigned int)))
361
362 typedef struct x86_avx512_state x86_avx512_state_t;
363 #define x86_AVX512_STATE_COUNT ((mach_msg_type_number_t) \
364 (sizeof(x86_avx512_state_t)/sizeof(unsigned int)))
365
366 /*
367 * Machine-independent way for servers and Mach's exception mechanism to
368 * choose the most efficient state flavor for exception RPC's:
369 */
370 #define MACHINE_THREAD_STATE x86_THREAD_STATE
371 #define MACHINE_THREAD_STATE_COUNT x86_THREAD_STATE_COUNT
372
373 #ifdef XNU_KERNEL_PRIVATE
374
375 #define x86_SAVED_STATE32 THREAD_STATE_NONE + 1
376 #define x86_SAVED_STATE64 THREAD_STATE_NONE + 2
377
378 /*
379 * The format in which thread state is saved by Mach on this machine. This
380 * state flavor is most efficient for exception RPC's to kernel-loaded
381 * servers, because copying can be avoided:
382 */
383 struct x86_saved_state32 {
384 uint32_t gs;
385 uint32_t fs;
386 uint32_t es;
387 uint32_t ds;
388 uint32_t edi;
389 uint32_t esi;
390 uint32_t ebp;
391 uint32_t cr2; /* kernel esp stored by pusha - we save cr2 here later */
392 uint32_t ebx;
393 uint32_t edx;
394 uint32_t ecx;
395 uint32_t eax;
396 uint16_t trapno;
397 uint16_t cpu;
398 uint32_t err;
399 uint32_t eip;
400 uint32_t cs;
401 uint32_t efl;
402 uint32_t uesp;
403 uint32_t ss;
404 };
405 typedef struct x86_saved_state32 x86_saved_state32_t;
406
407 #define x86_SAVED_STATE32_COUNT ((mach_msg_type_number_t) \
408 (sizeof (x86_saved_state32_t)/sizeof(unsigned int)))
409
410 #pragma pack(4)
411
412 /*
413 * This is the state pushed onto the 64-bit interrupt stack
414 * on any exception/trap/interrupt.
415 */
416 struct x86_64_intr_stack_frame {
417 uint16_t trapno;
418 uint16_t cpu;
419 uint32_t _pad;
420 uint64_t trapfn;
421 uint64_t err;
422 uint64_t rip;
423 uint64_t cs;
424 uint64_t rflags;
425 uint64_t rsp;
426 uint64_t ss;
427 };
428 typedef struct x86_64_intr_stack_frame x86_64_intr_stack_frame_t;
429 _Static_assert((sizeof(x86_64_intr_stack_frame_t) % 16) == 0,
430 "interrupt stack frame size must be a multiple of 16 bytes");
431
432 /*
433 * thread state format for task running in 64bit long mode
434 * in long mode, the same hardware frame is always pushed regardless
435 * of whether there was a change in privilege level... therefore, there
436 * is no need for an x86_saved_state64_from_kernel variant
437 */
438 struct x86_saved_state64 {
439 uint64_t rdi; /* arg0 for system call */
440 uint64_t rsi;
441 uint64_t rdx;
442 uint64_t r10; /* R10 := RCX prior to syscall trap */
443 uint64_t r8;
444 uint64_t r9; /* arg5 for system call */
445
446 uint64_t cr2;
447 uint64_t r15;
448 uint64_t r14;
449 uint64_t r13;
450 uint64_t r12;
451 uint64_t r11;
452 uint64_t rbp;
453 uint64_t rbx;
454 uint64_t rcx;
455 uint64_t rax;
456
457 uint32_t gs;
458 uint32_t fs;
459
460 uint32_t ds;
461 uint32_t es;
462
463 struct x86_64_intr_stack_frame isf;
464 };
465 typedef struct x86_saved_state64 x86_saved_state64_t;
466 #define x86_SAVED_STATE64_COUNT ((mach_msg_type_number_t) \
467 (sizeof (struct x86_saved_state64)/sizeof(unsigned int)))
468
469 extern uint32_t get_eflags_exportmask(void);
470
471 /*
472 * Unified, tagged saved state:
473 */
474 typedef struct {
475 uint32_t flavor;
476 uint32_t _pad_for_16byte_alignment[3];
477 union {
478 x86_saved_state32_t ss_32;
479 x86_saved_state64_t ss_64;
480 } uss;
481 } x86_saved_state_t;
482 #define ss_32 uss.ss_32
483 #define ss_64 uss.ss_64
484 #pragma pack()
485
486 static inline boolean_t
is_saved_state64(x86_saved_state_t * iss)487 is_saved_state64(x86_saved_state_t *iss)
488 {
489 return iss->flavor == x86_SAVED_STATE64;
490 }
491
492 static inline boolean_t
is_saved_state32(x86_saved_state_t * iss)493 is_saved_state32(x86_saved_state_t *iss)
494 {
495 return iss->flavor == x86_SAVED_STATE32;
496 }
497
498 static inline x86_saved_state32_t *
saved_state32(x86_saved_state_t * iss)499 saved_state32(x86_saved_state_t *iss)
500 {
501 return &iss->ss_32;
502 }
503
504 static inline x86_saved_state64_t *
saved_state64(x86_saved_state_t * iss)505 saved_state64(x86_saved_state_t *iss)
506 {
507 return &iss->ss_64;
508 }
509
510 #endif /* XNU_KERNEL_PRIVATE */
511
512 #endif /* defined (__i386__) || defined (__x86_64__) */
513
514 #endif /* _MACH_I386_THREAD_STATUS_H_ */
515