arch/x86/entry/common.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * common.c - C code for kernel entry and exit
   4  * Copyright (c) 2015 Andrew Lutomirski
   5  *
   6  * Based on asm and ptrace code by many authors.  The code here originated
   7  * in ptrace.c and signal.c.
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/sched.h>
  12 #include <linux/sched/task_stack.h>
  13 #include <linux/entry-common.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/errno.h>
  17 #include <linux/ptrace.h>
  18 #include <linux/export.h>
  19 #include <linux/nospec.h>
  20 #include <linux/syscalls.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/init.h>
  23
  24 #ifdef CONFIG_XEN_PV
  25 #include <xen/xen-ops.h>
  26 #include <xen/events.h>
  27 #endif
  28
  29 #include <asm/apic.h>
  30 #include <asm/desc.h>
  31 #include <asm/traps.h>
  32 #include <asm/vdso.h>
  33 #include <asm/cpufeature.h>
  34 #include <asm/fpu/api.h>
  35 #include <asm/nospec-branch.h>
  36 #include <asm/io_bitmap.h>
  37 #include <asm/syscall.h>
  38 #include <asm/irq_stack.h>
  39
  40 #ifdef CONFIG_X86_64
  41
  42 static __always_inline bool do_syscall_x64(struct pt_regs *regs, int nr)
  43 {
  44         /*
  45          * Convert negative numbers to very high and thus out of range
  46          * numbers for comparisons.
  47          */
  48         unsigned int unr = nr;
  49
  50         if (likely(unr < NR_syscalls)) {
  51                 unr = array_index_nospec(unr, NR_syscalls);
  52                 regs->ax = x64_sys_call(regs, unr);
  53                 return true;
  54         }
  55         return false;
  56 }
  57
  58 static __always_inline bool do_syscall_x32(struct pt_regs *regs, int nr)
  59 {
  60         /*
  61          * Adjust the starting offset of the table, and convert numbers
  62          * < __X32_SYSCALL_BIT to very high and thus out of range
  63          * numbers for comparisons.
  64          */
  65         unsigned int xnr = nr - __X32_SYSCALL_BIT;
  66
  67         if (IS_ENABLED(CONFIG_X86_X32_ABI) && likely(xnr < X32_NR_syscalls)) {
  68                 xnr = array_index_nospec(xnr, X32_NR_syscalls);
  69                 regs->ax = x32_sys_call(regs, xnr);
  70                 return true;
  71         }
  72         return false;
  73 }
  74
  75 /* Returns true to return using SYSRET, or false to use IRET */
  76 __visible noinstr bool do_syscall_64(struct pt_regs *regs, int nr)
  77 {
  78         add_random_kstack_offset();
  79         nr = syscall_enter_from_user_mode(regs, nr);
  80
  81         instrumentation_begin();
  82
  83         if (!do_syscall_x64(regs, nr) && !do_syscall_x32(regs, nr) && nr != -1) {
  84                 /* Invalid system call, but still a system call. */
  85                 regs->ax = __x64_sys_ni_syscall(regs);
  86         }
  87
  88         instrumentation_end();
  89         syscall_exit_to_user_mode(regs);
  90
  91         /*
  92          * Check that the register state is valid for using SYSRET to exit
  93          * to userspace.  Otherwise use the slower but fully capable IRET
  94          * exit path.
  95          */
  96
  97         /* XEN PV guests always use the IRET path */
  98         if (cpu_feature_enabled(X86_FEATURE_XENPV))
  99                 return false;
 100
 101         /* SYSRET requires RCX == RIP and R11 == EFLAGS */
 102         if (unlikely(regs->cx != regs->ip || regs->r11 != regs->flags))
 103                 return false;
 104
 105         /* CS and SS must match the values set in MSR_STAR */
 106         if (unlikely(regs->cs != __USER_CS || regs->ss != __USER_DS))
 107                 return false;
 108
 109         /*
 110          * On Intel CPUs, SYSRET with non-canonical RCX/RIP will #GP
 111          * in kernel space.  This essentially lets the user take over
 112          * the kernel, since userspace controls RSP.
 113          *
 114          * TASK_SIZE_MAX covers all user-accessible addresses other than
 115          * the deprecated vsyscall page.
 116          */
 117         if (unlikely(regs->ip >= TASK_SIZE_MAX))
 118                 return false;
 119
 120         /*
 121          * SYSRET cannot restore RF.  It can restore TF, but unlike IRET,
 122          * restoring TF results in a trap from userspace immediately after
 123          * SYSRET.
 124          */
 125         if (unlikely(regs->flags & (X86_EFLAGS_RF | X86_EFLAGS_TF)))
 126                 return false;
 127
 128         /* Use SYSRET to exit to userspace */
 129         return true;
 130 }
 131 #endif
 132
 133 #if defined(CONFIG_X86_32) || defined(CONFIG_IA32_EMULATION)
 134 static __always_inline int syscall_32_enter(struct pt_regs *regs)
 135 {
 136         if (IS_ENABLED(CONFIG_IA32_EMULATION))
 137                 current_thread_info()->status |= TS_COMPAT;
 138
 139         return (int)regs->orig_ax;
 140 }
 141
 142 #ifdef CONFIG_IA32_EMULATION
 143 bool __ia32_enabled __ro_after_init = !IS_ENABLED(CONFIG_IA32_EMULATION_DEFAULT_DISABLED);
 144
 145 static int ia32_emulation_override_cmdline(char *arg)
 146 {
 147         return kstrtobool(arg, &__ia32_enabled);
 148 }
 149 early_param("ia32_emulation", ia32_emulation_override_cmdline);
 150 #endif
 151
 152 /*
 153  * Invoke a 32-bit syscall.  Called with IRQs on in CONTEXT_KERNEL.
 154  */
 155 static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs, int nr)
 156 {
 157         /*
 158          * Convert negative numbers to very high and thus out of range
 159          * numbers for comparisons.
 160          */
 161         unsigned int unr = nr;
 162
 163         if (likely(unr < IA32_NR_syscalls)) {
 164                 unr = array_index_nospec(unr, IA32_NR_syscalls);
 165                 regs->ax = ia32_sys_call(regs, unr);
 166         } else if (nr != -1) {
 167                 regs->ax = __ia32_sys_ni_syscall(regs);
 168         }
 169 }
 170
 171 #ifdef CONFIG_IA32_EMULATION
 172 static __always_inline bool int80_is_external(void)
 173 {
 174         const unsigned int offs = (0x80 / 32) * 0x10;
 175         const u32 bit = BIT(0x80 % 32);
 176
 177         /* The local APIC on XENPV guests is fake */
 178         if (cpu_feature_enabled(X86_FEATURE_XENPV))
 179                 return false;
 180
 181         /*
 182          * If vector 0x80 is set in the APIC ISR then this is an external
 183          * interrupt. Either from broken hardware or injected by a VMM.
 184          *
 185          * Note: In guest mode this is only valid for secure guests where
 186          * the secure module fully controls the vAPIC exposed to the guest.
 187          */
 188         return apic_read(APIC_ISR + offs) & bit;
 189 }
 190
 191 /**
 192  * do_int80_emulation - 32-bit legacy syscall C entry from asm
 193  *
 194  * This entry point can be used by 32-bit and 64-bit programs to perform
 195  * 32-bit system calls.  Instances of INT $0x80 can be found inline in
 196  * various programs and libraries.  It is also used by the vDSO's
 197  * __kernel_vsyscall fallback for hardware that doesn't support a faster
 198  * entry method.  Restarted 32-bit system calls also fall back to INT
 199  * $0x80 regardless of what instruction was originally used to do the
 200  * system call.
 201  *
 202  * This is considered a slow path.  It is not used by most libc
 203  * implementations on modern hardware except during process startup.
 204  *
 205  * The arguments for the INT $0x80 based syscall are on stack in the
 206  * pt_regs structure:
 207  *   eax:                               system call number
 208  *   ebx, ecx, edx, esi, edi, ebp:      arg1 - arg 6
 209  */
 210 __visible noinstr void do_int80_emulation(struct pt_regs *regs)
 211 {
 212         int nr;
 213
 214         /* Kernel does not use INT $0x80! */
 215         if (unlikely(!user_mode(regs))) {
 216                 irqentry_enter(regs);
 217                 instrumentation_begin();
 218                 panic("Unexpected external interrupt 0x80\n");
 219         }
 220
 221         /*
 222          * Establish kernel context for instrumentation, including for
 223          * int80_is_external() below which calls into the APIC driver.
 224          * Identical for soft and external interrupts.
 225          */
 226         enter_from_user_mode(regs);
 227
 228         instrumentation_begin();
 229         add_random_kstack_offset();
 230
 231         /* Validate that this is a soft interrupt to the extent possible */
 232         if (unlikely(int80_is_external()))
 233                 panic("Unexpected external interrupt 0x80\n");
 234
 235         /*
 236          * The low level idtentry code pushed -1 into regs::orig_ax
 237          * and regs::ax contains the syscall number.
 238          *
 239          * User tracing code (ptrace or signal handlers) might assume
 240          * that the regs::orig_ax contains a 32-bit number on invoking
 241          * a 32-bit syscall.
 242          *
 243          * Establish the syscall convention by saving the 32bit truncated
 244          * syscall number in regs::orig_ax and by invalidating regs::ax.
 245          */
 246         regs->orig_ax = regs->ax & GENMASK(31, 0);
 247         regs->ax = -ENOSYS;
 248
 249         nr = syscall_32_enter(regs);
 250
 251         local_irq_enable();
 252         nr = syscall_enter_from_user_mode_work(regs, nr);
 253         do_syscall_32_irqs_on(regs, nr);
 254
 255         instrumentation_end();
 256         syscall_exit_to_user_mode(regs);
 257 }
 258 #else /* CONFIG_IA32_EMULATION */
 259
 260 /* Handles int $0x80 on a 32bit kernel */
 261 __visible noinstr void do_int80_syscall_32(struct pt_regs *regs)
 262 {
 263         int nr = syscall_32_enter(regs);
 264
 265         add_random_kstack_offset();
 266         /*
 267          * Subtlety here: if ptrace pokes something larger than 2^31-1 into
 268          * orig_ax, the int return value truncates it. This matches
 269          * the semantics of syscall_get_nr().
 270          */
 271         nr = syscall_enter_from_user_mode(regs, nr);
 272         instrumentation_begin();
 273
 274         do_syscall_32_irqs_on(regs, nr);
 275
 276         instrumentation_end();
 277         syscall_exit_to_user_mode(regs);
 278 }
 279 #endif /* !CONFIG_IA32_EMULATION */
 280
 281 static noinstr bool __do_fast_syscall_32(struct pt_regs *regs)
 282 {
 283         int nr = syscall_32_enter(regs);
 284         int res;
 285
 286         add_random_kstack_offset();
 287         /*
 288          * This cannot use syscall_enter_from_user_mode() as it has to
 289          * fetch EBP before invoking any of the syscall entry work
 290          * functions.
 291          */
 292         syscall_enter_from_user_mode_prepare(regs);
 293
 294         instrumentation_begin();
 295         /* Fetch EBP from where the vDSO stashed it. */
 296         if (IS_ENABLED(CONFIG_X86_64)) {
 297                 /*
 298                  * Micro-optimization: the pointer we're following is
 299                  * explicitly 32 bits, so it can't be out of range.
 300                  */
 301                 res = __get_user(*(u32 *)&regs->bp,
 302                          (u32 __user __force *)(unsigned long)(u32)regs->sp);
 303         } else {
 304                 res = get_user(*(u32 *)&regs->bp,
 305                        (u32 __user __force *)(unsigned long)(u32)regs->sp);
 306         }
 307
 308         if (res) {
 309                 /* User code screwed up. */
 310                 regs->ax = -EFAULT;
 311
 312                 local_irq_disable();
 313                 instrumentation_end();
 314                 irqentry_exit_to_user_mode(regs);
 315                 return false;
 316         }
 317
 318         nr = syscall_enter_from_user_mode_work(regs, nr);
 319
 320         /* Now this is just like a normal syscall. */
 321         do_syscall_32_irqs_on(regs, nr);
 322
 323         instrumentation_end();
 324         syscall_exit_to_user_mode(regs);
 325         return true;
 326 }
 327
 328 /* Returns true to return using SYSEXIT/SYSRETL, or false to use IRET */
 329 __visible noinstr bool do_fast_syscall_32(struct pt_regs *regs)
 330 {
 331         /*
 332          * Called using the internal vDSO SYSENTER/SYSCALL32 calling
 333          * convention.  Adjust regs so it looks like we entered using int80.
 334          */
 335         unsigned long landing_pad = (unsigned long)current->mm->context.vdso +
 336                                         vdso_image_32.sym_int80_landing_pad;
 337
 338         /*
 339          * SYSENTER loses EIP, and even SYSCALL32 needs us to skip forward
 340          * so that 'regs->ip -= 2' lands back on an int $0x80 instruction.
 341          * Fix it up.
 342          */
 343         regs->ip = landing_pad;
 344
 345         /* Invoke the syscall. If it failed, keep it simple: use IRET. */
 346         if (!__do_fast_syscall_32(regs))
 347                 return false;
 348
 349         /*
 350          * Check that the register state is valid for using SYSRETL/SYSEXIT
 351          * to exit to userspace.  Otherwise use the slower but fully capable
 352          * IRET exit path.
 353          */
 354
 355         /* XEN PV guests always use the IRET path */
 356         if (cpu_feature_enabled(X86_FEATURE_XENPV))
 357                 return false;
 358
 359         /* EIP must point to the VDSO landing pad */
 360         if (unlikely(regs->ip != landing_pad))
 361                 return false;
 362
 363         /* CS and SS must match the values set in MSR_STAR */
 364         if (unlikely(regs->cs != __USER32_CS || regs->ss != __USER_DS))
 365                 return false;
 366
 367         /* If the TF, RF, or VM flags are set, use IRET */
 368         if (unlikely(regs->flags & (X86_EFLAGS_RF | X86_EFLAGS_TF | X86_EFLAGS_VM)))
 369                 return false;
 370
 371         /* Use SYSRETL/SYSEXIT to exit to userspace */
 372         return true;
 373 }
 374
 375 /* Returns true to return using SYSEXIT/SYSRETL, or false to use IRET */
 376 __visible noinstr bool do_SYSENTER_32(struct pt_regs *regs)
 377 {
 378         /* SYSENTER loses RSP, but the vDSO saved it in RBP. */
 379         regs->sp = regs->bp;
 380
 381         /* SYSENTER clobbers EFLAGS.IF.  Assume it was set in usermode. */
 382         regs->flags |= X86_EFLAGS_IF;
 383
 384         return do_fast_syscall_32(regs);
 385 }
 386 #endif
 387
 388 SYSCALL_DEFINE0(ni_syscall)
 389 {
 390         return -ENOSYS;
 391 }
 392
 393 #ifdef CONFIG_XEN_PV
 394 #ifndef CONFIG_PREEMPTION
 395 /*
 396  * Some hypercalls issued by the toolstack can take many 10s of
 397  * seconds. Allow tasks running hypercalls via the privcmd driver to
 398  * be voluntarily preempted even if full kernel preemption is
 399  * disabled.
 400  *
 401  * Such preemptible hypercalls are bracketed by
 402  * xen_preemptible_hcall_begin() and xen_preemptible_hcall_end()
 403  * calls.
 404  */
 405 DEFINE_PER_CPU(bool, xen_in_preemptible_hcall);
 406 EXPORT_SYMBOL_GPL(xen_in_preemptible_hcall);
 407
 408 /*
 409  * In case of scheduling the flag must be cleared and restored after
 410  * returning from schedule as the task might move to a different CPU.
 411  */
 412 static __always_inline bool get_and_clear_inhcall(void)
 413 {
 414         bool inhcall = __this_cpu_read(xen_in_preemptible_hcall);
 415
 416         __this_cpu_write(xen_in_preemptible_hcall, false);
 417         return inhcall;
 418 }
 419
 420 static __always_inline void restore_inhcall(bool inhcall)
 421 {
 422         __this_cpu_write(xen_in_preemptible_hcall, inhcall);
 423 }
 424 #else
 425 static __always_inline bool get_and_clear_inhcall(void) { return false; }
 426 static __always_inline void restore_inhcall(bool inhcall) { }
 427 #endif
 428
 429 static void __xen_pv_evtchn_do_upcall(struct pt_regs *regs)
 430 {
 431         struct pt_regs *old_regs = set_irq_regs(regs);
 432
 433         inc_irq_stat(irq_hv_callback_count);
 434
 435         xen_evtchn_do_upcall();
 436
 437         set_irq_regs(old_regs);
 438 }
 439
 440 __visible noinstr void xen_pv_evtchn_do_upcall(struct pt_regs *regs)
 441 {
 442         irqentry_state_t state = irqentry_enter(regs);
 443         bool inhcall;
 444
 445         instrumentation_begin();
 446         run_sysvec_on_irqstack_cond(__xen_pv_evtchn_do_upcall, regs);
 447
 448         inhcall = get_and_clear_inhcall();
 449         if (inhcall && !WARN_ON_ONCE(state.exit_rcu)) {
 450                 irqentry_exit_cond_resched();
 451                 instrumentation_end();
 452                 restore_inhcall(inhcall);
 453         } else {
 454                 instrumentation_end();
 455                 irqentry_exit(regs, state);
 456         }
 457 }
 458 #endif /* CONFIG_XEN_PV */