xstate.c 20.1 KB
Newer Older
1 2 3 4 5 6
/*
 * xsave/xrstor support.
 *
 * Author: Suresh Siddha <suresh.b.siddha@intel.com>
 */
#include <linux/compat.h>
F
Fenghua Yu 已提交
7
#include <linux/cpu.h>
8

9
#include <asm/fpu/api.h>
10
#include <asm/fpu/internal.h>
11
#include <asm/fpu/signal.h>
12
#include <asm/fpu/regset.h>
I
Ingo Molnar 已提交
13

A
Andy Lutomirski 已提交
14
#include <asm/tlbflush.h>
15

16 17 18 19 20 21 22 23 24 25 26 27 28
static const char *xfeature_names[] =
{
	"x87 floating point registers"	,
	"SSE registers"			,
	"AVX registers"			,
	"MPX bounds registers"		,
	"MPX CSR"			,
	"AVX-512 opmask"		,
	"AVX-512 Hi256"			,
	"AVX-512 ZMM_Hi256"		,
	"unknown xstate feature"	,
};

29
/*
30
 * Mask of xstate features supported by the CPU and the kernel:
31
 */
32
u64 xfeatures_mask __read_mostly;
33

D
Dave Hansen 已提交
34 35
static unsigned int xstate_offsets[XFEATURE_MAX] = { [ 0 ... XFEATURE_MAX - 1] = -1};
static unsigned int xstate_sizes[XFEATURE_MAX]   = { [ 0 ... XFEATURE_MAX - 1] = -1};
36
static unsigned int xstate_comp_offsets[sizeof(xfeatures_mask)*8];
37

38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
/*
 * Clear all of the X86_FEATURE_* bits that are unavailable
 * when the CPU has no XSAVE support.
 */
void fpu__xstate_clear_all_cpu_caps(void)
{
	setup_clear_cpu_cap(X86_FEATURE_XSAVE);
	setup_clear_cpu_cap(X86_FEATURE_XSAVEOPT);
	setup_clear_cpu_cap(X86_FEATURE_XSAVEC);
	setup_clear_cpu_cap(X86_FEATURE_XSAVES);
	setup_clear_cpu_cap(X86_FEATURE_AVX);
	setup_clear_cpu_cap(X86_FEATURE_AVX2);
	setup_clear_cpu_cap(X86_FEATURE_AVX512F);
	setup_clear_cpu_cap(X86_FEATURE_AVX512PF);
	setup_clear_cpu_cap(X86_FEATURE_AVX512ER);
	setup_clear_cpu_cap(X86_FEATURE_AVX512CD);
	setup_clear_cpu_cap(X86_FEATURE_MPX);
55
	setup_clear_cpu_cap(X86_FEATURE_XGETBV1);
56 57
}

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
/*
 * Return whether the system supports a given xfeature.
 *
 * Also return the name of the (most advanced) feature that the caller requested:
 */
int cpu_has_xfeatures(u64 xfeatures_needed, const char **feature_name)
{
	u64 xfeatures_missing = xfeatures_needed & ~xfeatures_mask;

	if (unlikely(feature_name)) {
		long xfeature_idx, max_idx;
		u64 xfeatures_print;
		/*
		 * So we use FLS here to be able to print the most advanced
		 * feature that was requested but is missing. So if a driver
D
Dave Hansen 已提交
73
		 * asks about "XFEATURE_MASK_SSE | XFEATURE_MASK_YMM" we'll print the
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
		 * missing AVX feature - this is the most informative message
		 * to users:
		 */
		if (xfeatures_missing)
			xfeatures_print = xfeatures_missing;
		else
			xfeatures_print = xfeatures_needed;

		xfeature_idx = fls64(xfeatures_print)-1;
		max_idx = ARRAY_SIZE(xfeature_names)-1;
		xfeature_idx = min(xfeature_idx, max_idx);

		*feature_name = xfeature_names[xfeature_idx];
	}

	if (xfeatures_missing)
		return 0;

	return 1;
}
EXPORT_SYMBOL_GPL(cpu_has_xfeatures);

