cac80d6702b75ee99cbfda4e43b7cbb9b98ef757
[akaros.git] / kern / arch / x86 / ros / trapframe.h
1 #pragma once
2
3 #define ROS_INC_ARCH_TRAPFRAME_H
4
5 #ifndef ROS_INC_TRAPFRAME_H
6 #error "Do not include include ros/arch/trapframe.h directly"
7 #endif
8
9 #include <ros/common.h>
10
11 #define ROS_ARCH_REFL_ID 0x1234
12
13 /* Page faults return the nature of the fault in the bits of the error code: */
14 #define PF_ERROR_PRESENT                0x01
15 #define PF_ERROR_WRITE                  0x02
16 #define PF_ERROR_USER                   0x04
17 #define PF_VMR_BACKED                   (1 << 31)
18
19 #include <ros/arch/trapframe64.h>
20
21 /* FP state and whatever else the kernel won't muck with automatically.  For
22  * now, it's the Non-64-bit-mode layout of FP and XMM registers, as used by
23  * FXSAVE and FXRSTOR.  Other modes will require a union on a couple entries.
24  * See SDM 2a 3-451. */
25 /* Header for the non-64-bit mode FXSAVE map */
26 struct fp_header_non_64bit {
27         uint16_t                fcw;
28         uint16_t                fsw;
29         uint8_t                 ftw;
30         uint8_t                 padding0;
31         uint16_t                fop;
32         uint32_t                fpu_ip;
33         uint16_t                cs;
34         uint16_t                padding1;
35         uint32_t                fpu_dp;
36         uint16_t                ds;
37         uint16_t                padding2;
38         uint32_t                mxcsr;
39         uint32_t                mxcsr_mask;
40 };
41
42 /* Header for the 64-bit mode FXSAVE map with promoted operand size */
43 struct fp_header_64bit_promoted {
44         uint16_t                fcw;
45         uint16_t                fsw;
46         uint8_t                 ftw;
47         uint8_t                 padding0;
48         uint16_t                fop;
49         uint64_t                fpu_ip;
50         uint64_t                fpu_dp;
51         uint32_t                mxcsr;
52         uint32_t                mxcsr_mask;
53 };
54
55 /* Header for the 64-bit mode FXSAVE map with default operand size */
56 struct fp_header_64bit_default {
57         uint16_t                fcw;
58         uint16_t                fsw;
59         uint8_t                 ftw;
60         uint8_t                 padding0;
61         uint16_t                fop;
62         uint32_t                fpu_ip;
63         uint16_t                cs;
64         uint16_t                padding1;
65         uint32_t                fpu_dp;
66         uint16_t                ds;
67         uint16_t                padding2;
68         uint32_t                mxcsr;
69         uint32_t                mxcsr_mask;
70 };
71
72 /* Just for storage space, not for real use     */
73 typedef struct {
74         unsigned int stor[4];
75 } __128bits;
76
77 /*
78  *  X86_MAX_XCR0 specifies the maximum set of processor extended state
79  *  feature components that Akaros supports saving through the
80  *  XSAVE instructions.
81  *  This may be a superset of available state components on a given
82  *  processor. We CPUID at boot and determine the intersection
83  *  of Akaros-supported and processor-supported features, and we
84  *  save this value to __proc_global_info.x86_default_xcr0 in arch/x86/init.c.
85  *  We guarantee that the set of feature components specified by
86  *  X86_MAX_XCR0 will fit in the ancillary_state struct.
87  *  If you add to the mask, make sure you also extend ancillary_state!
88  */
89
90 #define X86_MAX_XCR0 0x2ff
91
92 typedef struct ancillary_state {
93         /* Legacy region of the XSAVE area */
94         union { /* whichever header used depends on the mode */
95                 struct fp_header_non_64bit                      fp_head_n64;
96                 struct fp_header_64bit_promoted         fp_head_64p;
97                 struct fp_header_64bit_default          fp_head_64d;
98         };
99         /* offset 32 bytes */
100         __128bits               st0_mm0;        /* 128 bits: 80 for the st0, 48 reserved */
101         __128bits               st1_mm1;
102         __128bits               st2_mm2;
103         __128bits               st3_mm3;
104         __128bits               st4_mm4;
105         __128bits               st5_mm5;
106         __128bits               st6_mm6;
107         __128bits               st7_mm7;
108         /* offset 160 bytes */
109         __128bits               xmm0;
110         __128bits               xmm1;
111         __128bits               xmm2;
112         __128bits               xmm3;
113         __128bits               xmm4;
114         __128bits               xmm5;
115         __128bits               xmm6;
116         __128bits               xmm7;
117         /* xmm8-xmm15 are only available in 64-bit-mode */
118         __128bits               xmm8;
119         __128bits               xmm9;
120         __128bits               xmm10;
121         __128bits               xmm11;
122         __128bits               xmm12;
123         __128bits               xmm13;
124         __128bits               xmm14;
125         __128bits               xmm15;
126         /* offset 416 bytes */
127         __128bits               reserv0;
128         __128bits               reserv1;
129         __128bits               reserv2;
130         __128bits               reserv3;
131         __128bits               reserv4;
132         __128bits               reserv5;
133         /* offset 512 bytes */
134
135         /*
136          * XSAVE header (64 bytes, starting at offset 512 from
137          * the XSAVE area's base address)
138          */
139
140         // xstate_bv identifies the state components in the XSAVE area
141         uint64_t                xstate_bv;
142         /*
143          *      xcomp_bv[bit 63] is 1 if the compacted format is used, else 0.
144          *      All bits in xcomp_bv should be 0 if the processor does not support the
145          *      compaction extensions to the XSAVE feature set.
146         */
147         uint64_t                xcomp_bv;
148         __128bits               reserv6;
149
150         /* offset 576 bytes */
151         /*
152          *      Extended region of the XSAVE area
153          *      We currently support an extended region of up to 2112 bytes,
154          *      for a total ancillary_state size of 2688 bytes.
155          *      This supports x86 state components up through the zmm31 register.
156          *      If you need more, please ask!
157          *      See the Intel Architecture Instruction Set Extensions Programming
158          *      Reference page 3-3 for detailed offsets in this region.
159         */
160         uint8_t                 extended_region[2120];
161
162         /* ancillary state  */
163 } __attribute__((aligned(64))) ancillary_state_t;