xstate.c 23.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
/*
 * Although we spell it out in here, the Processor Trace
 * xfeature is completely unused.  We use other mechanisms
 * to save/restore PT state in Linux.
 */
21 22 23 24 25 26 27 28 29 30
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"		,
31
	"Processor Trace (unused)"	,
32 33
	"Protection Keys User registers",
	"unknown xstate feature"	,
34 35
};

36
/*
37
 * Mask of xstate features supported by the CPU and the kernel:
38
 */
39
u64 xfeatures_mask __read_mostly;
40

D
Dave Hansen 已提交
41 42
static unsigned int xstate_offsets[XFEATURE_MAX] = { [ 0 ... XFEATURE_MAX - 1] = -1};
static unsigned int xstate_sizes[XFEATURE_MAX]   = { [ 0 ... XFEATURE_MAX - 1] = -1};
43
static unsigned int xstate_comp_offsets[sizeof(xfeatures_mask)*8];
44

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
/*
 * 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);
62
	setup_clear_cpu_cap(X86_FEATURE_XGETBV1);
63
	setup_clear_cpu_cap(X86_FEATURE_PKU);
64 65
}

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
/*
 * 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 已提交
81
		 * asks about "XFEATURE_MASK_SSE | XFEATURE_MASK_YMM" we'll print the
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
		 * 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);

104
/*
105 106 107 108 109
 * 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.
110 111 112 113 114 115 116 117
 *
 * 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.
118
 */
