xstate.c 13.5 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

34 35
static unsigned int xstate_offsets[XFEATURES_NR_MAX] = { [ 0 ... XFEATURES_NR_MAX - 1] = -1};
static unsigned int xstate_sizes[XFEATURES_NR_MAX]   = { [ 0 ... XFEATURES_NR_MAX - 1] = -1};
36
static unsigned int xstate_comp_offsets[sizeof(xfeatures_mask)*8];
37 38 39

/* The number of supported xfeatures in xfeatures_mask: */
static unsigned int xfeatures_nr;
40

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
/*
 * 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);
}

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
/*
 * 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
		 * asks about "XSTATE_SSE | XSTATE_YMM" we'll print the
		 * 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);

98
/*
99 100 101 102 103
 * 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.
104 105 106 107 108 109 110 111
 *
 * 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.
112
 */
113
void fpstate_sanitize_xstate(struct fpu *fpu)
114
{
115
	struct fxregs_state *fx = &fpu->state.fxsave;
116
	int feature_bit;
117
	u64 xfeatures;
118

119
	if (!use_xsaveopt())
120 121
		return;

122
	xfeatures = fpu->state.xsave.header.xfeatures;
123 124 125

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

	/*
	 * FP is in init state
	 */
134
	if (!(xfeatures & XSTATE_FP)) {
135 136 137 138 139 140 141 142 143 144 145 146
		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
	 */
147
	if (!(xfeatures & XSTATE_SSE))
148 149
		memset(&fx->xmm_space[0], 0, 256);

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

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

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

172
		xfeatures >>= 1;
173 174 175 176
		feature_bit++;
	}
}

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

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

190
/*
191 192 193 194 195
 * Record the offsets and sizes of various xstates contained
 * in the XSAVE state memory layout.
 *
 * ( Note that certain features might be non-present, for them
 *   we'll have 0 offset and 0 size. )
196
 */
197
static void __init setup_xstate_features(void)
198
{
199
	u32 eax, ebx, ecx, edx, leaf;
200

201
	xfeatures_nr = fls64(xfeatures_mask);
202

203
	for (leaf = 2; leaf < xfeatures_nr; leaf++) {
204
		cpuid_count(XSTATE_CPUID, leaf, &eax, &ebx, &ecx, &edx);
205 206 207 208

		xstate_offsets[leaf] = ebx;
		xstate_sizes[leaf] = eax;

209
		printk(KERN_INFO "x86/fpu: xstate_offset[%d]: %4d, xstate_sizes[%d]: %4d\n", leaf, ebx, leaf, eax);
210
	}
211 212
}

213
static void __init print_xstate_feature(u64 xstate_mask)
214
{
215
	const char *feature_name;
216

217 218
	if (cpu_has_xfeatures(xstate_mask, &feature_name))
		pr_info("x86/fpu: Supporting XSAVE feature 0x%02Lx: '%s'\n", xstate_mask, feature_name);
219 220 221 222 223
}

/*
 * Print out all the supported xstate features:
 */
224
static void __init print_xstate_features(void)
225
{
226 227 228 229 230 231 232 233
	print_xstate_feature(XSTATE_FP);
	print_xstate_feature(XSTATE_SSE);
	print_xstate_feature(XSTATE_YMM);
	print_xstate_feature(XSTATE_BNDREGS);
	print_xstate_feature(XSTATE_BNDCSR);
	print_xstate_feature(XSTATE_OPMASK);
	print_xstate_feature(XSTATE_ZMM_Hi256);
	print_xstate_feature(XSTATE_Hi16_ZMM);
234 235
}

236 237 238 239 240
/*
 * 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.
 */