96
/*
97 98 99 100 101
 * When executing XSAVEOPT (or other optimized XSAVE instructions), if
 * a processor implementation detects that an FPU state component is still
 * (or is again) in its initialized state, it may clear the corresponding
 * bit in the header.xfeatures field, and can skip the writeout of registers
 * to the corresponding memory layout.
102 103 104 105 106 107 108 109
 *
 * This means that when the bit is zero, the state component might still contain
 * some previous - non-initialized register state.
 *
 * Before writing xstate information to user-space we sanitize those components,
 * to always ensure that the memory layout of a feature will be in the init state
 * if the corresponding header bit is zero. This is to ensure that user-space doesn't
 * see some stale state in the memory layout during signal handling, debugging etc.
110
 */
111
void fpstate_sanitize_xstate(struct fpu *fpu)
112
{
113
	struct fxregs_state *fx = &fpu->state.fxsave;
114
	int feature_bit;
115
	u64 xfeatures;
116

117
	if (!use_xsaveopt())
118 119
		return;

120
	xfeatures = fpu->state.xsave.header.xfeatures;
121 122 123

	/*
	 * None of the feature bits are in init state. So nothing else
L
Lucas De Marchi 已提交
124
	 * to do for us, as the memory layout is up to date.
125
	 */
126
	if ((xfeatures & xfeatures_mask) == xfeatures_mask)
127 128 129 130 131
		return;

	/*
	 * FP is in init state
	 */
D
Dave Hansen 已提交
132
	if (!(xfeatures & XFEATURE_MASK_FP)) {
133 134 135 136 137 138 139 140 141 142 143 144
		fx->cwd = 0x37f;
		fx->swd = 0;
		fx->twd = 0;
		fx->fop = 0;
		fx->rip = 0;
		fx->rdp = 0;
		memset(&fx->st_space[0], 0, 128);
	}

	/*
	 * SSE is in init state
	 */
D
Dave Hansen 已提交
145
	if (!(xfeatures & XFEATURE_MASK_SSE))
146 147
		memset(&fx->xmm_space[0], 0, 256);

148 149 150 151 152
	/*
	 * First two features are FPU and SSE, which above we handled
	 * in a special way already:
	 */
	feature_bit = 0x2;
153
	xfeatures = (xfeatures_mask & ~xfeatures) >> 2;
154 155

	/*
156 157 158
	 * Update all the remaining memory layouts according to their
	 * standard xstate layout, if their header bit is in the init
	 * state:
159
	 */
160 161
	while (xfeatures) {
		if (xfeatures & 0x1) {
162 163 164
			int offset = xstate_offsets[feature_bit];
			int size = xstate_sizes[feature_bit];

165
			memcpy((void *)fx + offset,
166
			       (void *)&init_fpstate.xsave + offset,
167 168 169
			       size);
		}

170
		xfeatures >>= 1;
171 172 173 174
		feature_bit++;
	}
}

175
/*
176 177
 * Enable the extended processor state save/restore feature.
 * Called once per CPU onlining.
178
 */
179
void fpu__init_cpu_xstate(void)
180
{
181
	if (!cpu_has_xsave || !xfeatures_mask)
182 183
		return;

A
Andy Lutomirski 已提交
184
	cr4_set_bits(X86_CR4_OSXSAVE);
185
	xsetbv(XCR_XFEATURE_ENABLED_MASK, xfeatures_mask);
186 187
}

188 189 190 191 192 193 194 195 196 197
/*
 * Note that in the future we will likely need a pair of
 * functions here: one for user xstates and the other for
 * system xstates.  For now, they are the same.
 */
static int xfeature_enabled(enum xfeature xfeature)
{
	return !!(xfeatures_mask & (1UL << xfeature));
}

198
/*
199 200
 * Record the offsets and sizes of various xstates contained
 * in the XSAVE state memory layout.
201
 */
