Release 4.14 arch/x86/include/asm/cpufeature.h

Directory: arch/x86/include/asm
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_X86_CPUFEATURE_H

#define _ASM_X86_CPUFEATURE_H

#include <asm/processor.h>

#if defined(__KERNEL__) && !defined(__ASSEMBLY__)

#include <asm/asm.h>
#include <linux/bitops.h>


enum cpuid_leafs
{
	
CPUID_1_EDX		= 0,
	
CPUID_8000_0001_EDX,
	
CPUID_8086_0001_EDX,
	
CPUID_LNX_1,
	
CPUID_1_ECX,
	
CPUID_C000_0001_EDX,
	
CPUID_8000_0001_ECX,
	
CPUID_LNX_2,
	
CPUID_LNX_3,
	
CPUID_7_0_EBX,
	
CPUID_D_1_EAX,
	
CPUID_F_0_EDX,
	
CPUID_F_1_EDX,
	
CPUID_8000_0008_EBX,
	
CPUID_6_EAX,
	
CPUID_8000_000A_EDX,
	
CPUID_7_ECX,
	
CPUID_8000_0007_EBX,
};

#ifdef CONFIG_X86_FEATURE_NAMES
extern const char * const x86_cap_flags[NCAPINTS*32];
extern const char * const x86_power_flags[32];

#define X86_CAP_FMT "%s"

#define x86_cap_flag(flag) x86_cap_flags[flag]
#else

#define X86_CAP_FMT "%d:%d"

#define x86_cap_flag(flag) ((flag) >> 5), ((flag) & 31)
#endif

/*
 * In order to save room, we index into this array by doing
 * X86_BUG_<name> - NCAPINTS*32.
 */
extern const char * const x86_bug_flags[NBUGINTS*32];


#define test_cpu_cap(c, bit)						\
	 test_bit(bit, (unsigned long *)((c)->x86_capability))

/*
 * There are 32 bits/features in each mask word.  The high bits
 * (selected with (bit>>5) give us the word number and the low 5
 * bits give us the bit/feature number inside the word.
 * (1UL<<((bit)&31) gives us a mask for the feature_bit so we can
 * see if it is set in the mask word.
 */

#define CHECK_BIT_IN_MASK_WORD(maskname, word, bit)	\
	(((bit)>>5)==(word) && (1UL<<((bit)&31) & maskname##word ))


#define REQUIRED_MASK_BIT_SET(feature_bit)		\
	 ( CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  0, feature_bit) ||     \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  1, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  2, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  3, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  4, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  5, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  6, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  7, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  8, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK,  9, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 10, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 11, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 12, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 13, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 14, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 15, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 16, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(REQUIRED_MASK, 17, feature_bit) ||    \
           REQUIRED_MASK_CHECK                                    ||    \
           BUILD_BUG_ON_ZERO(NCAPINTS != 18))


#define DISABLED_MASK_BIT_SET(feature_bit)				\
	 ( CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  0, feature_bit) ||     \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  1, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  2, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  3, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  4, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  5, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  6, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  7, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  8, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK,  9, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 10, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 11, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 12, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 13, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 14, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 15, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 16, feature_bit) ||    \
           CHECK_BIT_IN_MASK_WORD(DISABLED_MASK, 17, feature_bit) ||    \
           DISABLED_MASK_CHECK                                    ||    \
           BUILD_BUG_ON_ZERO(NCAPINTS != 18))


#define cpu_has(c, bit)							\
	(__builtin_constant_p(bit) && REQUIRED_MASK_BIT_SET(bit) ? 1 :  \
         test_cpu_cap(c, bit))


#define this_cpu_has(bit)						\
	(__builtin_constant_p(bit) && REQUIRED_MASK_BIT_SET(bit) ? 1 :  \
         x86_this_cpu_test_bit(bit, (unsigned long *)&cpu_info.x86_capability))

/*
 * This macro is for detection of features which need kernel
 * infrastructure to be used.  It may *not* directly test the CPU
 * itself.  Use the cpu_has() family if you want true runtime
 * testing of CPU features, like in hypervisor code where you are
 * supporting a possible guest feature where host support for it
 * is not relevant.
 */

#define cpu_feature_enabled(bit)	\
	(__builtin_constant_p(bit) && DISABLED_MASK_BIT_SET(bit) ? 0 : static_cpu_has(bit))


#define boot_cpu_has(bit)	cpu_has(&boot_cpu_data, bit)


#define set_cpu_cap(c, bit)	set_bit(bit, (unsigned long *)((c)->x86_capability))

#define clear_cpu_cap(c, bit)	clear_bit(bit, (unsigned long *)((c)->x86_capability))

#define setup_clear_cpu_cap(bit) do { \
        clear_cpu_cap(&boot_cpu_data, bit);     \
        set_bit(bit, (unsigned long *)cpu_caps_cleared); \
} while (0)

#define setup_force_cpu_cap(bit) do { \
        set_cpu_cap(&boot_cpu_data, bit);       \
        set_bit(bit, (unsigned long *)cpu_caps_set);    \
} while (0)

