1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __X86_KERNEL_FPU_XSTATE_H
3 #define __X86_KERNEL_FPU_XSTATE_H
5 #include <asm/cpufeature.h>
6 #include <asm/fpu/xstate.h>
7 #include <asm/fpu/xcr.h>
10 DECLARE_PER_CPU(u64, xfd_state);
13 static inline void xstate_init_xcomp_bv(struct xregs_state *xsave, u64 mask)
16 * XRSTORS requires these bits set in xcomp_bv, or it will
19 if (cpu_feature_enabled(X86_FEATURE_XSAVES))
20 xsave->header.xcomp_bv = mask | XCOMP_BV_COMPACTED_FORMAT;
23 static inline u64 xstate_get_group_perm(bool guest)
25 struct fpu *fpu = ¤t->group_leader->thread.fpu;
26 struct fpu_state_perm *perm;
28 /* Pairs with WRITE_ONCE() in xstate_request_perm() */
29 perm = guest ? &fpu->guest_perm : &fpu->perm;
30 return READ_ONCE(perm->__state_perm);
33 static inline u64 xstate_get_host_group_perm(void)
35 return xstate_get_group_perm(false);
38 enum xstate_copy_mode {
45 extern void __copy_xstate_to_uabi_buf(struct membuf to, struct fpstate *fpstate,
46 u32 pkru_val, enum xstate_copy_mode copy_mode);
47 extern void copy_xstate_to_uabi_buf(struct membuf to, struct task_struct *tsk,
48 enum xstate_copy_mode mode);
49 extern int copy_uabi_from_kernel_to_xstate(struct fpstate *fpstate, const void *kbuf);
50 extern int copy_sigframe_from_user_to_xstate(struct fpstate *fpstate, const void __user *ubuf);
53 extern void fpu__init_cpu_xstate(void);
54 extern void fpu__init_system_xstate(unsigned int legacy_size);
56 extern void *get_xsave_addr(struct xregs_state *xsave, int xfeature_nr);
58 static inline u64 xfeatures_mask_supervisor(void)
60 return fpu_kernel_cfg.max_features & XFEATURE_MASK_SUPERVISOR_SUPPORTED;
63 static inline u64 xfeatures_mask_independent(void)
65 if (!cpu_feature_enabled(X86_FEATURE_ARCH_LBR))
66 return XFEATURE_MASK_INDEPENDENT & ~XFEATURE_MASK_LBR;
68 return XFEATURE_MASK_INDEPENDENT;
71 /* XSAVE/XRSTOR wrapper functions */
74 #define REX_PREFIX "0x48, "
79 /* These macros all use (%edi)/(%rdi) as the single memory argument. */
80 #define XSAVE ".byte " REX_PREFIX "0x0f,0xae,0x27"
81 #define XSAVEOPT ".byte " REX_PREFIX "0x0f,0xae,0x37"
82 #define XSAVES ".byte " REX_PREFIX "0x0f,0xc7,0x2f"
83 #define XRSTOR ".byte " REX_PREFIX "0x0f,0xae,0x2f"
84 #define XRSTORS ".byte " REX_PREFIX "0x0f,0xc7,0x1f"
87 * After this @err contains 0 on success or the trap number when the
88 * operation raises an exception.
90 #define XSTATE_OP(op, st, lmask, hmask, err) \
91 asm volatile("1:" op "\n\t" \
92 "xor %[err], %[err]\n" \
94 _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_FAULT_MCE_SAFE) \
96 : "D" (st), "m" (*st), "a" (lmask), "d" (hmask) \
100 * If XSAVES is enabled, it replaces XSAVEOPT because it supports a compact
101 * format and supervisor states in addition to modified optimization in
104 * Otherwise, if XSAVEOPT is enabled, XSAVEOPT replaces XSAVE because XSAVEOPT
105 * supports modified optimization which is not supported by XSAVE.
107 * We use XSAVE as a fallback.
109 * The 661 label is defined in the ALTERNATIVE* macros as the address of the
110 * original instruction which gets replaced. We need to use it here as the
111 * address of the instruction where we might get an exception at.
113 #define XSTATE_XSAVE(st, lmask, hmask, err) \
114 asm volatile(ALTERNATIVE_2(XSAVE, \
115 XSAVEOPT, X86_FEATURE_XSAVEOPT, \
116 XSAVES, X86_FEATURE_XSAVES) \
118 "xor %[err], %[err]\n" \
120 _ASM_EXTABLE_TYPE_REG(661b, 3b, EX_TYPE_EFAULT_REG, %[err]) \
122 : "D" (st), "m" (*st), "a" (lmask), "d" (hmask) \
126 * Use XRSTORS to restore context if it is enabled. XRSTORS supports compact
129 #define XSTATE_XRESTORE(st, lmask, hmask) \
130 asm volatile(ALTERNATIVE(XRSTOR, \
131 XRSTORS, X86_FEATURE_XSAVES) \
134 _ASM_EXTABLE_TYPE(661b, 3b, EX_TYPE_FPU_RESTORE) \
136 : "D" (st), "m" (*st), "a" (lmask), "d" (hmask) \
139 #if defined(CONFIG_X86_64) && defined(CONFIG_X86_DEBUG_FPU)
140 extern void xfd_validate_state(struct fpstate *fpstate, u64 mask, bool rstor);
142 static inline void xfd_validate_state(struct fpstate *fpstate, u64 mask, bool rstor) { }
146 static inline void xfd_update_state(struct fpstate *fpstate)
148 if (fpu_state_size_dynamic()) {
149 u64 xfd = fpstate->xfd;
151 if (__this_cpu_read(xfd_state) != xfd) {
152 wrmsrl(MSR_IA32_XFD, xfd);
153 __this_cpu_write(xfd_state, xfd);
158 extern int __xfd_enable_feature(u64 which, struct fpu_guest *guest_fpu);
160 static inline void xfd_update_state(struct fpstate *fpstate) { }
162 static inline int __xfd_enable_feature(u64 which, struct fpu_guest *guest_fpu) {
168 * Save processor xstate to xsave area.
170 * Uses either XSAVE or XSAVEOPT or XSAVES depending on the CPU features
171 * and command line options. The choice is permanent until the next reboot.
173 static inline void os_xsave(struct fpstate *fpstate)
175 u64 mask = fpstate->xfeatures;
177 u32 hmask = mask >> 32;
180 WARN_ON_FPU(!alternatives_patched);
181 xfd_validate_state(fpstate, mask, false);
183 XSTATE_XSAVE(&fpstate->regs.xsave, lmask, hmask, err);
185 /* We should never fault when copying to a kernel buffer: */
190 * Restore processor xstate from xsave area.
192 * Uses XRSTORS when XSAVES is used, XRSTOR otherwise.
194 static inline void os_xrstor(struct fpstate *fpstate, u64 mask)
197 u32 hmask = mask >> 32;
199 xfd_validate_state(fpstate, mask, true);
200 XSTATE_XRESTORE(&fpstate->regs.xsave, lmask, hmask);
203 /* Restore of supervisor state. Does not require XFD */
204 static inline void os_xrstor_supervisor(struct fpstate *fpstate)
206 u64 mask = xfeatures_mask_supervisor();
208 u32 hmask = mask >> 32;
210 XSTATE_XRESTORE(&fpstate->regs.xsave, lmask, hmask);
214 * XSAVE itself always writes all requested xfeatures. Removing features
215 * from the request bitmap reduces the features which are written.
216 * Generate a mask of features which must be written to a sigframe. The
217 * unset features can be optimized away and not written.
219 * This optimization is user-visible. Only use for states where
220 * uninitialized sigframe contents are tolerable, like dynamic features.
222 * Users of buffers produced with this optimization must check XSTATE_BV
223 * to determine which features have been optimized out.
225 static inline u64 xfeatures_need_sigframe_write(void)
227 u64 xfeaures_to_write;
229 /* In-use features must be written: */
230 xfeaures_to_write = xfeatures_in_use();
232 /* Also write all non-optimizable sigframe features: */
233 xfeaures_to_write |= XFEATURE_MASK_USER_SUPPORTED &
234 ~XFEATURE_MASK_SIGFRAME_INITOPT;
236 return xfeaures_to_write;
240 * Save xstate to user space xsave area.
242 * We don't use modified optimization because xrstor/xrstors might track
243 * a different application.
245 * We don't use compacted format xsave area for backward compatibility for
246 * old applications which don't understand the compacted format of the
249 * The caller has to zero buf::header before calling this because XSAVE*
250 * does not touch the reserved fields in the header.
252 static inline int xsave_to_user_sigframe(struct xregs_state __user *buf)
255 * Include the features which are not xsaved/rstored by the kernel
256 * internally, e.g. PKRU. That's user space ABI and also required
257 * to allow the signal handler to modify PKRU.
259 struct fpstate *fpstate = current->thread.fpu.fpstate;
260 u64 mask = fpstate->user_xfeatures;
265 /* Optimize away writing unnecessary xfeatures: */
266 if (fpu_state_size_dynamic())
267 mask &= xfeatures_need_sigframe_write();
271 xfd_validate_state(fpstate, mask, false);
274 XSTATE_OP(XSAVE, buf, lmask, hmask, err);
281 * Restore xstate from user space xsave area.
283 static inline int xrstor_from_user_sigframe(struct xregs_state __user *buf, u64 mask)
285 struct xregs_state *xstate = ((__force struct xregs_state *)buf);
287 u32 hmask = mask >> 32;
290 xfd_validate_state(current->thread.fpu.fpstate, mask, true);
293 XSTATE_OP(XRSTOR, xstate, lmask, hmask, err);
300 * Restore xstate from kernel space xsave area, return an error code instead of
303 static inline int os_xrstor_safe(struct fpstate *fpstate, u64 mask)
305 struct xregs_state *xstate = &fpstate->regs.xsave;
307 u32 hmask = mask >> 32;
310 /* Ensure that XFD is up to date */
311 xfd_update_state(fpstate);
313 if (cpu_feature_enabled(X86_FEATURE_XSAVES))
314 XSTATE_OP(XRSTORS, xstate, lmask, hmask, err);
316 XSTATE_OP(XRSTOR, xstate, lmask, hmask, err);