202
static void __init setup_xstate_features(void)
203
{
D
Dave Hansen 已提交
204
	u32 eax, ebx, ecx, edx, i;
205 206 207
	/* start at the beginnning of the "extended state" */
	unsigned int last_good_offset = offsetof(struct xregs_state,
						 extended_state_area);
208

D
Dave Hansen 已提交
209
	for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
210 211
		if (!xfeature_enabled(i))
			continue;
212

213
		cpuid_count(XSTATE_CPUID, i, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
214 215
		xstate_offsets[i] = ebx;
		xstate_sizes[i] = eax;
216 217 218 219 220 221 222 223
		/*
		 * In our xstate size checks, we assume that the
		 * highest-numbered xstate feature has the
		 * highest offset in the buffer.  Ensure it does.
		 */
		WARN_ONCE(last_good_offset > xstate_offsets[i],
			"x86/fpu: misordered xstate at %d\n", last_good_offset);
		last_good_offset = xstate_offsets[i];
224

D
Dave Hansen 已提交
225
		printk(KERN_INFO "x86/fpu: xstate_offset[%d]: %4d, xstate_sizes[%d]: %4d\n", i, ebx, i, eax);
226
	}
227 228
}

229
static void __init print_xstate_feature(u64 xstate_mask)
230
{
231
	const char *feature_name;
232

233 234
	if (cpu_has_xfeatures(xstate_mask, &feature_name))
		pr_info("x86/fpu: Supporting XSAVE feature 0x%02Lx: '%s'\n", xstate_mask, feature_name);
235 236 237 238 239
}

/*
 * Print out all the supported xstate features:
 */
240
static void __init print_xstate_features(void)
241
{
D
Dave Hansen 已提交
242 243 244 245 246 247 248 249
	print_xstate_feature(XFEATURE_MASK_FP);
	print_xstate_feature(XFEATURE_MASK_SSE);
	print_xstate_feature(XFEATURE_MASK_YMM);
	print_xstate_feature(XFEATURE_MASK_BNDREGS);
	print_xstate_feature(XFEATURE_MASK_BNDCSR);
	print_xstate_feature(XFEATURE_MASK_OPMASK);
	print_xstate_feature(XFEATURE_MASK_ZMM_Hi256);
	print_xstate_feature(XFEATURE_MASK_Hi16_ZMM);
250 251
}

252 253 254 255 256
/*
 * This function sets up offsets and sizes of all extended states in
 * xsave area. This supports both standard format and compacted format
 * of the xsave aread.
 */
257
static void __init setup_xstate_comp(void)
258
{
259
	unsigned int xstate_comp_sizes[sizeof(xfeatures_mask)*8];
260 261
	int i;

262 263 264 265 266 267
	/*
	 * The FP xstates and SSE xstates are legacy states. They are always
	 * in the fixed offsets in the xsave area in either compacted form
	 * or standard form.
	 */
	xstate_comp_offsets[0] = 0;
268
	xstate_comp_offsets[1] = offsetof(struct fxregs_state, xmm_space);
269 270

	if (!cpu_has_xsaves) {
D
Dave Hansen 已提交
271
		for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
272
			if (xfeature_enabled(i)) {
273 274 275 276 277 278 279
				xstate_comp_offsets[i] = xstate_offsets[i];
				xstate_comp_sizes[i] = xstate_sizes[i];
			}
		}
		return;
	}

280 281
	xstate_comp_offsets[FIRST_EXTENDED_XFEATURE] =
		FXSAVE_SIZE + XSAVE_HDR_SIZE;
282

D
Dave Hansen 已提交
283
	for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
284
		if (xfeature_enabled(i))
285 286 287 288
			xstate_comp_sizes[i] = xstate_sizes[i];
		else
			xstate_comp_sizes[i] = 0;

289
		if (i > FIRST_EXTENDED_XFEATURE)
290 291 292 293 294 295
			xstate_comp_offsets[i] = xstate_comp_offsets[i-1]
					+ xstate_comp_sizes[i-1];

	}
}

296 297 298
/*
 * setup the xstate image representing the init state
 */
