arch/x86/kernel/signal_64.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 1991, 1992  Linus Torvalds
   4  *  Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/kernel.h>
  10 #include <linux/errno.h>
  11 #include <linux/unistd.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/syscalls.h>
  14
  15 #include <asm/ucontext.h>
  16 #include <asm/fpu/signal.h>
  17 #include <asm/sighandling.h>
  18
  19 #include <asm/syscall.h>
  20 #include <asm/sigframe.h>
  21 #include <asm/signal.h>
  22
  23 /*
  24  * If regs->ss will cause an IRET fault, change it.  Otherwise leave it
  25  * alone.  Using this generally makes no sense unless
  26  * user_64bit_mode(regs) would return true.
  27  */
  28 static void force_valid_ss(struct pt_regs *regs)
  29 {
  30         u32 ar;
  31         asm volatile ("lar %[old_ss], %[ar]\n\t"
  32                       "jz 1f\n\t"               /* If invalid: */
  33                       "xorl %[ar], %[ar]\n\t"   /* set ar = 0 */
  34                       "1:"
  35                       : [ar] "=r" (ar)
  36                       : [old_ss] "rm" ((u16)regs->ss));
  37
  38         /*
  39          * For a valid 64-bit user context, we need DPL 3, type
  40          * read-write data or read-write exp-down data, and S and P
  41          * set.  We can't use VERW because VERW doesn't check the
  42          * P bit.
  43          */
  44         ar &= AR_DPL_MASK | AR_S | AR_P | AR_TYPE_MASK;
  45         if (ar != (AR_DPL3 | AR_S | AR_P | AR_TYPE_RWDATA) &&
  46             ar != (AR_DPL3 | AR_S | AR_P | AR_TYPE_RWDATA_EXPDOWN))
  47                 regs->ss = __USER_DS;
  48 }
  49
  50 static bool restore_sigcontext(struct pt_regs *regs,
  51                                struct sigcontext __user *usc,
  52                                unsigned long uc_flags)
  53 {
  54         struct sigcontext sc;
  55
  56         /* Always make any pending restarted system calls return -EINTR */
  57         current->restart_block.fn = do_no_restart_syscall;
  58
  59         if (copy_from_user(&sc, usc, offsetof(struct sigcontext, reserved1)))
  60                 return false;
  61
  62         regs->bx = sc.bx;
  63         regs->cx = sc.cx;
  64         regs->dx = sc.dx;
  65         regs->si = sc.si;
  66         regs->di = sc.di;
  67         regs->bp = sc.bp;
  68         regs->ax = sc.ax;
  69         regs->sp = sc.sp;
  70         regs->ip = sc.ip;
  71         regs->r8 = sc.r8;
  72         regs->r9 = sc.r9;
  73         regs->r10 = sc.r10;
  74         regs->r11 = sc.r11;
  75         regs->r12 = sc.r12;
  76         regs->r13 = sc.r13;
  77         regs->r14 = sc.r14;
  78         regs->r15 = sc.r15;
  79
  80         /* Get CS/SS and force CPL3 */
  81         regs->cs = sc.cs | 0x03;
  82         regs->ss = sc.ss | 0x03;
  83
  84         regs->flags = (regs->flags & ~FIX_EFLAGS) | (sc.flags & FIX_EFLAGS);
  85         /* disable syscall checks */
  86         regs->orig_ax = -1;
  87
  88         /*
  89          * Fix up SS if needed for the benefit of old DOSEMU and
  90          * CRIU.
  91          */
  92         if (unlikely(!(uc_flags & UC_STRICT_RESTORE_SS) && user_64bit_mode(regs)))
  93                 force_valid_ss(regs);
  94
  95         return fpu__restore_sig((void __user *)sc.fpstate, 0);
  96 }
  97
  98 static __always_inline int
  99 __unsafe_setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
 100                      struct pt_regs *regs, unsigned long mask)
 101 {
 102         unsafe_put_user(regs->di, &sc->di, Efault);
 103         unsafe_put_user(regs->si, &sc->si, Efault);
 104         unsafe_put_user(regs->bp, &sc->bp, Efault);
 105         unsafe_put_user(regs->sp, &sc->sp, Efault);
 106         unsafe_put_user(regs->bx, &sc->bx, Efault);
 107         unsafe_put_user(regs->dx, &sc->dx, Efault);
 108         unsafe_put_user(regs->cx, &sc->cx, Efault);
 109         unsafe_put_user(regs->ax, &sc->ax, Efault);
 110         unsafe_put_user(regs->r8, &sc->r8, Efault);
 111         unsafe_put_user(regs->r9, &sc->r9, Efault);
 112         unsafe_put_user(regs->r10, &sc->r10, Efault);
 113         unsafe_put_user(regs->r11, &sc->r11, Efault);
 114         unsafe_put_user(regs->r12, &sc->r12, Efault);
 115         unsafe_put_user(regs->r13, &sc->r13, Efault);
 116         unsafe_put_user(regs->r14, &sc->r14, Efault);
 117         unsafe_put_user(regs->r15, &sc->r15, Efault);
 118
 119         unsafe_put_user(current->thread.trap_nr, &sc->trapno, Efault);
 120         unsafe_put_user(current->thread.error_code, &sc->err, Efault);
 121         unsafe_put_user(regs->ip, &sc->ip, Efault);
 122         unsafe_put_user(regs->flags, &sc->flags, Efault);
 123         unsafe_put_user(regs->cs, &sc->cs, Efault);
 124         unsafe_put_user(0, &sc->gs, Efault);
 125         unsafe_put_user(0, &sc->fs, Efault);
 126         unsafe_put_user(regs->ss, &sc->ss, Efault);
 127
 128         unsafe_put_user(fpstate, (unsigned long __user *)&sc->fpstate, Efault);
 129
 130         /* non-iBCS2 extensions.. */
 131         unsafe_put_user(mask, &sc->oldmask, Efault);
 132         unsafe_put_user(current->thread.cr2, &sc->cr2, Efault);
 133         return 0;
 134 Efault:
 135         return -EFAULT;
 136 }
 137
 138 #define unsafe_put_sigcontext(sc, fp, regs, set, label)                 \
 139 do {                                                                    \
 140         if (__unsafe_setup_sigcontext(sc, fp, regs, set->sig[0]))       \
 141                 goto label;                                             \
 142 } while(0);
 143
 144 #define unsafe_put_sigmask(set, frame, label) \
 145         unsafe_put_user(*(__u64 *)(set), \
 146                         (__u64 __user *)&(frame)->uc.uc_sigmask, \
 147                         label)
 148
 149 static unsigned long frame_uc_flags(struct pt_regs *regs)
 150 {
 151         unsigned long flags;
 152
 153         if (boot_cpu_has(X86_FEATURE_XSAVE))
 154                 flags = UC_FP_XSTATE | UC_SIGCONTEXT_SS;
 155         else
 156                 flags = UC_SIGCONTEXT_SS;
 157
 158         if (likely(user_64bit_mode(regs)))
 159                 flags |= UC_STRICT_RESTORE_SS;
 160
 161         return flags;
 162 }
 163
 164 int x64_setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
 165 {
 166         sigset_t *set = sigmask_to_save();
 167         struct rt_sigframe __user *frame;
 168         void __user *fp = NULL;
 169         unsigned long uc_flags;
 170
 171         /* x86-64 should always use SA_RESTORER. */
 172         if (!(ksig->ka.sa.sa_flags & SA_RESTORER))
 173                 return -EFAULT;
 174
 175         frame = get_sigframe(ksig, regs, sizeof(struct rt_sigframe), &fp);
 176         uc_flags = frame_uc_flags(regs);
 177
 178         if (!user_access_begin(frame, sizeof(*frame)))
 179                 return -EFAULT;
 180
 181         /* Create the ucontext.  */
 182         unsafe_put_user(uc_flags, &frame->uc.uc_flags, Efault);
 183         unsafe_put_user(0, &frame->uc.uc_link, Efault);
 184         unsafe_save_altstack(&frame->uc.uc_stack, regs->sp, Efault);
 185
 186         /* Set up to return from userspace.  If provided, use a stub
 187            already in userspace.  */
 188         unsafe_put_user(ksig->ka.sa.sa_restorer, &frame->pretcode, Efault);
 189         unsafe_put_sigcontext(&frame->uc.uc_mcontext, fp, regs, set, Efault);
 190         unsafe_put_sigmask(set, frame, Efault);
 191         user_access_end();
 192
 193         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
 194                 if (copy_siginfo_to_user(&frame->info, &ksig->info))
 195                         return -EFAULT;
 196         }
 197
 198         /* Set up registers for signal handler */
 199         regs->di = ksig->sig;
 200         /* In case the signal handler was declared without prototypes */
 201         regs->ax = 0;
 202
 203         /* This also works for non SA_SIGINFO handlers because they expect the
 204            next argument after the signal number on the stack. */
 205         regs->si = (unsigned long)&frame->info;
 206         regs->dx = (unsigned long)&frame->uc;
 207         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 208
 209         regs->sp = (unsigned long)frame;
 210
 211         /*
 212          * Set up the CS and SS registers to run signal handlers in
 213          * 64-bit mode, even if the handler happens to be interrupting
 214          * 32-bit or 16-bit code.
 215          *
 216          * SS is subtle.  In 64-bit mode, we don't need any particular
 217          * SS descriptor, but we do need SS to be valid.  It's possible
 218          * that the old SS is entirely bogus -- this can happen if the
 219          * signal we're trying to deliver is #GP or #SS caused by a bad
 220          * SS value.  We also have a compatibility issue here: DOSEMU
 221          * relies on the contents of the SS register indicating the
 222          * SS value at the time of the signal, even though that code in
 223          * DOSEMU predates sigreturn's ability to restore SS.  (DOSEMU
 224          * avoids relying on sigreturn to restore SS; instead it uses
 225          * a trampoline.)  So we do our best: if the old SS was valid,
 226          * we keep it.  Otherwise we replace it.
 227          */
 228         regs->cs = __USER_CS;
 229
 230         if (unlikely(regs->ss != __USER_DS))
 231                 force_valid_ss(regs);
 232
 233         return 0;
 234
 235 Efault:
 236         user_access_end();
 237         return -EFAULT;
 238 }
 239
 240 /*
 241  * Do a signal return; undo the signal stack.
 242  */
 243 SYSCALL_DEFINE0(rt_sigreturn)
 244 {
 245         struct pt_regs *regs = current_pt_regs();
 246         struct rt_sigframe __user *frame;
 247         sigset_t set;
 248         unsigned long uc_flags;
 249
 250         frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
 251         if (!access_ok(frame, sizeof(*frame)))
 252                 goto badframe;
 253         if (__get_user(*(__u64 *)&set, (__u64 __user *)&frame->uc.uc_sigmask))
 254                 goto badframe;
 255         if (__get_user(uc_flags, &frame->uc.uc_flags))
 256                 goto badframe;
 257
 258         set_current_blocked(&set);
 259
 260         if (!restore_sigcontext(regs, &frame->uc.uc_mcontext, uc_flags))
 261                 goto badframe;
 262
 263         if (restore_altstack(&frame->uc.uc_stack))
 264                 goto badframe;
 265
 266         return regs->ax;
 267
 268 badframe:
 269         signal_fault(regs, frame, "rt_sigreturn");
 270         return 0;
 271 }
 272
 273 #ifdef CONFIG_X86_X32_ABI
 274 static int x32_copy_siginfo_to_user(struct compat_siginfo __user *to,
 275                 const struct kernel_siginfo *from)
 276 {
 277         struct compat_siginfo new;
 278
 279         copy_siginfo_to_external32(&new, from);
 280         if (from->si_signo == SIGCHLD) {
 281                 new._sifields._sigchld_x32._utime = from->si_utime;
 282                 new._sifields._sigchld_x32._stime = from->si_stime;
 283         }
 284         if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
 285                 return -EFAULT;
 286         return 0;
 287 }
 288
 289 int copy_siginfo_to_user32(struct compat_siginfo __user *to,
 290                            const struct kernel_siginfo *from)
 291 {
 292         if (in_x32_syscall())
 293                 return x32_copy_siginfo_to_user(to, from);
 294         return __copy_siginfo_to_user32(to, from);
 295 }
 296
 297 int x32_setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
 298 {
 299         compat_sigset_t *set = (compat_sigset_t *) sigmask_to_save();
 300         struct rt_sigframe_x32 __user *frame;
 301         unsigned long uc_flags;
 302         void __user *restorer;
 303         void __user *fp = NULL;
 304
 305         if (!(ksig->ka.sa.sa_flags & SA_RESTORER))
 306                 return -EFAULT;
 307
 308         frame = get_sigframe(ksig, regs, sizeof(*frame), &fp);
 309
 310         uc_flags = frame_uc_flags(regs);
 311
 312         if (!user_access_begin(frame, sizeof(*frame)))
 313                 return -EFAULT;
 314
 315         /* Create the ucontext.  */
 316         unsafe_put_user(uc_flags, &frame->uc.uc_flags, Efault);
 317         unsafe_put_user(0, &frame->uc.uc_link, Efault);
 318         unsafe_compat_save_altstack(&frame->uc.uc_stack, regs->sp, Efault);
 319         unsafe_put_user(0, &frame->uc.uc__pad0, Efault);
 320         restorer = ksig->ka.sa.sa_restorer;
 321         unsafe_put_user(restorer, (unsigned long __user *)&frame->pretcode, Efault);
 322         unsafe_put_sigcontext(&frame->uc.uc_mcontext, fp, regs, set, Efault);
 323         unsafe_put_sigmask(set, frame, Efault);
 324         user_access_end();
 325
 326         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
 327                 if (x32_copy_siginfo_to_user(&frame->info, &ksig->info))
 328                         return -EFAULT;
 329         }
 330
 331         /* Set up registers for signal handler */
 332         regs->sp = (unsigned long) frame;
 333         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 334
 335         /* We use the x32 calling convention here... */
 336         regs->di = ksig->sig;
 337         regs->si = (unsigned long) &frame->info;
 338         regs->dx = (unsigned long) &frame->uc;
 339
 340         loadsegment(ds, __USER_DS);
 341         loadsegment(es, __USER_DS);
 342
 343         regs->cs = __USER_CS;
 344         regs->ss = __USER_DS;
 345
 346         return 0;
 347
 348 Efault:
 349         user_access_end();
 350         return -EFAULT;
 351 }
 352
 353 COMPAT_SYSCALL_DEFINE0(x32_rt_sigreturn)
 354 {
 355         struct pt_regs *regs = current_pt_regs();
 356         struct rt_sigframe_x32 __user *frame;
 357         sigset_t set;
 358         unsigned long uc_flags;
 359
 360         frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8);
 361
 362         if (!access_ok(frame, sizeof(*frame)))
 363                 goto badframe;
 364         if (__get_user(set.sig[0], (__u64 __user *)&frame->uc.uc_sigmask))
 365                 goto badframe;
 366         if (__get_user(uc_flags, &frame->uc.uc_flags))
 367                 goto badframe;
 368
 369         set_current_blocked(&set);
 370
 371         if (!restore_sigcontext(regs, &frame->uc.uc_mcontext, uc_flags))
 372                 goto badframe;
 373
 374         if (compat_restore_altstack(&frame->uc.uc_stack))
 375                 goto badframe;
 376
 377         return regs->ax;
 378
 379 badframe:
 380         signal_fault(regs, frame, "x32 rt_sigreturn");
 381         return 0;
 382 }
 383 #endif /* CONFIG_X86_X32_ABI */
 384
 385 #ifdef CONFIG_COMPAT
 386 void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact)
 387 {
 388         if (!act)
 389                 return;
 390
 391         if (in_ia32_syscall())
 392                 act->sa.sa_flags |= SA_IA32_ABI;
 393         if (in_x32_syscall())
 394                 act->sa.sa_flags |= SA_X32_ABI;
 395 }
 396 #endif /* CONFIG_COMPAT */
 397
 398 /*
 399 * If adding a new si_code, there is probably new data in
 400 * the siginfo.  Make sure folks bumping the si_code
 401 * limits also have to look at this code.  Make sure any
 402 * new fields are handled in copy_siginfo_to_user32()!
 403 */
 404 static_assert(NSIGILL  == 11);
 405 static_assert(NSIGFPE  == 15);
 406 static_assert(NSIGSEGV == 9);
 407 static_assert(NSIGBUS  == 5);
 408 static_assert(NSIGTRAP == 6);
 409 static_assert(NSIGCHLD == 6);
 410 static_assert(NSIGSYS  == 2);
 411
 412 /* This is part of the ABI and can never change in size: */
 413 static_assert(sizeof(siginfo_t) == 128);
 414
 415 /* This is a part of the ABI and can never change in alignment */
 416 static_assert(__alignof__(siginfo_t) == 8);
 417
 418 /*
 419 * The offsets of all the (unioned) si_fields are fixed
 420 * in the ABI, of course.  Make sure none of them ever
 421 * move and are always at the beginning:
 422 */
 423 static_assert(offsetof(siginfo_t, si_signo) == 0);
 424 static_assert(offsetof(siginfo_t, si_errno) == 4);
 425 static_assert(offsetof(siginfo_t, si_code)  == 8);
 426
 427 /*
 428 * Ensure that the size of each si_field never changes.
 429 * If it does, it is a sign that the
 430 * copy_siginfo_to_user32() code below needs to updated
 431 * along with the size in the CHECK_SI_SIZE().
 432 *
 433 * We repeat this check for both the generic and compat
 434 * siginfos.
 435 *
 436 * Note: it is OK for these to grow as long as the whole
 437 * structure stays within the padding size (checked
 438 * above).
 439 */
 440
 441 #define CHECK_SI_OFFSET(name)                                           \
 442         static_assert(offsetof(siginfo_t, _sifields) ==                 \
 443                       offsetof(siginfo_t, _sifields.name))
 444 #define CHECK_SI_SIZE(name, size)                                       \
 445         static_assert(sizeof_field(siginfo_t, _sifields.name) == size)
 446
 447 CHECK_SI_OFFSET(_kill);
 448 CHECK_SI_SIZE  (_kill, 2*sizeof(int));
 449 static_assert(offsetof(siginfo_t, si_pid) == 0x10);
 450 static_assert(offsetof(siginfo_t, si_uid) == 0x14);
 451
 452 CHECK_SI_OFFSET(_timer);
 453 CHECK_SI_SIZE  (_timer, 6*sizeof(int));
 454 static_assert(offsetof(siginfo_t, si_tid)     == 0x10);
 455 static_assert(offsetof(siginfo_t, si_overrun) == 0x14);
 456 static_assert(offsetof(siginfo_t, si_value)   == 0x18);
 457
 458 CHECK_SI_OFFSET(_rt);
 459 CHECK_SI_SIZE  (_rt, 4*sizeof(int));
 460 static_assert(offsetof(siginfo_t, si_pid)   == 0x10);
 461 static_assert(offsetof(siginfo_t, si_uid)   == 0x14);
 462 static_assert(offsetof(siginfo_t, si_value) == 0x18);
 463
 464 CHECK_SI_OFFSET(_sigchld);
 465 CHECK_SI_SIZE  (_sigchld, 8*sizeof(int));
 466 static_assert(offsetof(siginfo_t, si_pid)    == 0x10);
 467 static_assert(offsetof(siginfo_t, si_uid)    == 0x14);
 468 static_assert(offsetof(siginfo_t, si_status) == 0x18);
 469 static_assert(offsetof(siginfo_t, si_utime)  == 0x20);
 470 static_assert(offsetof(siginfo_t, si_stime)  == 0x28);
 471
 472 #ifdef CONFIG_X86_X32_ABI
 473 /* no _sigchld_x32 in the generic siginfo_t */
 474 static_assert(sizeof_field(compat_siginfo_t, _sifields._sigchld_x32) ==
 475               7*sizeof(int));
 476 static_assert(offsetof(compat_siginfo_t, _sifields) ==
 477               offsetof(compat_siginfo_t, _sifields._sigchld_x32));
 478 static_assert(offsetof(compat_siginfo_t, _sifields._sigchld_x32._utime)  == 0x18);
 479 static_assert(offsetof(compat_siginfo_t, _sifields._sigchld_x32._stime)  == 0x20);
 480 #endif
 481
 482 CHECK_SI_OFFSET(_sigfault);
 483 CHECK_SI_SIZE  (_sigfault, 8*sizeof(int));
 484 static_assert(offsetof(siginfo_t, si_addr)      == 0x10);
 485
 486 static_assert(offsetof(siginfo_t, si_trapno)    == 0x18);
 487
 488 static_assert(offsetof(siginfo_t, si_addr_lsb)  == 0x18);
 489
 490 static_assert(offsetof(siginfo_t, si_lower)     == 0x20);
 491 static_assert(offsetof(siginfo_t, si_upper)     == 0x28);
 492
 493 static_assert(offsetof(siginfo_t, si_pkey)      == 0x20);
 494
 495 static_assert(offsetof(siginfo_t, si_perf_data)  == 0x18);
 496 static_assert(offsetof(siginfo_t, si_perf_type)  == 0x20);
 497 static_assert(offsetof(siginfo_t, si_perf_flags) == 0x24);
 498
 499 CHECK_SI_OFFSET(_sigpoll);
 500 CHECK_SI_SIZE  (_sigpoll, 4*sizeof(int));
 501 static_assert(offsetof(siginfo_t, si_band) == 0x10);
 502 static_assert(offsetof(siginfo_t, si_fd)   == 0x18);
 503
 504 CHECK_SI_OFFSET(_sigsys);
 505 CHECK_SI_SIZE  (_sigsys, 4*sizeof(int));
 506 static_assert(offsetof(siginfo_t, si_call_addr) == 0x10);
 507 static_assert(offsetof(siginfo_t, si_syscall)   == 0x18);
 508 static_assert(offsetof(siginfo_t, si_arch)      == 0x1C);
 509
 510 /* any new si_fields should be added here */