LCOV - code coverage report
Current view: top level - arch/x86/include/asm - processor.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 61 80 76.2 %
Date: 2022-03-28 13:20:08 Functions: 2 4 50.0 %
Branches: 22 66 33.3 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _ASM_X86_PROCESSOR_H
       3                 :            : #define _ASM_X86_PROCESSOR_H
       4                 :            : 
       5                 :            : #include <asm/processor-flags.h>
       6                 :            : 
       7                 :            : /* Forward declaration, a strange C thing */
       8                 :            : struct task_struct;
       9                 :            : struct mm_struct;
      10                 :            : struct io_bitmap;
      11                 :            : struct vm86;
      12                 :            : 
      13                 :            : #include <asm/math_emu.h>
      14                 :            : #include <asm/segment.h>
      15                 :            : #include <asm/types.h>
      16                 :            : #include <uapi/asm/sigcontext.h>
      17                 :            : #include <asm/current.h>
      18                 :            : #include <asm/cpufeatures.h>
      19                 :            : #include <asm/page.h>
      20                 :            : #include <asm/pgtable_types.h>
      21                 :            : #include <asm/percpu.h>
      22                 :            : #include <asm/msr.h>
      23                 :            : #include <asm/desc_defs.h>
      24                 :            : #include <asm/nops.h>
      25                 :            : #include <asm/special_insns.h>
      26                 :            : #include <asm/fpu/types.h>
      27                 :            : #include <asm/unwind_hints.h>
      28                 :            : #include <asm/vmxfeatures.h>
      29                 :            : 
      30                 :            : #include <linux/personality.h>
      31                 :            : #include <linux/cache.h>
      32                 :            : #include <linux/threads.h>
      33                 :            : #include <linux/math64.h>
      34                 :            : #include <linux/err.h>
      35                 :            : #include <linux/irqflags.h>
      36                 :            : #include <linux/mem_encrypt.h>
      37                 :            : 
      38                 :            : /*
      39                 :            :  * We handle most unaligned accesses in hardware.  On the other hand
      40                 :            :  * unaligned DMA can be quite expensive on some Nehalem processors.
      41                 :            :  *
      42                 :            :  * Based on this we disable the IP header alignment in network drivers.
      43                 :            :  */
      44                 :            : #define NET_IP_ALIGN    0
      45                 :            : 
      46                 :            : #define HBP_NUM 4
      47                 :            : 
      48                 :            : /*
      49                 :            :  * These alignment constraints are for performance in the vSMP case,
      50                 :            :  * but in the task_struct case we must also meet hardware imposed
      51                 :            :  * alignment requirements of the FPU state:
      52                 :            :  */
      53                 :            : #ifdef CONFIG_X86_VSMP
      54                 :            : # define ARCH_MIN_TASKALIGN             (1 << INTERNODE_CACHE_SHIFT)
      55                 :            : # define ARCH_MIN_MMSTRUCT_ALIGN        (1 << INTERNODE_CACHE_SHIFT)
      56                 :            : #else
      57                 :            : # define ARCH_MIN_TASKALIGN             __alignof__(union fpregs_state)
      58                 :            : # define ARCH_MIN_MMSTRUCT_ALIGN        0
      59                 :            : #endif
      60                 :            : 
      61                 :            : enum tlb_infos {
      62                 :            :         ENTRIES,
      63                 :            :         NR_INFO
      64                 :            : };
      65                 :            : 
      66                 :            : extern u16 __read_mostly tlb_lli_4k[NR_INFO];
      67                 :            : extern u16 __read_mostly tlb_lli_2m[NR_INFO];
      68                 :            : extern u16 __read_mostly tlb_lli_4m[NR_INFO];
      69                 :            : extern u16 __read_mostly tlb_lld_4k[NR_INFO];
      70                 :            : extern u16 __read_mostly tlb_lld_2m[NR_INFO];
      71                 :            : extern u16 __read_mostly tlb_lld_4m[NR_INFO];
      72                 :            : extern u16 __read_mostly tlb_lld_1g[NR_INFO];
      73                 :            : 
      74                 :            : /*
      75                 :            :  *  CPU type and hardware bug flags. Kept separately for each CPU.
      76                 :            :  *  Members of this structure are referenced in head_32.S, so think twice
      77                 :            :  *  before touching them. [mj]
      78                 :            :  */
      79                 :            : 
      80                 :            : struct cpuinfo_x86 {
      81                 :            :         __u8                    x86;            /* CPU family */
      82                 :            :         __u8                    x86_vendor;     /* CPU vendor */
      83                 :            :         __u8                    x86_model;
      84                 :            :         __u8                    x86_stepping;
      85                 :            : #ifdef CONFIG_X86_64
      86                 :            :         /* Number of 4K pages in DTLB/ITLB combined(in pages): */
      87                 :            :         int                     x86_tlbsize;
      88                 :            : #endif
      89                 :            : #ifdef CONFIG_X86_VMX_FEATURE_NAMES
      90                 :            :         __u32                   vmx_capability[NVMXINTS];
      91                 :            : #endif
      92                 :            :         __u8                    x86_virt_bits;
      93                 :            :         __u8                    x86_phys_bits;
      94                 :            :         /* CPUID returned core id bits: */
      95                 :            :         __u8                    x86_coreid_bits;
      96                 :            :         __u8                    cu_id;
      97                 :            :         /* Max extended CPUID function supported: */
      98                 :            :         __u32                   extended_cpuid_level;
      99                 :            :         /* Maximum supported CPUID level, -1=no CPUID: */
     100                 :            :         int                     cpuid_level;
     101                 :            :         /*
     102                 :            :          * Align to size of unsigned long because the x86_capability array
     103                 :            :          * is passed to bitops which require the alignment. Use unnamed
     104                 :            :          * union to enforce the array is aligned to size of unsigned long.
     105                 :            :          */
     106                 :            :         union {
     107                 :            :                 __u32           x86_capability[NCAPINTS + NBUGINTS];
     108                 :            :                 unsigned long   x86_capability_alignment;
     109                 :            :         };
     110                 :            :         char                    x86_vendor_id[16];
     111                 :            :         char                    x86_model_id[64];
     112                 :            :         /* in KB - valid for CPUS which support this call: */
     113                 :            :         unsigned int            x86_cache_size;
     114                 :            :         int                     x86_cache_alignment;    /* In bytes */
     115                 :            :         /* Cache QoS architectural values: */
     116                 :            :         int                     x86_cache_max_rmid;     /* max index */
     117                 :            :         int                     x86_cache_occ_scale;    /* scale to bytes */
     118                 :            :         int                     x86_power;
     119                 :            :         unsigned long           loops_per_jiffy;
     120                 :            :         /* cpuid returned max cores value: */
     121                 :            :         u16                     x86_max_cores;
     122                 :            :         u16                     apicid;
     123                 :            :         u16                     initial_apicid;
     124                 :            :         u16                     x86_clflush_size;
     125                 :            :         /* number of cores as seen by the OS: */
     126                 :            :         u16                     booted_cores;
     127                 :            :         /* Physical processor id: */
     128                 :            :         u16                     phys_proc_id;
     129                 :            :         /* Logical processor id: */
     130                 :            :         u16                     logical_proc_id;
     131                 :            :         /* Core id: */
     132                 :            :         u16                     cpu_core_id;
     133                 :            :         u16                     cpu_die_id;
     134                 :            :         u16                     logical_die_id;
     135                 :            :         /* Index into per_cpu list: */
     136                 :            :         u16                     cpu_index;
     137                 :            :         u32                     microcode;
     138                 :            :         /* Address space bits used by the cache internally */
     139                 :            :         u8                      x86_cache_bits;
     140                 :            :         unsigned                initialized : 1;
     141                 :            : } __randomize_layout;
     142                 :            : 
     143                 :            : struct cpuid_regs {
     144                 :            :         u32 eax, ebx, ecx, edx;
     145                 :            : };
     146                 :            : 
     147                 :            : enum cpuid_regs_idx {
     148                 :            :         CPUID_EAX = 0,
     149                 :            :         CPUID_EBX,
     150                 :            :         CPUID_ECX,
     151                 :            :         CPUID_EDX,
     152                 :            : };
     153                 :            : 
     154                 :            : #define X86_VENDOR_INTEL        0
     155                 :            : #define X86_VENDOR_CYRIX        1
     156                 :            : #define X86_VENDOR_AMD          2
     157                 :            : #define X86_VENDOR_UMC          3
     158                 :            : #define X86_VENDOR_CENTAUR      5
     159                 :            : #define X86_VENDOR_TRANSMETA    7
     160                 :            : #define X86_VENDOR_NSC          8
     161                 :            : #define X86_VENDOR_HYGON        9
     162                 :            : #define X86_VENDOR_ZHAOXIN      10
     163                 :            : #define X86_VENDOR_NUM          11
     164                 :            : 
     165                 :            : #define X86_VENDOR_UNKNOWN      0xff
     166                 :            : 
     167                 :            : /*
     168                 :            :  * capabilities of CPUs
     169                 :            :  */
     170                 :            : extern struct cpuinfo_x86       boot_cpu_data;
     171                 :            : extern struct cpuinfo_x86       new_cpu_data;
     172                 :            : 
     173                 :            : extern __u32                    cpu_caps_cleared[NCAPINTS + NBUGINTS];
     174                 :            : extern __u32                    cpu_caps_set[NCAPINTS + NBUGINTS];
     175                 :            : 
     176                 :            : #ifdef CONFIG_SMP
     177                 :            : DECLARE_PER_CPU_READ_MOSTLY(struct cpuinfo_x86, cpu_info);
     178                 :            : #define cpu_data(cpu)           per_cpu(cpu_info, cpu)
     179                 :            : #else
     180                 :            : #define cpu_info                boot_cpu_data
     181                 :            : #define cpu_data(cpu)           boot_cpu_data
     182                 :            : #endif
     183                 :            : 
     184                 :            : extern const struct seq_operations cpuinfo_op;
     185                 :            : 
     186                 :            : #define cache_line_size()       (boot_cpu_data.x86_cache_alignment)
     187                 :            : 
     188                 :            : extern void cpu_detect(struct cpuinfo_x86 *c);
     189                 :            : 
     190                 :          0 : static inline unsigned long long l1tf_pfn_limit(void)
     191                 :            : {
     192         [ #  # ]:          0 :         return BIT_ULL(boot_cpu_data.x86_cache_bits - 1 - PAGE_SHIFT);
     193                 :            : }
     194                 :            : 
     195                 :            : extern void early_cpu_init(void);
     196                 :            : extern void identify_boot_cpu(void);
     197                 :            : extern void identify_secondary_cpu(struct cpuinfo_x86 *);
     198                 :            : extern void print_cpu_info(struct cpuinfo_x86 *);
     199                 :            : void print_cpu_msr(struct cpuinfo_x86 *);
     200                 :            : 
     201                 :            : #ifdef CONFIG_X86_32
     202                 :            : extern int have_cpuid_p(void);
     203                 :            : #else
     204                 :         90 : static inline int have_cpuid_p(void)
     205                 :            : {
     206                 :         90 :         return 1;
     207                 :            : }
     208                 :            : #endif
     209                 :       3330 : static inline void native_cpuid(unsigned int *eax, unsigned int *ebx,
     210                 :            :                                 unsigned int *ecx, unsigned int *edx)
     211                 :            : {
     212                 :            :         /* ecx is often an input as well as an output. */
     213                 :       3300 :         asm volatile("cpuid"
     214                 :            :             : "=a" (*eax),
     215                 :            :               "=b" (*ebx),
     216                 :            :               "=c" (*ecx),
     217                 :            :               "=d" (*edx)
     218                 :          0 :             : "0" (*eax), "2" (*ecx)
     219                 :            :             : "memory");
     220                 :            : }
     221                 :            : 
     222                 :            : #define native_cpuid_reg(reg)                                   \
     223                 :            : static inline unsigned int native_cpuid_##reg(unsigned int op)  \
     224                 :            : {                                                               \
     225                 :            :         unsigned int eax = op, ebx, ecx = 0, edx;               \
     226                 :            :                                                                 \
     227                 :            :         native_cpuid(&eax, &ebx, &ecx, &edx);                   \
     228                 :            :                                                                 \
     229                 :            :         return reg;                                             \
     230                 :            : }
     231                 :            : 
     232                 :            : /*
     233                 :            :  * Native CPUID functions returning a single datum.
     234                 :            :  */
     235                 :         30 : native_cpuid_reg(eax)
     236                 :            : native_cpuid_reg(ebx)
     237         [ #  # ]:          0 : native_cpuid_reg(ecx)
     238                 :            : native_cpuid_reg(edx)
     239                 :            : 
     240                 :            : /*
     241                 :            :  * Friendlier CR3 helpers.
     242                 :            :  */
     243                 :        180 : static inline unsigned long read_cr3_pa(void)
     244                 :            : {
     245         [ -  + ]:        180 :         return __read_cr3() & CR3_ADDR_MASK;
     246                 :            : }
     247                 :            : 
     248                 :            : static inline unsigned long native_read_cr3_pa(void)
     249                 :            : {
     250                 :            :         return __native_read_cr3() & CR3_ADDR_MASK;
     251                 :            : }
     252                 :            : 
     253                 :         90 : static inline void load_cr3(pgd_t *pgdir)
     254                 :            : {
     255   [ -  +  -  + ]:         90 :         write_cr3(__sme_pa(pgdir));
     256                 :            : }
     257                 :            : 
     258                 :            : /*
     259                 :            :  * Note that while the legacy 'TSS' name comes from 'Task State Segment',
     260                 :            :  * on modern x86 CPUs the TSS also holds information important to 64-bit mode,
     261                 :            :  * unrelated to the task-switch mechanism:
     262                 :            :  */
     263                 :            : #ifdef CONFIG_X86_32
     264                 :            : /* This is the TSS defined by the hardware. */
     265                 :            : struct x86_hw_tss {
     266                 :            :         unsigned short          back_link, __blh;
     267                 :            :         unsigned long           sp0;
     268                 :            :         unsigned short          ss0, __ss0h;
     269                 :            :         unsigned long           sp1;
     270                 :            : 
     271                 :            :         /*
     272                 :            :          * We don't use ring 1, so ss1 is a convenient scratch space in
     273                 :            :          * the same cacheline as sp0.  We use ss1 to cache the value in
     274                 :            :          * MSR_IA32_SYSENTER_CS.  When we context switch
     275                 :            :          * MSR_IA32_SYSENTER_CS, we first check if the new value being
     276                 :            :          * written matches ss1, and, if it's not, then we wrmsr the new
     277                 :            :          * value and update ss1.
     278                 :            :          *
     279                 :            :          * The only reason we context switch MSR_IA32_SYSENTER_CS is
     280                 :            :          * that we set it to zero in vm86 tasks to avoid corrupting the
     281                 :            :          * stack if we were to go through the sysenter path from vm86
     282                 :            :          * mode.
     283                 :            :          */
     284                 :            :         unsigned short          ss1;    /* MSR_IA32_SYSENTER_CS */
     285                 :            : 
     286                 :            :         unsigned short          __ss1h;
     287                 :            :         unsigned long           sp2;
     288                 :            :         unsigned short          ss2, __ss2h;
     289                 :            :         unsigned long           __cr3;
     290                 :            :         unsigned long           ip;
     291                 :            :         unsigned long           flags;
     292                 :            :         unsigned long           ax;
     293                 :            :         unsigned long           cx;
     294                 :            :         unsigned long           dx;
     295                 :            :         unsigned long           bx;
     296                 :            :         unsigned long           sp;
     297                 :            :         unsigned long           bp;
     298                 :            :         unsigned long           si;
     299                 :            :         unsigned long           di;
     300                 :            :         unsigned short          es, __esh;
     301                 :            :         unsigned short          cs, __csh;
     302                 :            :         unsigned short          ss, __ssh;
     303                 :            :         unsigned short          ds, __dsh;
     304                 :            :         unsigned short          fs, __fsh;
     305                 :            :         unsigned short          gs, __gsh;
     306                 :            :         unsigned short          ldt, __ldth;
     307                 :            :         unsigned short          trace;
     308                 :            :         unsigned short          io_bitmap_base;
     309                 :            : 
     310                 :            : } __attribute__((packed));
     311                 :            : #else
     312                 :            : struct x86_hw_tss {
     313                 :            :         u32                     reserved1;
     314                 :            :         u64                     sp0;
     315                 :            : 
     316                 :            :         /*
     317                 :            :          * We store cpu_current_top_of_stack in sp1 so it's always accessible.
     318                 :            :          * Linux does not use ring 1, so sp1 is not otherwise needed.
     319                 :            :          */
     320                 :            :         u64                     sp1;
     321                 :            : 
     322                 :            :         /*
     323                 :            :          * Since Linux does not use ring 2, the 'sp2' slot is unused by
     324                 :            :          * hardware.  entry_SYSCALL_64 uses it as scratch space to stash
     325                 :            :          * the user RSP value.
     326                 :            :          */
     327                 :            :         u64                     sp2;
     328                 :            : 
     329                 :            :         u64                     reserved2;
     330                 :            :         u64                     ist[7];
     331                 :            :         u32                     reserved3;
     332                 :            :         u32                     reserved4;
     333                 :            :         u16                     reserved5;
     334                 :            :         u16                     io_bitmap_base;
     335                 :            : 
     336                 :            : } __attribute__((packed));
     337                 :            : #endif
     338                 :            : 
     339                 :            : /*
     340                 :            :  * IO-bitmap sizes:
     341                 :            :  */
     342                 :            : #define IO_BITMAP_BITS                  65536
     343                 :            : #define IO_BITMAP_BYTES                 (IO_BITMAP_BITS / BITS_PER_BYTE)
     344                 :            : #define IO_BITMAP_LONGS                 (IO_BITMAP_BYTES / sizeof(long))
     345                 :            : 
     346                 :            : #define IO_BITMAP_OFFSET_VALID_MAP                              \
     347                 :            :         (offsetof(struct tss_struct, io_bitmap.bitmap) -        \
     348                 :            :          offsetof(struct tss_struct, x86_tss))
     349                 :            : 
     350                 :            : #define IO_BITMAP_OFFSET_VALID_ALL                              \
     351                 :            :         (offsetof(struct tss_struct, io_bitmap.mapall) -        \
     352                 :            :          offsetof(struct tss_struct, x86_tss))
     353                 :            : 
     354                 :            : #ifdef CONFIG_X86_IOPL_IOPERM
     355                 :            : /*
     356                 :            :  * sizeof(unsigned long) coming from an extra "long" at the end of the
     357                 :            :  * iobitmap. The limit is inclusive, i.e. the last valid byte.
     358                 :            :  */
     359                 :            : # define __KERNEL_TSS_LIMIT     \
     360                 :            :         (IO_BITMAP_OFFSET_VALID_ALL + IO_BITMAP_BYTES + \
     361                 :            :          sizeof(unsigned long) - 1)
     362                 :            : #else
     363                 :            : # define __KERNEL_TSS_LIMIT     \
     364                 :            :         (offsetof(struct tss_struct, x86_tss) + sizeof(struct x86_hw_tss) - 1)
     365                 :            : #endif
     366                 :            : 
     367                 :            : /* Base offset outside of TSS_LIMIT so unpriviledged IO causes #GP */
     368                 :            : #define IO_BITMAP_OFFSET_INVALID        (__KERNEL_TSS_LIMIT + 1)
     369                 :            : 
     370                 :            : struct entry_stack {
     371                 :            :         unsigned long           words[64];
     372                 :            : };
     373                 :            : 
     374                 :            : struct entry_stack_page {
     375                 :            :         struct entry_stack stack;
     376                 :            : } __aligned(PAGE_SIZE);
     377                 :            : 
     378                 :            : /*
     379                 :            :  * All IO bitmap related data stored in the TSS:
     380                 :            :  */
     381                 :            : struct x86_io_bitmap {
     382                 :            :         /* The sequence number of the last active bitmap. */
     383                 :            :         u64                     prev_sequence;
     384                 :            : 
     385                 :            :         /*
     386                 :            :          * Store the dirty size of the last io bitmap offender. The next
     387                 :            :          * one will have to do the cleanup as the switch out to a non io
     388                 :            :          * bitmap user will just set x86_tss.io_bitmap_base to a value
     389                 :            :          * outside of the TSS limit. So for sane tasks there is no need to
     390                 :            :          * actually touch the io_bitmap at all.
     391                 :            :          */
     392                 :            :         unsigned int            prev_max;
     393                 :            : 
     394                 :            :         /*
     395                 :            :          * The extra 1 is there because the CPU will access an
     396                 :            :          * additional byte beyond the end of the IO permission
     397                 :            :          * bitmap. The extra byte must be all 1 bits, and must
     398                 :            :          * be within the limit.
     399                 :            :          */
     400                 :            :         unsigned long           bitmap[IO_BITMAP_LONGS + 1];
     401                 :            : 
     402                 :            :         /*
     403                 :            :          * Special I/O bitmap to emulate IOPL(3). All bytes zero,
     404                 :            :          * except the additional byte at the end.
     405                 :            :          */
     406                 :            :         unsigned long           mapall[IO_BITMAP_LONGS + 1];
     407                 :            : };
     408                 :            : 
     409                 :            : struct tss_struct {
     410                 :            :         /*
     411                 :            :          * The fixed hardware portion.  This must not cross a page boundary
     412                 :            :          * at risk of violating the SDM's advice and potentially triggering
     413                 :            :          * errata.
     414                 :            :          */
     415                 :            :         struct x86_hw_tss       x86_tss;
     416                 :            : 
     417                 :            :         struct x86_io_bitmap    io_bitmap;
     418                 :            : } __aligned(PAGE_SIZE);
     419                 :            : 
     420                 :            : DECLARE_PER_CPU_PAGE_ALIGNED(struct tss_struct, cpu_tss_rw);
     421                 :            : 
     422                 :            : /* Per CPU interrupt stacks */
     423                 :            : struct irq_stack {
     424                 :            :         char            stack[IRQ_STACK_SIZE];
     425                 :            : } __aligned(IRQ_STACK_SIZE);
     426                 :            : 
     427                 :            : DECLARE_PER_CPU(struct irq_stack *, hardirq_stack_ptr);
     428                 :            : 
     429                 :            : #ifdef CONFIG_X86_32
     430                 :            : DECLARE_PER_CPU(unsigned long, cpu_current_top_of_stack);
     431                 :            : #else
     432                 :            : /* The RO copy can't be accessed with this_cpu_xyz(), so use the RW copy. */
     433                 :            : #define cpu_current_top_of_stack cpu_tss_rw.x86_tss.sp1
     434                 :            : #endif
     435                 :            : 
     436                 :            : #ifdef CONFIG_X86_64
     437                 :            : struct fixed_percpu_data {
     438                 :            :         /*
     439                 :            :          * GCC hardcodes the stack canary as %gs:40.  Since the
     440                 :            :          * irq_stack is the object at %gs:0, we reserve the bottom
     441                 :            :          * 48 bytes of the irq stack for the canary.
     442                 :            :          */
     443                 :            :         char            gs_base[40];
     444                 :            :         unsigned long   stack_canary;
     445                 :            : };
     446                 :            : 
     447                 :            : DECLARE_PER_CPU_FIRST(struct fixed_percpu_data, fixed_percpu_data) __visible;
     448                 :            : DECLARE_INIT_PER_CPU(fixed_percpu_data);
     449                 :            : 
     450                 :         90 : static inline unsigned long cpu_kernelmode_gs_base(int cpu)
     451                 :            : {
     452                 :         90 :         return (unsigned long)per_cpu(fixed_percpu_data.gs_base, cpu);
     453                 :            : }
     454                 :            : 
     455                 :            : DECLARE_PER_CPU(unsigned int, irq_count);
     456                 :            : extern asmlinkage void ignore_sysret(void);
     457                 :            : 
     458                 :            : #if IS_ENABLED(CONFIG_KVM)
     459                 :            : /* Save actual FS/GS selectors and bases to current->thread */
     460                 :            : void save_fsgs_for_kvm(void);
     461                 :            : #endif
     462                 :            : #else   /* X86_64 */
     463                 :            : #ifdef CONFIG_STACKPROTECTOR
     464                 :            : /*
     465                 :            :  * Make sure stack canary segment base is cached-aligned:
     466                 :            :  *   "For Intel Atom processors, avoid non zero segment base address
     467                 :            :  *    that is not aligned to cache line boundary at all cost."
     468                 :            :  * (Optim Ref Manual Assembly/Compiler Coding Rule 15.)
     469                 :            :  */
     470                 :            : struct stack_canary {
     471                 :            :         char __pad[20];         /* canary at %gs:20 */
     472                 :            :         unsigned long canary;
     473                 :            : };
     474                 :            : DECLARE_PER_CPU_ALIGNED(struct stack_canary, stack_canary);
     475                 :            : #endif
     476                 :            : /* Per CPU softirq stack pointer */
     477                 :            : DECLARE_PER_CPU(struct irq_stack *, softirq_stack_ptr);
     478                 :            : #endif  /* X86_64 */
     479                 :            : 
     480                 :            : extern unsigned int fpu_kernel_xstate_size;
     481                 :            : extern unsigned int fpu_user_xstate_size;
     482                 :            : 
     483                 :            : struct perf_event;
     484                 :            : 
     485                 :            : typedef struct {
     486                 :            :         unsigned long           seg;
     487                 :            : } mm_segment_t;
     488                 :            : 
     489                 :            : struct thread_struct {
     490                 :            :         /* Cached TLS descriptors: */
     491                 :            :         struct desc_struct      tls_array[GDT_ENTRY_TLS_ENTRIES];
     492                 :            : #ifdef CONFIG_X86_32
     493                 :            :         unsigned long           sp0;
     494                 :            : #endif
     495                 :            :         unsigned long           sp;
     496                 :            : #ifdef CONFIG_X86_32
     497                 :            :         unsigned long           sysenter_cs;
     498                 :            : #else
     499                 :            :         unsigned short          es;
     500                 :            :         unsigned short          ds;
     501                 :            :         unsigned short          fsindex;
     502                 :            :         unsigned short          gsindex;
     503                 :            : #endif
     504                 :            : 
     505                 :            : #ifdef CONFIG_X86_64
     506                 :            :         unsigned long           fsbase;
     507                 :            :         unsigned long           gsbase;
     508                 :            : #else
     509                 :            :         /*
     510                 :            :          * XXX: this could presumably be unsigned short.  Alternatively,
     511                 :            :          * 32-bit kernels could be taught to use fsindex instead.
     512                 :            :          */
     513                 :            :         unsigned long fs;
     514                 :            :         unsigned long gs;
     515                 :            : #endif
     516                 :            : 
     517                 :            :         /* Save middle states of ptrace breakpoints */
     518                 :            :         struct perf_event       *ptrace_bps[HBP_NUM];
     519                 :            :         /* Debug status used for traps, single steps, etc... */
     520                 :            :         unsigned long           debugreg6;
     521                 :            :         /* Keep track of the exact dr7 value set by the user */
     522                 :            :         unsigned long           ptrace_dr7;
     523                 :            :         /* Fault info: */
     524                 :            :         unsigned long           cr2;
     525                 :            :         unsigned long           trap_nr;
     526                 :            :         unsigned long           error_code;
     527                 :            : #ifdef CONFIG_VM86
     528                 :            :         /* Virtual 86 mode info */
     529                 :            :         struct vm86             *vm86;
     530                 :            : #endif
     531                 :            :         /* IO permissions: */
     532                 :            :         struct io_bitmap        *io_bitmap;
     533                 :            : 
     534                 :            :         /*
     535                 :            :          * IOPL. Priviledge level dependent I/O permission which is
     536                 :            :          * emulated via the I/O bitmap to prevent user space from disabling
     537                 :            :          * interrupts.
     538                 :            :          */
     539                 :            :         unsigned long           iopl_emul;
     540                 :            : 
     541                 :            :         mm_segment_t            addr_limit;
     542                 :            : 
     543                 :            :         unsigned int            sig_on_uaccess_err:1;
     544                 :            :         unsigned int            uaccess_err:1;  /* uaccess failed */
     545                 :            : 
     546                 :            :         /* Floating point and extended processor state */
     547                 :            :         struct fpu              fpu;
     548                 :            :         /*
     549                 :            :          * WARNING: 'fpu' is dynamically-sized.  It *MUST* be at
     550                 :            :          * the end.
     551                 :            :          */
     552                 :            : };
     553                 :            : 
     554                 :            : /* Whitelist the FPU state from the task_struct for hardened usercopy. */
     555                 :         30 : static inline void arch_thread_struct_whitelist(unsigned long *offset,
     556                 :            :                                                 unsigned long *size)
     557                 :            : {
     558                 :         30 :         *offset = offsetof(struct thread_struct, fpu.state);
     559         [ +  - ]:         30 :         *size = fpu_kernel_xstate_size;
     560                 :            : }
     561                 :            : 
     562                 :            : /*
     563                 :            :  * Thread-synchronous status.
     564                 :            :  *
     565                 :            :  * This is different from the flags in that nobody else
     566                 :            :  * ever touches our thread-synchronous status, so we don't
     567                 :            :  * have to worry about atomic accesses.
     568                 :            :  */
     569                 :            : #define TS_COMPAT               0x0002  /* 32bit syscall active (64BIT)*/
     570                 :            : 
     571                 :            : static inline void
     572                 :         30 : native_load_sp0(unsigned long sp0)
     573                 :            : {
     574                 :         30 :         this_cpu_write(cpu_tss_rw.x86_tss.sp0, sp0);
     575                 :            : }
     576                 :            : 
     577                 :            : static inline void native_swapgs(void)
     578                 :            : {
     579                 :            : #ifdef CONFIG_X86_64
     580                 :            :         asm volatile("swapgs" ::: "memory");
     581                 :            : #endif
     582                 :            : }
     583                 :            : 
     584                 :          0 : static inline unsigned long current_top_of_stack(void)
     585                 :            : {
     586                 :            :         /*
     587                 :            :          *  We can't read directly from tss.sp0: sp0 on x86_32 is special in
     588                 :            :          *  and around vm86 mode and sp0 on x86_64 is special because of the
     589                 :            :          *  entry trampoline.
     590                 :            :          */
     591                 :          0 :         return this_cpu_read_stable(cpu_current_top_of_stack);
     592                 :            : }
     593                 :            : 
     594                 :          0 : static inline bool on_thread_stack(void)
     595                 :            : {
     596         [ #  # ]:          0 :         return (unsigned long)(current_top_of_stack() -
     597                 :            :                                current_stack_pointer) < THREAD_SIZE;
     598                 :            : }
     599                 :            : 
     600                 :            : #ifdef CONFIG_PARAVIRT_XXL
     601                 :            : #include <asm/paravirt.h>
     602                 :            : #else
     603                 :            : #define __cpuid                 native_cpuid
     604                 :            : 
     605                 :         30 : static inline void load_sp0(unsigned long sp0)
     606                 :            : {
     607                 :         30 :         native_load_sp0(sp0);
     608                 :          0 : }
     609                 :            : 
     610                 :            : #endif /* CONFIG_PARAVIRT_XXL */
     611                 :            : 
     612                 :            : /* Free all resources held by a thread. */
     613                 :            : extern void release_thread(struct task_struct *);
     614                 :            : 
     615                 :            : unsigned long get_wchan(struct task_struct *p);
     616                 :            : 
     617                 :            : /*
     618                 :            :  * Generic CPUID function
     619                 :            :  * clear %ecx since some cpus (Cyrix MII) do not set or clear %ecx
     620                 :            :  * resulting in stale register contents being returned.
     621                 :            :  */
     622                 :       2790 : static inline void cpuid(unsigned int op,
     623                 :            :                          unsigned int *eax, unsigned int *ebx,
     624                 :            :                          unsigned int *ecx, unsigned int *edx)
     625                 :            : {
     626                 :       2790 :         *eax = op;
     627                 :       2790 :         *ecx = 0;
     628                 :       2310 :         __cpuid(eax, ebx, ecx, edx);
     629                 :            : }
     630                 :            : 
     631                 :            : /* Some CPUID calls want 'count' to be placed in ecx */
     632                 :        480 : static inline void cpuid_count(unsigned int op, int count,
     633                 :            :                                unsigned int *eax, unsigned int *ebx,
     634                 :            :                                unsigned int *ecx, unsigned int *edx)
     635                 :            : {
     636                 :        480 :         *eax = op;
     637                 :        480 :         *ecx = count;
     638                 :        480 :         __cpuid(eax, ebx, ecx, edx);
     639                 :          0 : }
     640                 :            : 
     641                 :            : /*
     642                 :            :  * CPUID functions returning a single datum
     643                 :            :  */
     644                 :       1650 : static inline unsigned int cpuid_eax(unsigned int op)
     645                 :            : {
     646                 :       1650 :         unsigned int eax, ebx, ecx, edx;
     647                 :            : 
     648                 :       1650 :         cpuid(op, &eax, &ebx, &ecx, &edx);
     649                 :            : 
     650   [ +  +  -  +  :       1530 :         return eax;
          +  -  +  -  +  
          -  -  -  -  +  
          -  -  -  +  -  
          -  -  -  +  -  
          -  +  +  -  +  
                      - ]
     651                 :            : }
     652                 :            : 
     653                 :         30 : static inline unsigned int cpuid_ebx(unsigned int op)
     654                 :            : {
     655                 :         30 :         unsigned int eax, ebx, ecx, edx;
     656                 :            : 
     657                 :         30 :         cpuid(op, &eax, &ebx, &ecx, &edx);
     658                 :            : 
     659                 :         30 :         return ebx;
     660                 :            : }
     661                 :            : 
     662                 :         60 : static inline unsigned int cpuid_ecx(unsigned int op)
     663                 :            : {
     664                 :         60 :         unsigned int eax, ebx, ecx, edx;
     665                 :            : 
     666                 :         60 :         cpuid(op, &eax, &ebx, &ecx, &edx);
     667                 :            : 
     668   [ -  -  -  -  :         60 :         return ecx;
                   +  - ]
     669                 :            : }
     670                 :            : 
     671                 :        150 : static inline unsigned int cpuid_edx(unsigned int op)
     672                 :            : {
     673                 :        150 :         unsigned int eax, ebx, ecx, edx;
     674                 :            : 
     675                 :        150 :         cpuid(op, &eax, &ebx, &ecx, &edx);
     676                 :            : 
     677   [ +  +  -  -  :        120 :         return edx;
                   -  - ]
     678                 :            : }
     679                 :            : 
     680                 :            : /* REP NOP (PAUSE) is a good thing to insert into busy-wait loops. */
     681                 :  136706849 : static __always_inline void rep_nop(void)
     682                 :            : {
     683                 :  136706849 :         asm volatile("rep; nop" ::: "memory");
     684                 :            : }
     685                 :            : 
     686                 :   94782776 : static __always_inline void cpu_relax(void)
     687                 :            : {
     688                 :   94782776 :         rep_nop();
     689                 :   94782536 : }
     690                 :            : 
     691                 :            : /*
     692                 :            :  * This function forces the icache and prefetched instruction stream to
     693                 :            :  * catch up with reality in two very specific cases:
     694                 :            :  *
     695                 :            :  *  a) Text was modified using one virtual address and is about to be executed
     696                 :            :  *     from the same physical page at a different virtual address.
     697                 :            :  *
     698                 :            :  *  b) Text was modified on a different CPU, may subsequently be
     699                 :            :  *     executed on this CPU, and you want to make sure the new version
     700                 :            :  *     gets executed.  This generally means you're calling this in a IPI.
     701                 :            :  *
     702                 :            :  * If you're calling this for a different reason, you're probably doing
     703                 :            :  * it wrong.
     704                 :            :  */
     705                 :     106740 : static inline void sync_core(void)
     706                 :            : {
     707                 :            :         /*
     708                 :            :          * There are quite a few ways to do this.  IRET-to-self is nice
     709                 :            :          * because it works on every CPU, at any CPL (so it's compatible
     710                 :            :          * with paravirtualization), and it never exits to a hypervisor.
     711                 :            :          * The only down sides are that it's a bit slow (it seems to be
     712                 :            :          * a bit more than 2x slower than the fastest options) and that
     713                 :            :          * it unmasks NMIs.  The "push %cs" is needed because, in
     714                 :            :          * paravirtual environments, __KERNEL_CS may not be a valid CS
     715                 :            :          * value when we do IRET directly.
     716                 :            :          *
     717                 :            :          * In case NMI unmasking or performance ever becomes a problem,
     718                 :            :          * the next best option appears to be MOV-to-CR2 and an
     719                 :            :          * unconditional jump.  That sequence also works on all CPUs,
     720                 :            :          * but it will fault at CPL3 (i.e. Xen PV).
     721                 :            :          *
     722                 :            :          * CPUID is the conventional way, but it's nasty: it doesn't
     723                 :            :          * exist on some 486-like CPUs, and it usually exits to a
     724                 :            :          * hypervisor.
     725                 :            :          *
     726                 :            :          * Like all of Linux's memory ordering operations, this is a
     727                 :            :          * compiler barrier as well.
     728                 :            :          */
     729                 :            : #ifdef CONFIG_X86_32
     730                 :            :         asm volatile (
     731                 :            :                 "pushfl\n\t"
     732                 :            :                 "pushl %%cs\n\t"
     733                 :            :                 "pushl $1f\n\t"
     734                 :            :                 "iret\n\t"
     735                 :            :                 "1:"
     736                 :            :                 : ASM_CALL_CONSTRAINT : : "memory");
     737                 :            : #else
     738                 :     106740 :         unsigned int tmp;
     739                 :            : 
     740                 :     106740 :         asm volatile (
     741                 :            :                 UNWIND_HINT_SAVE
     742                 :            :                 "mov %%ss, %0\n\t"
     743                 :            :                 "pushq %q0\n\t"
     744                 :            :                 "pushq %%rsp\n\t"
     745                 :            :                 "addq $8, (%%rsp)\n\t"
     746                 :            :                 "pushfq\n\t"
     747                 :            :                 "mov %%cs, %0\n\t"
     748                 :            :                 "pushq %q0\n\t"
     749                 :            :                 "pushq $1f\n\t"
     750                 :            :                 "iretq\n\t"
     751                 :            :                 UNWIND_HINT_RESTORE
     752                 :            :                 "1:"
     753                 :            :                 : "=&r" (tmp), ASM_CALL_CONSTRAINT : : "cc", "memory");
     754                 :            : #endif
     755                 :     106740 : }
     756                 :            : 
     757                 :            : extern void select_idle_routine(const struct cpuinfo_x86 *c);
     758                 :            : extern void amd_e400_c1e_apic_setup(void);
     759                 :            : 
     760                 :            : extern unsigned long            boot_option_idle_override;
     761                 :            : 
     762                 :            : enum idle_boot_override {IDLE_NO_OVERRIDE=0, IDLE_HALT, IDLE_NOMWAIT,
     763                 :            :                          IDLE_POLL};
     764                 :            : 
     765                 :            : extern void enable_sep_cpu(void);
     766                 :            : extern int sysenter_setup(void);
     767                 :            : 
     768                 :            : 
     769                 :            : /* Defined in head.S */
     770                 :            : extern struct desc_ptr          early_gdt_descr;
     771                 :            : 
     772                 :            : extern void switch_to_new_gdt(int);
     773                 :            : extern void load_direct_gdt(int);
     774                 :            : extern void load_fixmap_gdt(int);
     775                 :            : extern void load_percpu_segment(int);
     776                 :            : extern void cpu_init(void);
     777                 :            : extern void cr4_init(void);
     778                 :            : 
     779                 :          0 : static inline unsigned long get_debugctlmsr(void)
     780                 :            : {
     781                 :          0 :         unsigned long debugctlmsr = 0;
     782                 :            : 
     783                 :            : #ifndef CONFIG_X86_DEBUGCTLMSR
     784                 :            :         if (boot_cpu_data.x86 < 6)
     785                 :            :                 return 0;
     786                 :            : #endif
     787                 :          0 :         rdmsrl(MSR_IA32_DEBUGCTLMSR, debugctlmsr);
     788                 :            : 
     789         [ #  # ]:          0 :         return debugctlmsr;
     790                 :            : }
     791                 :            : 
     792                 :          0 : static inline void update_debugctlmsr(unsigned long debugctlmsr)
     793                 :            : {
     794                 :            : #ifndef CONFIG_X86_DEBUGCTLMSR
     795                 :            :         if (boot_cpu_data.x86 < 6)
     796                 :            :                 return;
     797                 :            : #endif
     798                 :          0 :         wrmsrl(MSR_IA32_DEBUGCTLMSR, debugctlmsr);
     799                 :          0 : }
     800                 :            : 
     801                 :            : extern void set_task_blockstep(struct task_struct *task, bool on);
     802                 :            : 
     803                 :            : /* Boot loader type from the setup header: */
     804                 :            : extern int                      bootloader_type;
     805                 :            : extern int                      bootloader_version;
     806                 :            : 
     807                 :            : extern char                     ignore_fpu_irq;
     808                 :            : 
     809                 :            : #define HAVE_ARCH_PICK_MMAP_LAYOUT 1
     810                 :            : #define ARCH_HAS_PREFETCHW
     811                 :            : #define ARCH_HAS_SPINLOCK_PREFETCH
     812                 :            : 
     813                 :            : #ifdef CONFIG_X86_32
     814                 :            : # define BASE_PREFETCH          ""
     815                 :            : # define ARCH_HAS_PREFETCH
     816                 :            : #else
     817                 :            : # define BASE_PREFETCH          "prefetcht0 %P1"
     818                 :            : #endif
     819                 :            : 
     820                 :            : /*
     821                 :            :  * Prefetch instructions for Pentium III (+) and AMD Athlon (+)
     822                 :            :  *
     823                 :            :  * It's not worth to care about 3dnow prefetches for the K6
     824                 :            :  * because they are microcoded there and very slow.
     825                 :            :  */
     826                 :            : static inline void prefetch(const void *x)
     827                 :            : {
     828                 :            :         alternative_input(BASE_PREFETCH, "prefetchnta %P1",
     829                 :            :                           X86_FEATURE_XMM,
     830                 :            :                           "m" (*(const char *)x));
     831                 :            : }
     832                 :            : 
     833                 :            : /*
     834                 :            :  * 3dnow prefetch to get an exclusive cache line.
     835                 :            :  * Useful for spinlocks to avoid one state transition in the
     836                 :            :  * cache coherency protocol:
     837                 :            :  */
     838                 :   22142553 : static inline void prefetchw(const void *x)
     839                 :            : {
     840                 :   22142553 :         alternative_input(BASE_PREFETCH, "prefetchw %P1",
     841                 :            :                           X86_FEATURE_3DNOWPREFETCH,
     842                 :            :                           "m" (*(const char *)x));
     843                 :          0 : }
     844                 :            : 
     845                 :     501181 : static inline void spin_lock_prefetch(const void *x)
     846                 :            : {
     847                 :     501181 :         prefetchw(x);
     848                 :            : }
     849                 :            : 
     850                 :            : #define TOP_OF_INIT_STACK ((unsigned long)&init_stack + sizeof(init_stack) - \
     851                 :            :                            TOP_OF_KERNEL_STACK_PADDING)
     852                 :            : 
     853                 :            : #define task_top_of_stack(task) ((unsigned long)(task_pt_regs(task) + 1))
     854                 :            : 
     855                 :            : #define task_pt_regs(task) \
     856                 :            : ({                                                                      \
     857                 :            :         unsigned long __ptr = (unsigned long)task_stack_page(task);     \
     858                 :            :         __ptr += THREAD_SIZE - TOP_OF_KERNEL_STACK_PADDING;             \
     859                 :            :         ((struct pt_regs *)__ptr) - 1;                                  \
     860                 :            : })
     861                 :            : 
     862                 :            : #ifdef CONFIG_X86_32
     863                 :            : /*
     864                 :            :  * User space process size: 3GB (default).
     865                 :            :  */
     866                 :            : #define IA32_PAGE_OFFSET        PAGE_OFFSET
     867                 :            : #define TASK_SIZE               PAGE_OFFSET
     868                 :            : #define TASK_SIZE_LOW           TASK_SIZE
     869                 :            : #define TASK_SIZE_MAX           TASK_SIZE
     870                 :            : #define DEFAULT_MAP_WINDOW      TASK_SIZE
     871                 :            : #define STACK_TOP               TASK_SIZE
     872                 :            : #define STACK_TOP_MAX           STACK_TOP
     873                 :            : 
     874                 :            : #define INIT_THREAD  {                                                    \
     875                 :            :         .sp0                    = TOP_OF_INIT_STACK,                      \
     876                 :            :         .sysenter_cs            = __KERNEL_CS,                            \
     877                 :            :         .addr_limit             = KERNEL_DS,                              \
     878                 :            : }
     879                 :            : 
     880                 :            : #define KSTK_ESP(task)          (task_pt_regs(task)->sp)
     881                 :            : 
     882                 :            : #else
     883                 :            : /*
     884                 :            :  * User space process size.  This is the first address outside the user range.
     885                 :            :  * There are a few constraints that determine this:
     886                 :            :  *
     887                 :            :  * On Intel CPUs, if a SYSCALL instruction is at the highest canonical
     888                 :            :  * address, then that syscall will enter the kernel with a
     889                 :            :  * non-canonical return address, and SYSRET will explode dangerously.
     890                 :            :  * We avoid this particular problem by preventing anything executable
     891                 :            :  * from being mapped at the maximum canonical address.
     892                 :            :  *
     893                 :            :  * On AMD CPUs in the Ryzen family, there's a nasty bug in which the
     894                 :            :  * CPUs malfunction if they execute code from the highest canonical page.
     895                 :            :  * They'll speculate right off the end of the canonical space, and
     896                 :            :  * bad things happen.  This is worked around in the same way as the
     897                 :            :  * Intel problem.
     898                 :            :  *
     899                 :            :  * With page table isolation enabled, we map the LDT in ... [stay tuned]
     900                 :            :  */
     901                 :            : #define TASK_SIZE_MAX   ((1UL << __VIRTUAL_MASK_SHIFT) - PAGE_SIZE)
     902                 :            : 
     903                 :            : #define DEFAULT_MAP_WINDOW      ((1UL << 47) - PAGE_SIZE)
     904                 :            : 
     905                 :            : /* This decides where the kernel will search for a free chunk of vm
     906                 :            :  * space during mmap's.
     907                 :            :  */
     908                 :            : #define IA32_PAGE_OFFSET        ((current->personality & ADDR_LIMIT_3GB) ? \
     909                 :            :                                         0xc0000000 : 0xFFFFe000)
     910                 :            : 
     911                 :            : #define TASK_SIZE_LOW           (test_thread_flag(TIF_ADDR32) ? \
     912                 :            :                                         IA32_PAGE_OFFSET : DEFAULT_MAP_WINDOW)
     913                 :            : #define TASK_SIZE               (test_thread_flag(TIF_ADDR32) ? \
     914                 :            :                                         IA32_PAGE_OFFSET : TASK_SIZE_MAX)
     915                 :            : #define TASK_SIZE_OF(child)     ((test_tsk_thread_flag(child, TIF_ADDR32)) ? \
     916                 :            :                                         IA32_PAGE_OFFSET : TASK_SIZE_MAX)
     917                 :            : 
     918                 :            : #define STACK_TOP               TASK_SIZE_LOW
     919                 :            : #define STACK_TOP_MAX           TASK_SIZE_MAX
     920                 :            : 
     921                 :            : #define INIT_THREAD  {                                          \
     922                 :            :         .addr_limit             = KERNEL_DS,                    \
     923                 :            : }
     924                 :            : 
     925                 :            : extern unsigned long KSTK_ESP(struct task_struct *task);
     926                 :            : 
     927                 :            : #endif /* CONFIG_X86_64 */
     928                 :            : 
     929                 :            : extern void start_thread(struct pt_regs *regs, unsigned long new_ip,
     930                 :            :                                                unsigned long new_sp);
     931                 :            : 
     932                 :            : /*
     933                 :            :  * This decides where the kernel will search for a free chunk of vm
     934                 :            :  * space during mmap's.
     935                 :            :  */
     936                 :            : #define __TASK_UNMAPPED_BASE(task_size) (PAGE_ALIGN(task_size / 3))
     937                 :            : #define TASK_UNMAPPED_BASE              __TASK_UNMAPPED_BASE(TASK_SIZE_LOW)
     938                 :            : 
     939                 :            : #define KSTK_EIP(task)          (task_pt_regs(task)->ip)
     940                 :            : 
     941                 :            : /* Get/set a process' ability to use the timestamp counter instruction */
     942                 :            : #define GET_TSC_CTL(adr)        get_tsc_mode((adr))
     943                 :            : #define SET_TSC_CTL(val)        set_tsc_mode((val))
     944                 :            : 
     945                 :            : extern int get_tsc_mode(unsigned long adr);
     946                 :            : extern int set_tsc_mode(unsigned int val);
     947                 :            : 
     948                 :            : DECLARE_PER_CPU(u64, msr_misc_features_shadow);
     949                 :            : 
     950                 :            : #ifdef CONFIG_CPU_SUP_AMD
     951                 :            : extern u16 amd_get_nb_id(int cpu);
     952                 :            : extern u32 amd_get_nodes_per_socket(void);
     953                 :            : #else
     954                 :            : static inline u16 amd_get_nb_id(int cpu)                { return 0; }
     955                 :            : static inline u32 amd_get_nodes_per_socket(void)        { return 0; }
     956                 :            : #endif
     957                 :            : 
     958                 :         30 : static inline uint32_t hypervisor_cpuid_base(const char *sig, uint32_t leaves)
     959                 :            : {
     960                 :         30 :         uint32_t base, eax, signature[3];
     961                 :            : 
     962         [ +  - ]:         30 :         for (base = 0x40000000; base < 0x40010000; base += 0x100) {
     963                 :         30 :                 cpuid(base, &eax, &signature[0], &signature[1], &signature[2]);
     964                 :            : 
     965   [ +  -  -  + ]:         30 :                 if (!memcmp(sig, signature, 12) &&
     966         [ #  # ]:          0 :                     (leaves == 0 || ((eax - base) >= leaves)))
     967                 :         30 :                         return base;
     968                 :            :         }
     969                 :            : 
     970                 :            :         return 0;
     971                 :            : }
     972                 :            : 
     973                 :            : extern unsigned long arch_align_stack(unsigned long sp);
     974                 :            : void free_init_pages(const char *what, unsigned long begin, unsigned long end);
     975                 :            : extern void free_kernel_image_pages(const char *what, void *begin, void *end);
     976                 :            : 
     977                 :            : void default_idle(void);
     978                 :            : #ifdef  CONFIG_XEN
     979                 :            : bool xen_set_default_idle(void);
     980                 :            : #else
     981                 :            : #define xen_set_default_idle 0
     982                 :            : #endif
     983                 :            : 
     984                 :            : void stop_this_cpu(void *dummy);
     985                 :            : void microcode_check(void);
     986                 :            : 
     987                 :            : enum l1tf_mitigations {
     988                 :            :         L1TF_MITIGATION_OFF,
     989                 :            :         L1TF_MITIGATION_FLUSH_NOWARN,
     990                 :            :         L1TF_MITIGATION_FLUSH,
     991                 :            :         L1TF_MITIGATION_FLUSH_NOSMT,
     992                 :            :         L1TF_MITIGATION_FULL,
     993                 :            :         L1TF_MITIGATION_FULL_FORCE
     994                 :            : };
     995                 :            : 
     996                 :            : extern enum l1tf_mitigations l1tf_mitigation;
     997                 :            : 
     998                 :            : enum mds_mitigations {
     999                 :            :         MDS_MITIGATION_OFF,
    1000                 :            :         MDS_MITIGATION_FULL,
    1001                 :            :         MDS_MITIGATION_VMWERV,
    1002                 :            : };
    1003                 :            : 
    1004                 :            : #endif /* _ASM_X86_PROCESSOR_H */

Generated by: LCOV version 1.14