299
static void __init setup_init_fpu_buf(void)
300
{
301
	static int on_boot_cpu __initdata = 1;
302 303 304 305

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;

306 307 308 309
	if (!cpu_has_xsave)
		return;

	setup_xstate_features();
310
	print_xstate_features();
311

312
	if (cpu_has_xsaves) {
313 314
		init_fpstate.xsave.header.xcomp_bv = (u64)1 << 63 | xfeatures_mask;
		init_fpstate.xsave.header.xfeatures = xfeatures_mask;
315 316
	}

317 318 319
	/*
	 * Init all the features state with header_bv being 0x0
	 */
320
	copy_kernel_to_xregs_booting(&init_fpstate.xsave);
321

322 323 324 325
	/*
	 * Dump the init state again. This is to identify the init state
	 * of any feature which is not represented by all zero's.
	 */
326
	copy_xregs_to_kernel_booting(&init_fpstate.xsave);
327 328
}

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
static int xfeature_is_supervisor(int xfeature_nr)
{
	/*
	 * We currently do not support supervisor states, but if
	 * we did, we could find out like this.
	 *
	 * SDM says: If state component i is a user state component,
	 * ECX[0] return 0; if state component i is a supervisor
	 * state component, ECX[0] returns 1.
	u32 eax, ebx, ecx, edx;
	cpuid_count(XSTATE_CPUID, xfeature_nr, &eax, &ebx, &ecx, &edx;
	return !!(ecx & 1);
	*/
	return 0;
}
/*
static int xfeature_is_user(int xfeature_nr)
{
	return !xfeature_is_supervisor(xfeature_nr);
}
*/

/*
 * This check is important because it is easy to get XSTATE_*
 * confused with XSTATE_BIT_*.
 */
#define CHECK_XFEATURE(nr) do {		\
	WARN_ON(nr < FIRST_EXTENDED_XFEATURE);	\
	WARN_ON(nr >= XFEATURE_MAX);	\
} while (0)

/*
 * We could cache this like xstate_size[], but we only use
 * it here, so it would be a waste of space.
 */
static int xfeature_is_aligned(int xfeature_nr)
{
	u32 eax, ebx, ecx, edx;

	CHECK_XFEATURE(xfeature_nr);
	cpuid_count(XSTATE_CPUID, xfeature_nr, &eax, &ebx, &ecx, &edx);
	/*
	 * The value returned by ECX[1] indicates the alignment
	 * of state component i when the compacted format
	 * of the extended region of an XSAVE area is used
	 */
	return !!(ecx & 2);
}

static int xfeature_uncompacted_offset(int xfeature_nr)
{
	u32 eax, ebx, ecx, edx;

	CHECK_XFEATURE(xfeature_nr);
	cpuid_count(XSTATE_CPUID, xfeature_nr, &eax, &ebx, &ecx, &edx);
	return ebx;
}

static int xfeature_size(int xfeature_nr)
{
	u32 eax, ebx, ecx, edx;

	CHECK_XFEATURE(xfeature_nr);
	cpuid_count(XSTATE_CPUID, xfeature_nr, &eax, &ebx, &ecx, &edx);
	return eax;
}

/*
 * 'XSAVES' implies two different things:
 * 1. saving of supervisor/system state
 * 2. using the compacted format
 *
 * Use this function when dealing with the compacted format so
 * that it is obvious which aspect of 'XSAVES' is being handled
 * by the calling code.
 */
static int using_compacted_format(void)
{
	return cpu_has_xsaves;
}

static void __xstate_dump_leaves(void)
{
	int i;
	u32 eax, ebx, ecx, edx;
	static int should_dump = 1;

	if (!should_dump)
		return;
	should_dump = 0;
	/*
	 * Dump out a few leaves past the ones that we support
	 * just in case there are some goodies up there
	 */
	for (i = 0; i < XFEATURE_MAX + 10; i++) {
		cpuid_count(XSTATE_CPUID, i, &eax, &ebx, &ecx, &edx);
		pr_warn("CPUID[%02x, %02x]: eax=%08x ebx=%08x ecx=%08x edx=%08x\n",
			XSTATE_CPUID, i, eax, ebx, ecx, edx);
	}
}

#define XSTATE_WARN_ON(x) do {							\
	if (WARN_ONCE(x, "XSAVE consistency problem, dumping leaves")) {	\
		__xstate_dump_leaves();						\
	}									\
} while (0)

