arch/x86/kernel/fpu/xstate.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __X86_KERNEL_FPU_XSTATE_H
   3 #define __X86_KERNEL_FPU_XSTATE_H
   4
   5 #include <asm/cpufeature.h>
   6 #include <asm/fpu/xstate.h>
   7 #include <asm/fpu/xcr.h>
   8
   9 #ifdef CONFIG_X86_64
  10 DECLARE_PER_CPU(u64, xfd_state);
  11 #endif
  12
  13 static inline void xstate_init_xcomp_bv(struct xregs_state *xsave, u64 mask)
  14 {
  15         /*
  16          * XRSTORS requires these bits set in xcomp_bv, or it will
  17          * trigger #GP:
  18          */
  19         if (cpu_feature_enabled(X86_FEATURE_XSAVES))
  20                 xsave->header.xcomp_bv = mask | XCOMP_BV_COMPACTED_FORMAT;
  21 }
  22
  23 static inline u64 xstate_get_group_perm(bool guest)
  24 {
  25         struct fpu *fpu = &current->group_leader->thread.fpu;
  26         struct fpu_state_perm *perm;
  27
  28         /* Pairs with WRITE_ONCE() in xstate_request_perm() */
  29         perm = guest ? &fpu->guest_perm : &fpu->perm;
  30         return READ_ONCE(perm->__state_perm);
  31 }
  32
  33 static inline u64 xstate_get_host_group_perm(void)
  34 {
  35         return xstate_get_group_perm(false);
  36 }
  37
  38 enum xstate_copy_mode {
  39         XSTATE_COPY_FP,
  40         XSTATE_COPY_FX,
  41         XSTATE_COPY_XSAVE,
  42 };
  43
  44 struct membuf;
  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);
  51
  52
  53 extern void fpu__init_cpu_xstate(void);
  54 extern void fpu__init_system_xstate(unsigned int legacy_size);
  55
  56 extern void *get_xsave_addr(struct xregs_state *xsave, int xfeature_nr);
  57
  58 static inline u64 xfeatures_mask_supervisor(void)
  59 {
  60         return fpu_kernel_cfg.max_features & XFEATURE_MASK_SUPERVISOR_SUPPORTED;
  61 }
  62
  63 static inline u64 xfeatures_mask_independent(void)
  64 {
  65         if (!cpu_feature_enabled(X86_FEATURE_ARCH_LBR))
  66                 return XFEATURE_MASK_INDEPENDENT & ~XFEATURE_MASK_LBR;
  67
  68         return XFEATURE_MASK_INDEPENDENT;
  69 }
  70
  71 /* XSAVE/XRSTOR wrapper functions */
  72
  73 #ifdef CONFIG_X86_64
  74 #define REX_PREFIX      "0x48, "
  75 #else
  76 #define REX_PREFIX
  77 #endif
  78
  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"
  85
  86 /*
  87  * After this @err contains 0 on success or the trap number when the
  88  * operation raises an exception.
  89  */
  90 #define XSTATE_OP(op, st, lmask, hmask, err)                            \
  91         asm volatile("1:" op "\n\t"                                     \
  92                      "xor %[err], %[err]\n"                             \
  93                      "2:\n\t"                                           \
  94                      _ASM_EXTABLE_TYPE(1b, 2b, EX_TYPE_FAULT_MCE_SAFE)  \
  95                      : [err] "=a" (err)                                 \
  96                      : "D" (st), "m" (*st), "a" (lmask), "d" (hmask)    \
  97                      : "memory")
  98
  99 /*
 100  * If XSAVES is enabled, it replaces XSAVEOPT because it supports a compact
 101  * format and supervisor states in addition to modified optimization in
 102  * XSAVEOPT.
 103  *
 104  * Otherwise, if XSAVEOPT is enabled, XSAVEOPT replaces XSAVE because XSAVEOPT
 105  * supports modified optimization which is not supported by XSAVE.
 106  *
 107  * We use XSAVE as a fallback.
 108  *
 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.
 112  */
 113 #define XSTATE_XSAVE(st, lmask, hmask, err)                             \
 114         asm volatile(ALTERNATIVE_2(XSAVE,                               \
 115                                    XSAVEOPT, X86_FEATURE_XSAVEOPT,      \
 116                                    XSAVES,   X86_FEATURE_XSAVES)        \
 117                      "\n"                                               \
 118                      "xor %[err], %[err]\n"                             \
 119                      "3:\n"                                             \
 120                      _ASM_EXTABLE_TYPE_REG(661b, 3b, EX_TYPE_EFAULT_REG, %[err]) \
 121                      : [err] "=r" (err)                                 \
 122                      : "D" (st), "m" (*st), "a" (lmask), "d" (hmask)    \
 123                      : "memory")
 124
 125 /*
 126  * Use XRSTORS to restore context if it is enabled. XRSTORS supports compact
 127  * XSAVE area format.
 128  */
 129 #define XSTATE_XRESTORE(st, lmask, hmask)                               \
 130         asm volatile(ALTERNATIVE(XRSTOR,                                \
 131                                  XRSTORS, X86_FEATURE_XSAVES)           \
 132                      "\n"                                               \
 133                      "3:\n"                                             \
 134                      _ASM_EXTABLE_TYPE(661b, 3b, EX_TYPE_FPU_RESTORE)   \
 135                      :                                                  \
 136                      : "D" (st), "m" (*st), "a" (lmask), "d" (hmask)    \
 137                      : "memory")
 138
 139 #if defined(CONFIG_X86_64) && defined(CONFIG_X86_DEBUG_FPU)
 140 extern void xfd_validate_state(struct fpstate *fpstate, u64 mask, bool rstor);
 141 #else
 142 static inline void xfd_validate_state(struct fpstate *fpstate, u64 mask, bool rstor) { }
 143 #endif
 144
 145 #ifdef CONFIG_X86_64
 146 static inline void xfd_update_state(struct fpstate *fpstate)
 147 {
 148         if (fpu_state_size_dynamic()) {
 149                 u64 xfd = fpstate->xfd;
 150
 151                 if (__this_cpu_read(xfd_state) != xfd) {
 152                         wrmsrl(MSR_IA32_XFD, xfd);
 153                         __this_cpu_write(xfd_state, xfd);
 154                 }
 155         }
 156 }
 157
 158 extern int __xfd_enable_feature(u64 which, struct fpu_guest *guest_fpu);
 159 #else
 160 static inline void xfd_update_state(struct fpstate *fpstate) { }
 161
 162 static inline int __xfd_enable_feature(u64 which, struct fpu_guest *guest_fpu) {
 163         return -EPERM;
 164 }
 165 #endif
 166
 167 /*
 168  * Save processor xstate to xsave area.
 169  *
 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.
 172  */
 173 static inline void os_xsave(struct fpstate *fpstate)
 174 {
 175         u64 mask = fpstate->xfeatures;
 176         u32 lmask = mask;
 177         u32 hmask = mask >> 32;
 178         int err;
 179
 180         WARN_ON_FPU(!alternatives_patched);
 181         xfd_validate_state(fpstate, mask, false);
 182
 183         XSTATE_XSAVE(&fpstate->regs.xsave, lmask, hmask, err);
 184
 185         /* We should never fault when copying to a kernel buffer: */
 186         WARN_ON_FPU(err);
 187 }
 188
 189 /*
 190  * Restore processor xstate from xsave area.
 191  *
 192  * Uses XRSTORS when XSAVES is used, XRSTOR otherwise.
 193  */
 194 static inline void os_xrstor(struct fpstate *fpstate, u64 mask)
 195 {
 196         u32 lmask = mask;
 197         u32 hmask = mask >> 32;
 198
 199         xfd_validate_state(fpstate, mask, true);
 200         XSTATE_XRESTORE(&fpstate->regs.xsave, lmask, hmask);
 201 }
 202
 203 /* Restore of supervisor state. Does not require XFD */
 204 static inline void os_xrstor_supervisor(struct fpstate *fpstate)
 205 {
 206         u64 mask = xfeatures_mask_supervisor();
 207         u32 lmask = mask;
 208         u32 hmask = mask >> 32;
 209
 210         XSTATE_XRESTORE(&fpstate->regs.xsave, lmask, hmask);
 211 }
 212
 213 /*
 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.
 218  *
 219  * This optimization is user-visible.  Only use for states where
 220  * uninitialized sigframe contents are tolerable, like dynamic features.
 221  *
 222  * Users of buffers produced with this optimization must check XSTATE_BV
 223  * to determine which features have been optimized out.
 224  */
 225 static inline u64 xfeatures_need_sigframe_write(void)
 226 {
 227         u64 xfeaures_to_write;
 228
 229         /* In-use features must be written: */
 230         xfeaures_to_write = xfeatures_in_use();
 231
 232         /* Also write all non-optimizable sigframe features: */
 233         xfeaures_to_write |= XFEATURE_MASK_USER_SUPPORTED &
 234                              ~XFEATURE_MASK_SIGFRAME_INITOPT;
 235
 236         return xfeaures_to_write;
 237 }
 238
 239 /*
 240  * Save xstate to user space xsave area.
 241  *
 242  * We don't use modified optimization because xrstor/xrstors might track
 243  * a different application.
 244  *
 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
 247  * xsave area.
 248  *
 249  * The caller has to zero buf::header before calling this because XSAVE*
 250  * does not touch the reserved fields in the header.
 251  */
 252 static inline int xsave_to_user_sigframe(struct xregs_state __user *buf)
 253 {
 254         /*
 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.
 258          */
 259         struct fpstate *fpstate = current->thread.fpu.fpstate;
 260         u64 mask = fpstate->user_xfeatures;
 261         u32 lmask;
 262         u32 hmask;
 263         int err;
 264
 265         /* Optimize away writing unnecessary xfeatures: */
 266         if (fpu_state_size_dynamic())
 267                 mask &= xfeatures_need_sigframe_write();
 268
 269         lmask = mask;
 270         hmask = mask >> 32;
 271         xfd_validate_state(fpstate, mask, false);
 272
 273         stac();
 274         XSTATE_OP(XSAVE, buf, lmask, hmask, err);
 275         clac();
 276
 277         return err;
 278 }
 279
 280 /*
 281  * Restore xstate from user space xsave area.
 282  */
 283 static inline int xrstor_from_user_sigframe(struct xregs_state __user *buf, u64 mask)
 284 {
 285         struct xregs_state *xstate = ((__force struct xregs_state *)buf);
 286         u32 lmask = mask;
 287         u32 hmask = mask >> 32;
 288         int err;
 289
 290         xfd_validate_state(current->thread.fpu.fpstate, mask, true);
 291
 292         stac();
 293         XSTATE_OP(XRSTOR, xstate, lmask, hmask, err);
 294         clac();
 295
 296         return err;
 297 }
 298
 299 /*
 300  * Restore xstate from kernel space xsave area, return an error code instead of
 301  * an exception.
 302  */
 303 static inline int os_xrstor_safe(struct fpstate *fpstate, u64 mask)
 304 {
 305         struct xregs_state *xstate = &fpstate->regs.xsave;
 306         u32 lmask = mask;
 307         u32 hmask = mask >> 32;
 308         int err;
 309
 310         /* Ensure that XFD is up to date */
 311         xfd_update_state(fpstate);
 312
 313         if (cpu_feature_enabled(X86_FEATURE_XSAVES))
 314                 XSTATE_OP(XRSTORS, xstate, lmask, hmask, err);
 315         else
 316                 XSTATE_OP(XRSTOR, xstate, lmask, hmask, err);
 317
 318         return err;
 319 }
 320
 321
 322 #endif