arch/x86/include/asm/entry-common.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 #ifndef _ASM_X86_ENTRY_COMMON_H
   3 #define _ASM_X86_ENTRY_COMMON_H
   4
   5 #include <linux/randomize_kstack.h>
   6 #include <linux/user-return-notifier.h>
   7
   8 #include <asm/nospec-branch.h>
   9 #include <asm/io_bitmap.h>
  10 #include <asm/fpu/api.h>
  11 #include <asm/fred.h>
  12
  13 /* Check that the stack and regs on entry from user mode are sane. */
  14 static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs)
  15 {
  16         if (IS_ENABLED(CONFIG_DEBUG_ENTRY)) {
  17                 /*
  18                  * Make sure that the entry code gave us a sensible EFLAGS
  19                  * register.  Native because we want to check the actual CPU
  20                  * state, not the interrupt state as imagined by Xen.
  21                  */
  22                 unsigned long flags = native_save_fl();
  23                 unsigned long mask = X86_EFLAGS_DF | X86_EFLAGS_NT;
  24
  25                 /*
  26                  * For !SMAP hardware we patch out CLAC on entry.
  27                  */
  28                 if (cpu_feature_enabled(X86_FEATURE_SMAP) ||
  29                     cpu_feature_enabled(X86_FEATURE_XENPV))
  30                         mask |= X86_EFLAGS_AC;
  31
  32                 WARN_ON_ONCE(flags & mask);
  33
  34                 /* We think we came from user mode. Make sure pt_regs agrees. */
  35                 WARN_ON_ONCE(!user_mode(regs));
  36
  37                 /*
  38                  * All entries from user mode (except #DF) should be on the
  39                  * normal thread stack and should have user pt_regs in the
  40                  * correct location.
  41                  */
  42                 WARN_ON_ONCE(!on_thread_stack());
  43                 WARN_ON_ONCE(regs != task_pt_regs(current));
  44         }
  45 }
  46 #define arch_enter_from_user_mode arch_enter_from_user_mode
  47
  48 static inline void arch_exit_work(unsigned long ti_work)
  49 {
  50         if (ti_work & _TIF_USER_RETURN_NOTIFY)
  51                 fire_user_return_notifiers();
  52
  53         if (unlikely(ti_work & _TIF_IO_BITMAP))
  54                 tss_update_io_bitmap();
  55
  56         fpregs_assert_state_consistent();
  57         if (unlikely(ti_work & _TIF_NEED_FPU_LOAD))
  58                 switch_fpu_return();
  59 }
  60
  61 static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,
  62                                                   unsigned long ti_work)
  63 {
  64         if (IS_ENABLED(CONFIG_X86_DEBUG_FPU) || unlikely(ti_work))
  65                 arch_exit_work(ti_work);
  66
  67         fred_update_rsp0();
  68
  69 #ifdef CONFIG_COMPAT
  70         /*
  71          * Compat syscalls set TS_COMPAT.  Make sure we clear it before
  72          * returning to user mode.  We need to clear it *after* signal
  73          * handling, because syscall restart has a fixup for compat
  74          * syscalls.  The fixup is exercised by the ptrace_syscall_32
  75          * selftest.
  76          *
  77          * We also need to clear TS_REGS_POKED_I386: the 32-bit tracer
  78          * special case only applies after poking regs and before the
  79          * very next return to user mode.
  80          */
  81         current_thread_info()->status &= ~(TS_COMPAT | TS_I386_REGS_POKED);
  82 #endif
  83
  84         /*
  85          * This value will get limited by KSTACK_OFFSET_MAX(), which is 10
  86          * bits. The actual entropy will be further reduced by the compiler
  87          * when applying stack alignment constraints (see cc_stack_align4/8 in
  88          * arch/x86/Makefile), which will remove the 3 (x86_64) or 2 (ia32)
  89          * low bits from any entropy chosen here.
  90          *
  91          * Therefore, final stack offset entropy will be 7 (x86_64) or
  92          * 8 (ia32) bits.
  93          */
  94         choose_random_kstack_offset(rdtsc());
  95 }
  96 #define arch_exit_to_user_mode_prepare arch_exit_to_user_mode_prepare
  97
  98 static __always_inline void arch_exit_to_user_mode(void)
  99 {
 100         amd_clear_divider();
 101 }
 102 #define arch_exit_to_user_mode arch_exit_to_user_mode
 103
 104 #endif