241
static void __init setup_xstate_comp(void)
242
{
243
	unsigned int xstate_comp_sizes[sizeof(xfeatures_mask)*8];
244 245
	int i;

246 247 248 249 250 251
	/*
	 * 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;
252
	xstate_comp_offsets[1] = offsetof(struct fxregs_state, xmm_space);
253 254

	if (!cpu_has_xsaves) {
255
		for (i = 2; i < xfeatures_nr; i++) {
256
			if (test_bit(i, (unsigned long *)&xfeatures_mask)) {
257 258 259 260 261 262 263 264 265
				xstate_comp_offsets[i] = xstate_offsets[i];
				xstate_comp_sizes[i] = xstate_sizes[i];
			}
		}
		return;
	}

	xstate_comp_offsets[2] = FXSAVE_SIZE + XSAVE_HDR_SIZE;

266
	for (i = 2; i < xfeatures_nr; i++) {
267
		if (test_bit(i, (unsigned long *)&xfeatures_mask))
268 269 270 271 272 273 274 275 276 277 278
			xstate_comp_sizes[i] = xstate_sizes[i];
		else
			xstate_comp_sizes[i] = 0;

		if (i > 2)
			xstate_comp_offsets[i] = xstate_comp_offsets[i-1]
					+ xstate_comp_sizes[i-1];

	}
}

279 280 281
/*
 * setup the xstate image representing the init state
 */
282
static void __init setup_init_fpu_buf(void)
283
{
284 285 286 287 288
	static int on_boot_cpu = 1;

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;

289 290 291 292
	if (!cpu_has_xsave)
		return;

	setup_xstate_features();
293
	print_xstate_features();
294

295
	if (cpu_has_xsaves) {
296 297
		init_fpstate.xsave.header.xcomp_bv = (u64)1 << 63 | xfeatures_mask;
		init_fpstate.xsave.header.xfeatures = xfeatures_mask;
298 299
	}

300 301 302
	/*
	 * Init all the features state with header_bv being 0x0
	 */
303
	copy_kernel_to_xregs_booting(&init_fpstate.xsave);
304

305 306 307 308
	/*
	 * Dump the init state again. This is to identify the init state
	 * of any feature which is not represented by all zero's.
	 */
309
	copy_xregs_to_kernel_booting(&init_fpstate.xsave);
310 311
}

F
Fenghua Yu 已提交
312
/*
313
 * Calculate total size of enabled xstates in XCR0/xfeatures_mask.
F
Fenghua Yu 已提交
314
 */
D
Dave Hansen 已提交
315
static unsigned int __init calculate_xstate_size(void)
F
Fenghua Yu 已提交
316 317
{
	unsigned int eax, ebx, ecx, edx;
D
Dave Hansen 已提交
318
	unsigned int calculated_xstate_size;
F
Fenghua Yu 已提交
319 320 321 322
	int i;

	if (!cpu_has_xsaves) {
		cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
323 324
		calculated_xstate_size = ebx;
		return calculated_xstate_size;
F
Fenghua Yu 已提交
325 326
	}

D
Dave Hansen 已提交
327
	calculated_xstate_size = FXSAVE_SIZE + XSAVE_HDR_SIZE;
F
Fenghua Yu 已提交
328
	for (i = 2; i < 64; i++) {
329
		if (test_bit(i, (unsigned long *)&xfeatures_mask)) {
F
Fenghua Yu 已提交
330
			cpuid_count(XSTATE_CPUID, i, &eax, &ebx, &ecx, &edx);
D
Dave Hansen 已提交
331
			calculated_xstate_size += eax;
F
Fenghua Yu 已提交
332 333
		}
	}
D
Dave Hansen 已提交
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
	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;
	return 0;
}

void fpu__init_disable_system_xstate(void)
{
	xfeatures_mask = 0;
	cr4_clear_bits(X86_CR4_OSXSAVE);
	fpu__xstate_clear_all_cpu_caps();
F
Fenghua Yu 已提交
373 374
}

375 376
/*
 * Enable and initialize the xsave feature.
377
 * Called once per system bootup.
378
 */
379
void __init fpu__init_system_xstate(void)
380 381
{
	unsigned int eax, ebx, ecx, edx;
382
	static int on_boot_cpu = 1;
D
Dave Hansen 已提交
383
	int err;
384 385 386

	WARN_ON_FPU(!on_boot_cpu);
	on_boot_cpu = 0;
387

388 389 390 391 392
	if (!cpu_has_xsave) {
		pr_info("x86/fpu: Legacy x87 FPU detected.\n");
		return;
	}

393
	if (boot_cpu_data.cpuid_level < XSTATE_CPUID) {
394
		WARN_ON_FPU(1);
395 396 397 398
		return;
	}

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

401 402
	if ((xfeatures_mask & XSTATE_FPSSE) != XSTATE_FPSSE) {
		pr_err("x86/fpu: FP/SSE not present amongst the CPU's xstate features: 0x%llx.\n", xfeatures_mask);
403 404 405
		BUG();
	}

406
	/* Support only the state known to the OS: */
407
	xfeatures_mask = xfeatures_mask & XCNTXT_MASK;
408

409 410
	/* Enable xstate instructions to be able to continue with initialization: */
	fpu__init_cpu_xstate();
D
Dave Hansen 已提交
411 412 413 414 415 416
	err = init_xstate_size();
	if (err) {
		/* something went wrong, boot without any XSAVE support */
		fpu__init_disable_system_xstate();
		return;
	}
417

418
	update_regset_xstate_info(xstate_size, xfeatures_mask);
I
Ingo Molnar 已提交
419
	fpu__init_prepare_fx_sw_frame();
420
	setup_init_fpu_buf();
421
	setup_xstate_comp();
422

423
	pr_info("x86/fpu: Enabled xstate features 0x%llx, context size is %d bytes, using '%s' format.\n",
424
		xfeatures_mask,
425 426
		xstate_size,
		cpu_has_xsaves ? "compacted" : "standard");
427
}
428

429 430 431 432 433 434 435 436 437 438 439 440
/*
 * 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);
}

441 442 443 444 445 446 447
/*
 * 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.
 *
448 449 450
 * Note that if there is no data for the field in the xsave buffer
 * this will return NULL.
 *
451
 * Inputs:
452 453 454
 *	xstate: the thread's storage area for all FPU data
 *	xstate_feature: state which is defined in xsave.h (e.g.
 *	XSTATE_FP, XSTATE_SSE, etc...)
455
 * Output:
456 457
 *	address of the state in the xsave area, or NULL if the
 *	field is not present in the xsave buffer.
458
 */
459
void *get_xsave_addr(struct xregs_state *xsave, int xstate_feature)
460
{
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	int feature_nr = fls64(xstate_feature) - 1;
	/*
	 * Do we even *have* xsave state?
	 */
	if (!boot_cpu_has(X86_FEATURE_XSAVE))
		return NULL;

	xsave = &current->thread.fpu.state.xsave;
	/*
	 * 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))
488 489
		return NULL;

490
	return (void *)xsave + xstate_comp_offsets[feature_nr];
491
}
P
Paolo Bonzini 已提交
492
EXPORT_SYMBOL_GPL(get_xsave_addr);
493 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 521 522 523 524

/*
 * 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:
 *	@xsave_state: state which is defined in xsave.h (e.g. XSTATE_FP,
 *	XSTATE_SSE, etc...)
 * 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);
}