436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
#define XCHECK_SZ(sz, nr, nr_macro, __struct) do {			\
	if ((nr == nr_macro) &&						\
	    WARN_ONCE(sz != sizeof(__struct),				\
		"%s: struct is %zu bytes, cpu state %d bytes\n",	\
		__stringify(nr_macro), sizeof(__struct), sz)) {		\
		__xstate_dump_leaves();					\
	}								\
} while (0)

/*
 * We have a C struct for each 'xstate'.  We need to ensure
 * that our software representation matches what the CPU
 * tells us about the state's size.
 */
static void check_xstate_against_struct(int nr)
{
	/*
	 * Ask the CPU for the size of the state.
	 */
	int sz = xfeature_size(nr);
	/*
	 * Match each CPU state with the corresponding software
	 * structure.
	 */
	XCHECK_SZ(sz, nr, XFEATURE_YMM,       struct ymmh_struct);
	XCHECK_SZ(sz, nr, XFEATURE_BNDREGS,   struct mpx_bndreg_state);
	XCHECK_SZ(sz, nr, XFEATURE_BNDCSR,    struct mpx_bndcsr_state);
	XCHECK_SZ(sz, nr, XFEATURE_OPMASK,    struct avx_512_opmask_state);
	XCHECK_SZ(sz, nr, XFEATURE_ZMM_Hi256, struct avx_512_zmm_uppers_state);
	XCHECK_SZ(sz, nr, XFEATURE_Hi16_ZMM,  struct avx_512_hi16_state);

	/*
	 * Make *SURE* to add any feature numbers in below if
	 * there are "holes" in the xsave state component
	 * numbers.
	 */
	if ((nr < XFEATURE_YMM) ||
	    (nr >= XFEATURE_MAX)) {
		WARN_ONCE(1, "no structure for xstate: %d\n", nr);
		XSTATE_WARN_ON(1);
	}
}

479 480 481 482 483 484 485 486 487 488 489 490 491
/*
 * This essentially double-checks what the cpu told us about
 * how large the XSAVE buffer needs to be.  We are recalculating
 * it to be safe.
 */
static void do_extra_xstate_size_checks(void)
{
	int paranoid_xstate_size = FXSAVE_SIZE + XSAVE_HDR_SIZE;
	int i;

	for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
		if (!xfeature_enabled(i))
			continue;
492 493

		check_xstate_against_struct(i);
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
		/*
		 * Supervisor state components can be managed only by
		 * XSAVES, which is compacted-format only.
		 */
		if (!using_compacted_format())
			XSTATE_WARN_ON(xfeature_is_supervisor(i));

		/* Align from the end of the previous feature */
		if (xfeature_is_aligned(i))
			paranoid_xstate_size = ALIGN(paranoid_xstate_size, 64);
		/*
		 * The offset of a given state in the non-compacted
		 * format is given to us in a CPUID leaf.  We check
		 * them for being ordered (increasing offsets) in
		 * setup_xstate_features().
		 */
		if (!using_compacted_format())
			paranoid_xstate_size = xfeature_uncompacted_offset(i);
		/*
		 * The compacted-format offset always depends on where
		 * the previous state ended.
		 */
		paranoid_xstate_size += xfeature_size(i);
	}
	XSTATE_WARN_ON(paranoid_xstate_size != xstate_size);
}

F
Fenghua Yu 已提交
521
/*
522
 * Calculate total size of enabled xstates in XCR0/xfeatures_mask.
523 524 525 526 527 528 529 530
 *
 * Note the SDM's wording here.  "sub-function 0" only enumerates
 * the size of the *user* states.  If we use it to size a buffer
 * that we use 'XSAVES' on, we could potentially overflow the
 * buffer because 'XSAVES' saves system states too.
 *
 * Note that we do not currently set any bits on IA32_XSS so
 * 'XCR0 | IA32_XSS == XCR0' for now.
F
Fenghua Yu 已提交
531
 */