#if defined(CC_HAVE_ASM_GOTO) && defined(CONFIG_X86_FAST_FEATURE_TESTS)
/*
 * Static testing of CPU features.  Used the same as boot_cpu_has().
 * These will statically patch the target code for additional
 * performance.
 */


static __always_inline __pure bool _static_cpu_has(u16 bit)
{
		asm_volatile_goto("1: jmp 6f\n"
			 "2:\n"
			 ".skip -(((5f-4f) - (2b-1b)) > 0) * "
			         "((5f-4f) - (2b-1b)),0x90\n"
			 "3:\n"
			 ".section .altinstructions,\"a\"\n"
			 " .long 1b - .\n"		/* src offset */
			 " .long 4f - .\n"		/* repl offset */
			 " .word %P1\n"			/* always replace */
			 " .byte 3b - 1b\n"		/* src len */
			 " .byte 5f - 4f\n"		/* repl len */
			 " .byte 3b - 2b\n"		/* pad len */
			 ".previous\n"
			 ".section .altinstr_replacement,\"ax\"\n"
			 "4: jmp %l[t_no]\n"
			 "5:\n"
			 ".previous\n"
			 ".section .altinstructions,\"a\"\n"
			 " .long 1b - .\n"		/* src offset */
			 " .long 0\n"			/* no replacement */
			 " .word %P0\n"			/* feature bit */
			 " .byte 3b - 1b\n"		/* src len */
			 " .byte 0\n"			/* repl len */
			 " .byte 0\n"			/* pad len */
			 ".previous\n"
			 ".section .altinstr_aux,\"ax\"\n"
			 "6:\n"
			 " testb %[bitnum],%[cap_byte]\n"
			 " jnz %l[t_yes]\n"
			 " jmp %l[t_no]\n"
			 ".previous\n"
			 : : "i" (bit), "i" (X86_FEATURE_ALWAYS),
			     [bitnum] "i" (1 << (bit & 7)),
			     [cap_byte] "m" (((const char *)boot_cpu_data.x86_capability)[bit >> 3])
			 : : t_yes, t_no);
	t_yes:
		return true;
	t_no:
		return false;
}

Contributors
Person Tokens Prop Commits CommitProp
Brian Gerst 46 38.33% 1 16.67%
Borislav Petkov 42 35.00% 4 66.67%
Ingo Molnar 32 26.67% 1 16.67%
Total 120 100.00% 6 100.00%


#define static_cpu_has(bit)					\
(                                                               \
        __builtin_constant_p(boot_cpu_has(bit)) ?               \
                boot_cpu_has(bit) :                             \
                _static_cpu_has(bit)                            \
)
#else
/*
 * Fall back to dynamic for gcc versions which don't support asm goto. Should be
 * a minority now anyway.
 */

#define static_cpu_has(bit)		boot_cpu_has(bit)
#endif


#define cpu_has_bug(c, bit)		cpu_has(c, (bit))

#define set_cpu_bug(c, bit)		set_cpu_cap(c, (bit))

#define clear_cpu_bug(c, bit)		clear_cpu_cap(c, (bit))


#define static_cpu_has_bug(bit)		static_cpu_has((bit))

#define boot_cpu_has_bug(bit)		cpu_has_bug(&boot_cpu_data, (bit))

#define boot_cpu_set_bug(bit)		set_cpu_cap(&boot_cpu_data, (bit))


#define MAX_CPU_FEATURES		(NCAPINTS * 32)

#define cpu_have_feature		boot_cpu_has


#define CPU_FEATURE_TYPEFMT		"x86,ven%04Xfam%04Xmod%04X"

#define CPU_FEATURE_TYPEVAL		boot_cpu_data.x86_vendor, boot_cpu_data.x86, \
                                        boot_cpu_data.x86_model

#endif /* defined(__KERNEL__) && !defined(__ASSEMBLY__) */
#endif /* _ASM_X86_CPUFEATURE_H */
Overall Contributors
Person Tokens Prop Commits CommitProp
Borislav Petkov 163 35.36% 13 38.24%
H. Peter Anvin 79 17.14% 5 14.71%
Brian Gerst 46 9.98% 1 2.94%
Ingo Molnar 42 9.11% 2 5.88%
Dave Hansen 35 7.59% 3 8.82%
Josh Triplett 29 6.29% 1 2.94%
Jeremy Fitzhardinge 18 3.90% 1 2.94%
Ard Biesheuvel 15 3.25% 1 2.94%
Christoph Lameter 15 3.25% 1 2.94%
Andi Kleen 12 2.60% 2 5.88%
Yazen Ghannam 2 0.43% 1 2.94%
Tetsuo Handa 2 0.43% 1 2.94%
Yinghai Lu 2 0.43% 1 2.94%
Greg Kroah-Hartman 1 0.22% 1 2.94%
Total 461 100.00% 34 100.00%
Directory: arch/x86/include/asm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Brian Gerst	46	38.33%	1	16.67%
Borislav Petkov	42	35.00%	4	66.67%
Ingo Molnar	32	26.67%	1	16.67%
Total	120	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/x86/include/asm/cpufeature.h

Contributors

Overall Contributors