119
void fpstate_sanitize_xstate(struct fpu *fpu)
120
{
121
	struct fxregs_state *fx = &fpu->state.fxsave;
122
	int feature_bit;
123
	u64 xfeatures;
124

125
	if (!use_xsaveopt())
126 127
		return;

128
	xfeatures = fpu->state.xsave.header.xfeatures;
129 130 131

	/*
	 * None of the feature bits are in init state. So nothing else
L
Lucas De Marchi 已提交
132
	 * to do for us, as the memory layout is up to date.
133
	 */
134
	if ((xfeatures & xfeatures_mask) == xfeatures_mask)
135 136 137 138 139
		return;

	/*
	 * FP is in init state
	 */
D
Dave Hansen 已提交
140
	if (!(xfeatures & XFEATURE_MASK_FP)) {
141 142 143 144 145 146 147 148 149 150 151 152
		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 已提交
153
	if (!(xfeatures & XFEATURE_MASK_SSE))
154 155
		memset(&fx->xmm_space[0], 0, 256);

156 157 158 159 160
	/*
	 * First two features are FPU and SSE, which above we handled
	 * in a special way already:
	 */
	feature_bit = 0x2;
161
	xfeatures = (xfeatures_mask & ~xfeatures) >> 2;
162 163

	/*
164 165 166
	 * Update all the remaining memory layouts according to their
	 * standard xstate layout, if their header bit is in the init
	 * state:
167
	 */
168 169
	while (xfeatures) {
		if (xfeatures & 0x1) {
170 171 172
			int offset = xstate_offsets[feature_bit];
			int size = xstate_sizes[feature_bit];

173
			memcpy((void *)fx + offset,
174
			       (void *)&init_fpstate.xsave + offset,
175 176 177
			       size);
		}

178
		xfeatures >>= 1;
179 180 181 182
		feature_bit++;
	}
}

183
/*
184 185
 * Enable the extended processor state save/restore feature.
 * Called once per CPU onlining.
186
 */
187
void fpu__init_cpu_xstate(void)
188
{
189
	if (!cpu_has_xsave || !xfeatures_mask)
190 191
		return;

A
Andy Lutomirski 已提交
192
	cr4_set_bits(X86_CR4_OSXSAVE);
193
	xsetbv(XCR_XFEATURE_ENABLED_MASK, xfeatures_mask);
194 195
}

196 197 198 199 200 201 202 203 204 205
/*
 * 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));
}

206
/*
207 208
 * Record the offsets and sizes of various xstates contained
 * in the XSAVE state memory layout.
209
 */
210
static void __init setup_xstate_features(void)
211
{
D
Dave Hansen 已提交
212
	u32 eax, ebx, ecx, edx, i;
213 214 215
	/* start at the beginnning of the "extended state" */
	unsigned int last_good_offset = offsetof(struct xregs_state,
						 extended_state_area);
216

D
Dave Hansen 已提交
217
	for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
218 219
		if (!xfeature_enabled(i))
			continue;
220

221
		cpuid_count(XSTATE_CPUID, i, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
222 223
		xstate_offsets[i] = ebx;
		xstate_sizes[i] = eax;
224 225 226 227 228 229 230 231
		/*
		 * 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];
232

D
Dave Hansen 已提交
233
		printk(KERN_INFO "x86/fpu: xstate_offset[%d]: %4d, xstate_sizes[%d]: %4d\n", i, ebx, i, eax);
234
	}
235 236
}

237
static void __init print_xstate_feature(u64 xstate_mask)
238
{
239
	const char *feature_name;
240

241
	if (cpu_has_xfeatures(xstate_mask, &feature_name))
242
		pr_info("x86/fpu: Supporting XSAVE feature 0x%03Lx: '%s'\n", xstate_mask, feature_name);
243 244 245 246 247
}

/*
 * Print out all the supported xstate features:
 */
248
static void __init print_xstate_features(void)
249
{
D
Dave Hansen 已提交
250 251 252 253 254 255 256 257
	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);
258
	print_xstate_feature(XFEATURE_MASK_PKRU);
259 260
}

261 262 263 264 265
/*
 * 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.
 */
266
static void __init setup_xstate_comp(void)
267
{
268
	unsigned int xstate_comp_sizes[sizeof(xfeatures_mask)*8];
269 270
	int i;

271 272 273 274 275 276
	/*
	 * 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;
277
	xstate_comp_offsets[1] = offsetof(struct fxregs_state, xmm_space);
278 279

	if (!cpu_has_xsaves) {
D
Dave Hansen 已提交
280
		for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
281
			if (xfeature_enabled(i)) {
282 283 284 285 286 287 288
				xstate_comp_offsets[i] = xstate_offsets[i];
				xstate_comp_sizes[i] = xstate_sizes[i];
			}
		}
		return;
	}

289 290
	xstate_comp_offsets[FIRST_EXTENDED_XFEATURE] =
		FXSAVE_SIZE + XSAVE_HDR_SIZE;
291

D
Dave Hansen 已提交
292
	for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) {
293
		if (xfeature_enabled(i))
294 295 296 297
			xstate_comp_sizes[i] = xstate_sizes[i];
		else
			xstate_comp_sizes[i] = 0;

298
		if (i > FIRST_EXTENDED_XFEATURE)
299 300 301 302 303 304
			xstate_comp_offsets[i] = xstate_comp_offsets[i-1]
					+ xstate_comp_sizes[i-1];

	}
}

305 306 307
/*
 * setup the xstate image representing the init state
 */
308
static void __init setup_init_fpu_buf(void)
309
{
310
	static int on_boot_cpu __initdata = 1;
311 312 313 314

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;

315 316 317 318
	if (!cpu_has_xsave)
		return;

	setup_xstate_features();
319
	print_xstate_features();
320

321
	if (cpu_has_xsaves) {
322 323
		init_fpstate.xsave.header.xcomp_bv = (u64)1 << 63 | xfeatures_mask;
		init_fpstate.xsave.header.xfeatures = xfeatures_mask;
324 325
	}

326 327 328
	/*
	 * Init all the features state with header_bv being 0x0
	 */
329
	copy_kernel_to_xregs_booting(&init_fpstate.xsave);
330

331 332 333 334
	/*
	 * Dump the init state again. This is to identify the init state
	 * of any feature which is not represented by all zero's.
	 */
335
	copy_xregs_to_kernel_booting(&init_fpstate.xsave);
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 436 437 438 439 440 441 442 443 444
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)

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
#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);
475
	XCHECK_SZ(sz, nr, XFEATURE_PKRU,      struct pkru_state);
476 477 478 479 480 481 482

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

490 491 492 493 494 495 496 497 498 499 500 501 502
/*
 * 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;
503 504

		check_xstate_against_struct(i);
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
		/*
		 * 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 已提交
532
/*
533
 * Calculate total size of enabled xstates in XCR0/xfeatures_mask.
534 535 536 537 538 539 540 541
 *
 * 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 已提交
542
 */
D
Dave Hansen 已提交
543
static unsigned int __init calculate_xstate_size(void)
F
Fenghua Yu 已提交
544 545
{
	unsigned int eax, ebx, ecx, edx;
D
Dave Hansen 已提交
546
	unsigned int calculated_xstate_size;
F
Fenghua Yu 已提交
547 548

	if (!cpu_has_xsaves) {
549 550 551 552 553 554 555
		/*
		 * - 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 已提交
556
		cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
557
		calculated_xstate_size = ebx;
558 559 560 561 562 563 564 565 566 567 568
	} 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 已提交
569
	}
D
Dave Hansen 已提交
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
	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;
601
	do_extra_xstate_size_checks();
D
Dave Hansen 已提交
602 603 604
	return 0;
}

D
Dave Hansen 已提交
605 606 607 608 609
/*
 * 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 已提交
610 611 612 613
{
	xfeatures_mask = 0;
	cr4_clear_bits(X86_CR4_OSXSAVE);
	fpu__xstate_clear_all_cpu_caps();
F
Fenghua Yu 已提交
614 615
}

616 617
/*
 * Enable and initialize the xsave feature.
618
 * Called once per system bootup.
619
 */
620
void __init fpu__init_system_xstate(void)
621 622
{
	unsigned int eax, ebx, ecx, edx;
623
	static int on_boot_cpu __initdata = 1;
D
Dave Hansen 已提交
624
	int err;
625 626 627

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;
628

629 630 631 632 633
	if (!cpu_has_xsave) {
		pr_info("x86/fpu: Legacy x87 FPU detected.\n");
		return;
	}

634
	if (boot_cpu_data.cpuid_level < XSTATE_CPUID) {
635
		WARN_ON_FPU(1);
636 637 638 639
		return;
	}

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

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

647
	xfeatures_mask &= fpu__get_supported_xfeatures_mask();
648

649 650
	/* Enable xstate instructions to be able to continue with initialization: */
	fpu__init_cpu_xstate();
D
Dave Hansen 已提交
651 652 653 654 655 656
	err = init_xstate_size();
	if (err) {
		/* something went wrong, boot without any XSAVE support */
		fpu__init_disable_system_xstate();
		return;
	}
657

658
	update_regset_xstate_info(xstate_size, xfeatures_mask);
I
Ingo Molnar 已提交
659
	fpu__init_prepare_fx_sw_frame();
660
	setup_init_fpu_buf();
661
	setup_xstate_comp();
662

663
	pr_info("x86/fpu: Enabled xstate features 0x%llx, context size is %d bytes, using '%s' format.\n",
664
		xfeatures_mask,
665 666
		xstate_size,
		cpu_has_xsaves ? "compacted" : "standard");
667
}
668

669 670 671 672 673 674 675 676 677 678 679 680
/*
 * 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);
}

681 682 683 684 685 686 687 688 689 690 691 692 693
/*
 * Given an xstate feature mask, calculate where in the xsave
 * buffer the state is.  Callers should ensure that the buffer
 * is valid.
 *
 * Note: does not work for compacted buffers.
 */
void *__raw_xsave_addr(struct xregs_state *xsave, int xstate_feature_mask)
{
	int feature_nr = fls64(xstate_feature_mask) - 1;

	return (void *)xsave + xstate_comp_offsets[feature_nr];
}
694 695 696 697 698 699 700
/*
 * 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.
 *
701 702 703
 * Note that if there is no data for the field in the xsave buffer
 * this will return NULL.
 *
704
 * Inputs:
705 706
 *	xstate: the thread's storage area for all FPU data
 *	xstate_feature: state which is defined in xsave.h (e.g.
D
Dave Hansen 已提交
707
 *	XFEATURE_MASK_FP, XFEATURE_MASK_SSE, etc...)
708
 * Output:
709 710
 *	address of the state in the xsave area, or NULL if the
 *	field is not present in the xsave buffer.
711
 */
712
void *get_xsave_addr(struct xregs_state *xsave, int xstate_feature)
713
{
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
	/*
	 * 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))
739 740
		return NULL;

741
	return __raw_xsave_addr(xsave, xstate_feature);
742
}
P
Paolo Bonzini 已提交
743
EXPORT_SYMBOL_GPL(get_xsave_addr);
744 745 746 747 748 749 750 751 752 753 754 755

/*
 * 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 已提交
756 757
 *	@xsave_state: state which is defined in xsave.h (e.g. XFEATURE_MASK_FP,
 *	XFEATURE_MASK_SSE, etc...)
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
 * 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);
}
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857


/*
 * Set xfeatures (aka XSTATE_BV) bit for a feature that we want
 * to take out of its "init state".  This will ensure that an
 * XRSTOR actually restores the state.
 */
static void fpu__xfeature_set_non_init(struct xregs_state *xsave,
		int xstate_feature_mask)
{
	xsave->header.xfeatures |= xstate_feature_mask;
}

/*
 * This function is safe to call whether the FPU is in use or not.
 *
 * Note that this only works on the current task.
 *
 * Inputs:
 *	@xsave_state: state which is defined in xsave.h (e.g. XFEATURE_MASK_FP,
 *	XFEATURE_MASK_SSE, etc...)
 *	@xsave_state_ptr: a pointer to a copy of the state that you would
 *	like written in to the current task's FPU xsave state.  This pointer
 *	must not be located in the current tasks's xsave area.
 * Output:
 *	address of the state in the xsave area or NULL if the state
 *	is not present or is in its 'init state'.
 */
static void fpu__xfeature_set_state(int xstate_feature_mask,
		void *xstate_feature_src, size_t len)
{
	struct xregs_state *xsave = &current->thread.fpu.state.xsave;
	struct fpu *fpu = &current->thread.fpu;
	void *dst;

	if (!boot_cpu_has(X86_FEATURE_XSAVE)) {
		WARN_ONCE(1, "%s() attempted with no xsave support", __func__);
		return;
	}

	/*
	 * Tell the FPU code that we need the FPU state to be in
	 * 'fpu' (not in the registers), and that we need it to
	 * be stable while we write to it.
	 */
	fpu__current_fpstate_write_begin();

	/*
	 * This method *WILL* *NOT* work for compact-format
	 * buffers.  If the 'xstate_feature_mask' is unset in
	 * xcomp_bv then we may need to move other feature state
	 * "up" in the buffer.
	 */
	if (xsave->header.xcomp_bv & xstate_feature_mask) {
		WARN_ON_ONCE(1);
		goto out;
	}

	/* find the location in the xsave buffer of the desired state */
	dst = __raw_xsave_addr(&fpu->state.xsave, xstate_feature_mask);

	/*
	 * Make sure that the pointer being passed in did not
	 * come from the xsave buffer itself.
	 */
	WARN_ONCE(xstate_feature_src == dst, "set from xsave buffer itself");

	/* put the caller-provided data in the location */
	memcpy(dst, xstate_feature_src, len);

	/*
	 * Mark the xfeature so that the CPU knows there is state
	 * in the buffer now.
	 */
	fpu__xfeature_set_non_init(xsave, xstate_feature_mask);
out:
	/*
	 * We are done writing to the 'fpu'.  Reenable preeption
	 * and (possibly) move the fpstate back in to the fpregs.
	 */
	fpu__current_fpstate_write_end();
}