D
Dave Hansen 已提交
532
static unsigned int __init calculate_xstate_size(void)
F
Fenghua Yu 已提交
533 534
{
	unsigned int eax, ebx, ecx, edx;
D
Dave Hansen 已提交
535
	unsigned int calculated_xstate_size;
F
Fenghua Yu 已提交
536 537

	if (!cpu_has_xsaves) {
538 539 540 541 542 543 544
		/*
		 * - CPUID function 0DH, sub-function 0:
		 *    EBX enumerates the size (in bytes) required by
		 *    the XSAVE instruction for an XSAVE area
		 *    containing all the *user* state components
		 *    corresponding to bits currently set in XCR0.
		 */
F
Fenghua Yu 已提交
545
		cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
546
		calculated_xstate_size = ebx;
547 548 549 550 551 552 553 554 555 556 557
	} else {
		/*
		 * - CPUID function 0DH, sub-function 1:
		 *    EBX enumerates the size (in bytes) required by
		 *    the XSAVES instruction for an XSAVE area
		 *    containing all the state components
		 *    corresponding to bits currently set in
		 *    XCR0 | IA32_XSS.
		 */
		cpuid_count(XSTATE_CPUID, 1, &eax, &ebx, &ecx, &edx);
		calculated_xstate_size = ebx;
F
Fenghua Yu 已提交
558
	}
D
Dave Hansen 已提交
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
	return calculated_xstate_size;
}

/*
 * Will the runtime-enumerated 'xstate_size' fit in the init
 * task's statically-allocated buffer?
 */
static bool is_supported_xstate_size(unsigned int test_xstate_size)
{
	if (test_xstate_size <= sizeof(union fpregs_state))
		return true;

	pr_warn("x86/fpu: xstate buffer too small (%zu < %d), disabling xsave\n",
			sizeof(union fpregs_state), test_xstate_size);
	return false;
}

static int init_xstate_size(void)
{
	/* Recompute the context size for enabled features: */
	unsigned int possible_xstate_size = calculate_xstate_size();

	/* Ensure we have the space to store all enabled: */
	if (!is_supported_xstate_size(possible_xstate_size))
		return -EINVAL;

	/*
	 * The size is OK, we are definitely going to use xsave,
	 * make it known to the world that we need more space.
	 */
	xstate_size = possible_xstate_size;
590
	do_extra_xstate_size_checks();
D
Dave Hansen 已提交
591 592 593
	return 0;
}

D
Dave Hansen 已提交
594 595 596 597 598
/*
 * We enabled the XSAVE hardware, but something went wrong and
 * we can not use it.  Disable it.
 */
static void fpu__init_disable_system_xstate(void)
D
Dave Hansen 已提交
599 600 601 602
{
	xfeatures_mask = 0;
	cr4_clear_bits(X86_CR4_OSXSAVE);
	fpu__xstate_clear_all_cpu_caps();
F
Fenghua Yu 已提交
603 604
}

605 606
/*
 * Enable and initialize the xsave feature.
607
 * Called once per system bootup.
608
 */
609
void __init fpu__init_system_xstate(void)
610 611
{
	unsigned int eax, ebx, ecx, edx;
612
	static int on_boot_cpu __initdata = 1;
D
Dave Hansen 已提交
613
	int err;
614 615 616

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;
617

618 619 620 621 622
	if (!cpu_has_xsave) {
		pr_info("x86/fpu: Legacy x87 FPU detected.\n");
		return;
	}

623
	if (boot_cpu_data.cpuid_level < XSTATE_CPUID) {
624
		WARN_ON_FPU(1);
625 626 627 628
		return;
	}

	cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
629
	xfeatures_mask = eax + ((u64)edx << 32);
630

D
Dave Hansen 已提交
631
	if ((xfeatures_mask & XFEATURE_MASK_FPSSE) != XFEATURE_MASK_FPSSE) {
632
		pr_err("x86/fpu: FP/SSE not present amongst the CPU's xstate features: 0x%llx.\n", xfeatures_mask);
633 634 635
		BUG();
	}

636
	/* Support only the state known to the OS: */
637
	xfeatures_mask = xfeatures_mask & XCNTXT_MASK;
638

639 640
	/* Enable xstate instructions to be able to continue with initialization: */
	fpu__init_cpu_xstate();
D
Dave Hansen 已提交
641 642 643 644 645 646
	err = init_xstate_size();
	if (err) {
		/* something went wrong, boot without any XSAVE support */
		fpu__init_disable_system_xstate();
		return;
	}
647

648
	update_regset_xstate_info(xstate_size, xfeatures_mask);
I
Ingo Molnar 已提交
649
	fpu__init_prepare_fx_sw_frame();
650
	setup_init_fpu_buf();
651
	setup_xstate_comp();
652

653
	pr_info("x86/fpu: Enabled xstate features 0x%llx, context size is %d bytes, using '%s' format.\n",
654
		xfeatures_mask,
655 656
		xstate_size,
		cpu_has_xsaves ? "compacted" : "standard");
657
}
658

