Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'x86-fpu-2025-07-29' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull x86 FPU updates from Ingo Molnar:
- Most of the changes are related to the implementation of CET
supervisor state support for guests, and its preparatory changes
(Chao Gao)
- Improve/fix the debug output for unexpected FPU exceptions (Dave
Hansen)
* tag 'x86-fpu-2025-07-29' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
x86/fpu: Delay instruction pointer fixup until after warning
x86/fpu/xstate: Add CET supervisor xfeature support as a guest-only feature
x86/fpu/xstate: Introduce "guest-only" supervisor xfeature set
x86/fpu: Remove xfd argument from __fpstate_reset()
x86/fpu: Initialize guest fpstate and FPU pseudo container from guest defaults
x86/fpu: Initialize guest FPU permissions from guest defaults
x86/fpu/xstate: Differentiate default features for host and guest FPUs
+124
-33
+43
-6
arch/x86/include/asm/fpu/types.h
+43
-6
arch/x86/include/asm/fpu/types.h
···
118
118
XFEATURE_PKRU,
119
119
XFEATURE_PASID,
120
120
XFEATURE_CET_USER,
121
-
XFEATURE_CET_KERNEL_UNUSED,
121
+
XFEATURE_CET_KERNEL,
122
122
XFEATURE_RSRVD_COMP_13,
123
123
XFEATURE_RSRVD_COMP_14,
124
124
XFEATURE_LBR,
···
142
142
#define XFEATURE_MASK_PKRU (1 << XFEATURE_PKRU)
143
143
#define XFEATURE_MASK_PASID (1 << XFEATURE_PASID)
144
144
#define XFEATURE_MASK_CET_USER (1 << XFEATURE_CET_USER)
145
-
#define XFEATURE_MASK_CET_KERNEL (1 << XFEATURE_CET_KERNEL_UNUSED)
145
+
#define XFEATURE_MASK_CET_KERNEL (1 << XFEATURE_CET_KERNEL)
146
146
#define XFEATURE_MASK_LBR (1 << XFEATURE_LBR)
147
147
#define XFEATURE_MASK_XTILE_CFG (1 << XFEATURE_XTILE_CFG)
148
148
#define XFEATURE_MASK_XTILE_DATA (1 << XFEATURE_XTILE_DATA)
···
267
267
/* user shadow stack pointer */
268
268
u64 user_ssp;
269
269
};
270
+
271
+
/*
272
+
* State component 12 is Control-flow Enforcement supervisor states.
273
+
* This state includes SSP pointers for privilege levels 0 through 2.
274
+
*/
275
+
struct cet_supervisor_state {
276
+
u64 pl0_ssp;
277
+
u64 pl1_ssp;
278
+
u64 pl2_ssp;
279
+
} __packed;
270
280
271
281
/*
272
282
* State component 15: Architectural LBR configuration state.
···
562
552
};
563
553
564
554
/*
555
+
* FPU state configuration data for fpu_guest.
556
+
* Initialized at boot time. Read only after init.
557
+
*/
558
+
struct vcpu_fpu_config {
559
+
/*
560
+
* @size:
561
+
*
562
+
* The default size of the register state buffer in guest FPUs.
563
+
* Includes all supported features except independent managed
564
+
* features and features which have to be requested by user space
565
+
* before usage.
566
+
*/
567
+
unsigned int size;
568
+
569
+
/*
570
+
* @features:
571
+
*
572
+
* The default supported features bitmap in guest FPUs. Does not
573
+
* include independent managed features and features which have to
574
+
* be requested by user space before usage.
575
+
*/
576
+
u64 features;
577
+
};
578
+
579
+
/*
565
580
* FPU state configuration data. Initialized at boot time. Read only after init.
566
581
*/
567
582
struct fpu_state_config {
···
602
567
* @default_size:
603
568
*
604
569
* The default size of the register state buffer. Includes all
605
-
* supported features except independent managed features and
606
-
* features which have to be requested by user space before usage.
570
+
* supported features except independent managed features,
571
+
* guest-only features and features which have to be requested by
572
+
* user space before usage.
607
573
*/
608
574
unsigned int default_size;
609
575
···
620
584
* @default_features:
621
585
*
622
586
* The default supported features bitmap. Does not include
623
-
* independent managed features and features which have to
624
-
* be requested by user space before usage.
587
+
* independent managed features, guest-only features and features
588
+
* which have to be requested by user space before usage.
625
589
*/
626
590
u64 default_features;
627
591
/*
···
642
606
643
607
/* FPU state configuration information */
644
608
extern struct fpu_state_config fpu_kernel_cfg, fpu_user_cfg;
609
+
extern struct vcpu_fpu_config guest_default_cfg;
645
610
646
611
#endif /* _ASM_X86_FPU_TYPES_H */
+6
-3
arch/x86/include/asm/fpu/xstate.h
+6
-3
arch/x86/include/asm/fpu/xstate.h
···
46
46
/* Features which are dynamically enabled for a process on request */
47
47
#define XFEATURE_MASK_USER_DYNAMIC XFEATURE_MASK_XTILE_DATA
48
48
49
+
/* Supervisor features which are enabled only in guest FPUs */
50
+
#define XFEATURE_MASK_GUEST_SUPERVISOR XFEATURE_MASK_CET_KERNEL
51
+
49
52
/* All currently supported supervisor features */
50
53
#define XFEATURE_MASK_SUPERVISOR_SUPPORTED (XFEATURE_MASK_PASID | \
51
-
XFEATURE_MASK_CET_USER)
54
+
XFEATURE_MASK_CET_USER | \
55
+
XFEATURE_MASK_GUEST_SUPERVISOR)
52
56
53
57
/*
54
58
* A supervisor state component may not always contain valuable information,
···
79
75
* Unsupported supervisor features. When a supervisor feature in this mask is
80
76
* supported in the future, move it to the supported supervisor feature mask.
81
77
*/
82
-
#define XFEATURE_MASK_SUPERVISOR_UNSUPPORTED (XFEATURE_MASK_PT | \
83
-
XFEATURE_MASK_CET_KERNEL)
78
+
#define XFEATURE_MASK_SUPERVISOR_UNSUPPORTED (XFEATURE_MASK_PT)
84
79
85
80
/* All supervisor states including supported and unsupported states. */
86
81
#define XFEATURE_MASK_SUPERVISOR_ALL (XFEATURE_MASK_SUPERVISOR_SUPPORTED | \
+39
-14
arch/x86/kernel/fpu/core.c
+39
-14
arch/x86/kernel/fpu/core.c
···
37
37
/* The FPU state configuration data for kernel and user space */
38
38
struct fpu_state_config fpu_kernel_cfg __ro_after_init;
39
39
struct fpu_state_config fpu_user_cfg __ro_after_init;
40
+
struct vcpu_fpu_config guest_default_cfg __ro_after_init;
40
41
41
42
/*
42
43
* Represents the initial FPU state. It's mostly (but not completely) zeroes,
···
218
217
}
219
218
220
219
#if IS_ENABLED(CONFIG_KVM)
221
-
static void __fpstate_reset(struct fpstate *fpstate, u64 xfd);
220
+
static void __fpstate_reset(struct fpstate *fpstate);
222
221
223
222
static void fpu_lock_guest_permissions(void)
224
223
{
···
243
242
struct fpstate *fpstate;
244
243
unsigned int size;
245
244
246
-
size = fpu_kernel_cfg.default_size + ALIGN(offsetof(struct fpstate, regs), 64);
245
+
size = guest_default_cfg.size + ALIGN(offsetof(struct fpstate, regs), 64);
246
+
247
247
fpstate = vzalloc(size);
248
248
if (!fpstate)
249
249
return false;
250
250
251
-
/* Leave xfd to 0 (the reset value defined by spec) */
252
-
__fpstate_reset(fpstate, 0);
253
-
fpstate_init_user(fpstate);
251
+
/* Initialize indicators to reflect properties of the fpstate */
254
252
fpstate->is_valloc = true;
255
253
fpstate->is_guest = true;
256
254
255
+
__fpstate_reset(fpstate);
256
+
fpstate_init_user(fpstate);
257
+
257
258
gfpu->fpstate = fpstate;
258
-
gfpu->xfeatures = fpu_kernel_cfg.default_features;
259
+
gfpu->xfeatures = guest_default_cfg.features;
259
260
260
261
/*
261
262
* KVM sets the FP+SSE bits in the XSAVE header when copying FPU state
···
544
541
fpstate_init_fstate(fpstate);
545
542
}
546
543
547
-
static void __fpstate_reset(struct fpstate *fpstate, u64 xfd)
544
+
static void __fpstate_reset(struct fpstate *fpstate)
548
545
{
549
-
/* Initialize sizes and feature masks */
550
-
fpstate->size = fpu_kernel_cfg.default_size;
546
+
/*
547
+
* Supervisor features (and thus sizes) may diverge between guest
548
+
* FPUs and host FPUs, as some supervisor features are supported
549
+
* for guests despite not being utilized by the host. User
550
+
* features and sizes are always identical, which allows for
551
+
* common guest and userspace ABI.
552
+
*
553
+
* For the host, set XFD to the kernel's desired initialization
554
+
* value. For guests, set XFD to its architectural RESET value.
555
+
*/
556
+
if (fpstate->is_guest) {
557
+
fpstate->size = guest_default_cfg.size;
558
+
fpstate->xfeatures = guest_default_cfg.features;
559
+
fpstate->xfd = 0;
560
+
} else {
561
+
fpstate->size = fpu_kernel_cfg.default_size;
562
+
fpstate->xfeatures = fpu_kernel_cfg.default_features;
563
+
fpstate->xfd = init_fpstate.xfd;
564
+
}
565
+
551
566
fpstate->user_size = fpu_user_cfg.default_size;
552
-
fpstate->xfeatures = fpu_kernel_cfg.default_features;
553
567
fpstate->user_xfeatures = fpu_user_cfg.default_features;
554
-
fpstate->xfd = xfd;
555
568
}
556
569
557
570
void fpstate_reset(struct fpu *fpu)
558
571
{
559
572
/* Set the fpstate pointer to the default fpstate */
560
573
fpu->fpstate = &fpu->__fpstate;
561
-
__fpstate_reset(fpu->fpstate, init_fpstate.xfd);
574
+
__fpstate_reset(fpu->fpstate);
562
575
563
576
/* Initialize the permission related info in fpu */
564
577
fpu->perm.__state_perm = fpu_kernel_cfg.default_features;
565
578
fpu->perm.__state_size = fpu_kernel_cfg.default_size;
566
579
fpu->perm.__user_state_size = fpu_user_cfg.default_size;
567
-
/* Same defaults for guests */
568
-
fpu->guest_perm = fpu->perm;
580
+
581
+
fpu->guest_perm.__state_perm = guest_default_cfg.features;
582
+
fpu->guest_perm.__state_size = guest_default_cfg.size;
583
+
/*
584
+
* User features and sizes are always identical between host and
585
+
* guest FPUs, which allows for common guest and userspace ABI.
586
+
*/
587
+
fpu->guest_perm.__user_state_size = fpu_user_cfg.default_size;
569
588
}
570
589
571
590
static inline void fpu_inherit_perms(struct fpu *dst_fpu)
+1
arch/x86/kernel/fpu/init.c
+1
arch/x86/kernel/fpu/init.c
+33
-7
arch/x86/kernel/fpu/xstate.c
+33
-7
arch/x86/kernel/fpu/xstate.c
···
57
57
"Protection Keys User registers",
58
58
"PASID state",
59
59
"Control-flow User registers",
60
-
"Control-flow Kernel registers (unused)",
60
+
"Control-flow Kernel registers (KVM only)",
61
61
"unknown xstate feature",
62
62
"unknown xstate feature",
63
63
"unknown xstate feature",
···
81
81
[XFEATURE_PKRU] = X86_FEATURE_OSPKE,
82
82
[XFEATURE_PASID] = X86_FEATURE_ENQCMD,
83
83
[XFEATURE_CET_USER] = X86_FEATURE_SHSTK,
84
+
[XFEATURE_CET_KERNEL] = X86_FEATURE_SHSTK,
84
85
[XFEATURE_XTILE_CFG] = X86_FEATURE_AMX_TILE,
85
86
[XFEATURE_XTILE_DATA] = X86_FEATURE_AMX_TILE,
86
87
[XFEATURE_APX] = X86_FEATURE_APX,
···
373
372
XFEATURE_MASK_BNDCSR | \
374
373
XFEATURE_MASK_PASID | \
375
374
XFEATURE_MASK_CET_USER | \
375
+
XFEATURE_MASK_CET_KERNEL | \
376
376
XFEATURE_MASK_XTILE | \
377
377
XFEATURE_MASK_APX)
378
378
···
575
573
case XFEATURE_PASID: return XCHECK_SZ(sz, nr, struct ia32_pasid_state);
576
574
case XFEATURE_XTILE_CFG: return XCHECK_SZ(sz, nr, struct xtile_cfg);
577
575
case XFEATURE_CET_USER: return XCHECK_SZ(sz, nr, struct cet_user_state);
576
+
case XFEATURE_CET_KERNEL: return XCHECK_SZ(sz, nr, struct cet_supervisor_state);
578
577
case XFEATURE_APX: return XCHECK_SZ(sz, nr, struct apx_state);
579
578
case XFEATURE_XTILE_DATA: check_xtile_data_against_struct(sz); return true;
580
579
default:
···
746
743
fpu_user_cfg.default_size =
747
744
xstate_calculate_size(fpu_user_cfg.default_features, false);
748
745
746
+
guest_default_cfg.size =
747
+
xstate_calculate_size(guest_default_cfg.features, compacted);
748
+
749
749
return 0;
750
750
}
751
751
···
769
763
fpu_kernel_cfg.default_size = legacy_size;
770
764
fpu_user_cfg.max_size = legacy_size;
771
765
fpu_user_cfg.default_size = legacy_size;
766
+
guest_default_cfg.size = legacy_size;
772
767
773
768
/*
774
769
* Prevent enabling the static branch which enables writes to the
···
778
771
init_fpstate.xfd = 0;
779
772
780
773
fpstate_reset(x86_task_fpu(current));
774
+
}
775
+
776
+
static u64 __init host_default_mask(void)
777
+
{
778
+
/*
779
+
* Exclude dynamic features (require userspace opt-in) and features
780
+
* that are supported only for KVM guests.
781
+
*/
782
+
return ~((u64)XFEATURE_MASK_USER_DYNAMIC | XFEATURE_MASK_GUEST_SUPERVISOR);
783
+
}
784
+
785
+
static u64 __init guest_default_mask(void)
786
+
{
787
+
/*
788
+
* Exclude dynamic features, which require userspace opt-in even
789
+
* for KVM guests.
790
+
*/
791
+
return ~(u64)XFEATURE_MASK_USER_DYNAMIC;
781
792
}
782
793
783
794
/*
···
880
855
fpu_user_cfg.max_features = fpu_kernel_cfg.max_features;
881
856
fpu_user_cfg.max_features &= XFEATURE_MASK_USER_SUPPORTED;
882
857
883
-
/* Clean out dynamic features from default */
884
-
fpu_kernel_cfg.default_features = fpu_kernel_cfg.max_features;
885
-
fpu_kernel_cfg.default_features &= ~XFEATURE_MASK_USER_DYNAMIC;
886
-
887
-
fpu_user_cfg.default_features = fpu_user_cfg.max_features;
888
-
fpu_user_cfg.default_features &= ~XFEATURE_MASK_USER_DYNAMIC;
858
+
/*
859
+
* Now, given maximum feature set, determine default values by
860
+
* applying default masks.
861
+
*/
862
+
fpu_kernel_cfg.default_features = fpu_kernel_cfg.max_features & host_default_mask();
863
+
fpu_user_cfg.default_features = fpu_user_cfg.max_features & host_default_mask();
864
+
guest_default_cfg.features = fpu_kernel_cfg.max_features & guest_default_mask();
889
865
890
866
/* Store it for paranoia check at the end */
891
867
xfeatures = fpu_kernel_cfg.max_features;
+2
-3
arch/x86/mm/extable.c
+2
-3
arch/x86/mm/extable.c
···
122
122
static bool ex_handler_fprestore(const struct exception_table_entry *fixup,
123
123
struct pt_regs *regs)
124
124
{
125
-
regs->ip = ex_fixup_addr(fixup);
126
-
127
125
WARN_ONCE(1, "Bad FPU state detected at %pB, reinitializing FPU registers.",
128
126
(void *)instruction_pointer(regs));
129
127
130
128
fpu_reset_from_exception_fixup();
131
-
return true;
129
+
130
+
return ex_handler_default(fixup, regs);
132
131
}
133
132
134
133
/*