659 660 661 662 663 664 665 666 667 668 669 670
/*
 * Restore minimal FPU state after suspend:
 */
void fpu__resume_cpu(void)
{
	/*
	 * Restore XCR0 on xsave capable CPUs:
	 */
	if (cpu_has_xsave)
		xsetbv(XCR_XFEATURE_ENABLED_MASK, xfeatures_mask);
}

671 672 673 674 675 676 677
/*
 * Given the xsave area and a state inside, this function returns the
 * address of the state.
 *
 * This is the API that is called to get xstate address in either
 * standard format or compacted format of xsave area.
 *
678 679 680
 * Note that if there is no data for the field in the xsave buffer
 * this will return NULL.
 *
681
 * Inputs:
682 683
 *	xstate: the thread's storage area for all FPU data
 *	xstate_feature: state which is defined in xsave.h (e.g.
D
Dave Hansen 已提交
684
 *	XFEATURE_MASK_FP, XFEATURE_MASK_SSE, etc...)
685
 * Output:
686 687
 *	address of the state in the xsave area, or NULL if the
 *	field is not present in the xsave buffer.
688
 */
689
void *get_xsave_addr(struct xregs_state *xsave, int xstate_feature)
690
{
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
	int feature_nr = fls64(xstate_feature) - 1;
	/*
	 * Do we even *have* xsave state?
	 */
	if (!boot_cpu_has(X86_FEATURE_XSAVE))
		return NULL;

	/*
	 * We should not ever be requesting features that we
	 * have not enabled.  Remember that pcntxt_mask is
	 * what we write to the XCR0 register.
	 */
	WARN_ONCE(!(xfeatures_mask & xstate_feature),
		  "get of unsupported state");
	/*
	 * This assumes the last 'xsave*' instruction to
	 * have requested that 'xstate_feature' be saved.
	 * If it did not, we might be seeing and old value
	 * of the field in the buffer.
	 *
	 * This can happen because the last 'xsave' did not
	 * request that this feature be saved (unlikely)
	 * or because the "init optimization" caused it
	 * to not be saved.
	 */
	if (!(xsave->header.xfeatures & xstate_feature))
717 718
		return NULL;

719
	return (void *)xsave + xstate_comp_offsets[feature_nr];
720
}
P
Paolo Bonzini 已提交
721
EXPORT_SYMBOL_GPL(get_xsave_addr);
722 723 724 725 726 727 728 729 730 731 732 733

/*
 * This wraps up the common operations that need to occur when retrieving
 * data from xsave state.  It first ensures that the current task was
 * using the FPU and retrieves the data in to a buffer.  It then calculates
 * the offset of the requested field in the buffer.
 *
 * This function is safe to call whether the FPU is in use or not.
 *
 * Note that this only works on the current task.
 *
 * Inputs:
D
Dave Hansen 已提交
734 735
 *	@xsave_state: state which is defined in xsave.h (e.g. XFEATURE_MASK_FP,
 *	XFEATURE_MASK_SSE, etc...)
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
 * Output:
 *	address of the state in the xsave area or NULL if the state
 *	is not present or is in its 'init state'.
 */
const void *get_xsave_field_ptr(int xsave_state)
{
	struct fpu *fpu = &current->thread.fpu;

	if (!fpu->fpstate_active)
		return NULL;
	/*
	 * fpu__save() takes the CPU's xstate registers
	 * and saves them off to the 'fpu memory buffer.
	 */
	fpu__save(fpu);

	return get_xsave_addr(&fpu->state.xsave, xsave_state);
}