arch/x86/kernel/signal_32.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 1991, 1992  Linus Torvalds
   4  *
   5  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
   6  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
   7  *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/sched/task_stack.h>
  12 #include <linux/mm.h>
  13 #include <linux/smp.h>
  14 #include <linux/kernel.h>
  15 #include <linux/errno.h>
  16 #include <linux/wait.h>
  17 #include <linux/unistd.h>
  18 #include <linux/stddef.h>
  19 #include <linux/personality.h>
  20 #include <linux/compat.h>
  21 #include <linux/binfmts.h>
  22 #include <linux/syscalls.h>
  23 #include <asm/ucontext.h>
  24 #include <linux/uaccess.h>
  25 #include <asm/fpu/signal.h>
  26 #include <asm/ptrace.h>
  27 #include <asm/user32.h>
  28 #include <uapi/asm/sigcontext.h>
  29 #include <asm/proto.h>
  30 #include <asm/vdso.h>
  31 #include <asm/sigframe.h>
  32 #include <asm/sighandling.h>
  33 #include <asm/smap.h>
  34
  35 #ifdef CONFIG_IA32_EMULATION
  36 #include <asm/ia32_unistd.h>
  37
  38 static inline void reload_segments(struct sigcontext_32 *sc)
  39 {
  40         unsigned int cur;
  41
  42         savesegment(gs, cur);
  43         if ((sc->gs | 0x03) != cur)
  44                 load_gs_index(sc->gs | 0x03);
  45         savesegment(fs, cur);
  46         if ((sc->fs | 0x03) != cur)
  47                 loadsegment(fs, sc->fs | 0x03);
  48         savesegment(ds, cur);
  49         if ((sc->ds | 0x03) != cur)
  50                 loadsegment(ds, sc->ds | 0x03);
  51         savesegment(es, cur);
  52         if ((sc->es | 0x03) != cur)
  53                 loadsegment(es, sc->es | 0x03);
  54 }
  55
  56 #define sigset32_t                      compat_sigset_t
  57 #define restore_altstack32              compat_restore_altstack
  58 #define unsafe_save_altstack32          unsafe_compat_save_altstack
  59
  60 #else
  61
  62 #define sigset32_t                      sigset_t
  63 #define __NR_ia32_sigreturn             __NR_sigreturn
  64 #define __NR_ia32_rt_sigreturn          __NR_rt_sigreturn
  65 #define restore_altstack32              restore_altstack
  66 #define unsafe_save_altstack32          unsafe_save_altstack
  67 #define __copy_siginfo_to_user32        copy_siginfo_to_user
  68
  69 #endif
  70
  71 /*
  72  * Do a signal return; undo the signal stack.
  73  */
  74 static bool ia32_restore_sigcontext(struct pt_regs *regs,
  75                                     struct sigcontext_32 __user *usc)
  76 {
  77         struct sigcontext_32 sc;
  78
  79         /* Always make any pending restarted system calls return -EINTR */
  80         current->restart_block.fn = do_no_restart_syscall;
  81
  82         if (unlikely(copy_from_user(&sc, usc, sizeof(sc))))
  83                 return false;
  84
  85         /* Get only the ia32 registers. */
  86         regs->bx = sc.bx;
  87         regs->cx = sc.cx;
  88         regs->dx = sc.dx;
  89         regs->si = sc.si;
  90         regs->di = sc.di;
  91         regs->bp = sc.bp;
  92         regs->ax = sc.ax;
  93         regs->sp = sc.sp;
  94         regs->ip = sc.ip;
  95
  96         /* Get CS/SS and force CPL3 */
  97         regs->cs = sc.cs | 0x03;
  98         regs->ss = sc.ss | 0x03;
  99
 100         regs->flags = (regs->flags & ~FIX_EFLAGS) | (sc.flags & FIX_EFLAGS);
 101         /* disable syscall checks */
 102         regs->orig_ax = -1;
 103
 104 #ifdef CONFIG_IA32_EMULATION
 105         /*
 106          * Reload fs and gs if they have changed in the signal
 107          * handler.  This does not handle long fs/gs base changes in
 108          * the handler, but does not clobber them at least in the
 109          * normal case.
 110          */
 111         reload_segments(&sc);
 112 #else
 113         loadsegment(gs, sc.gs);
 114         regs->fs = sc.fs;
 115         regs->es = sc.es;
 116         regs->ds = sc.ds;
 117 #endif
 118
 119         return fpu__restore_sig(compat_ptr(sc.fpstate), 1);
 120 }
 121
 122 SYSCALL32_DEFINE0(sigreturn)
 123 {
 124         struct pt_regs *regs = current_pt_regs();
 125         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
 126         sigset_t set;
 127
 128         if (!access_ok(frame, sizeof(*frame)))
 129                 goto badframe;
 130         if (__get_user(set.sig[0], &frame->sc.oldmask)
 131             || __get_user(((__u32 *)&set)[1], &frame->extramask[0]))
 132                 goto badframe;
 133
 134         set_current_blocked(&set);
 135
 136         if (!ia32_restore_sigcontext(regs, &frame->sc))
 137                 goto badframe;
 138         return regs->ax;
 139
 140 badframe:
 141         signal_fault(regs, frame, "32bit sigreturn");
 142         return 0;
 143 }
 144
 145 SYSCALL32_DEFINE0(rt_sigreturn)
 146 {
 147         struct pt_regs *regs = current_pt_regs();
 148         struct rt_sigframe_ia32 __user *frame;
 149         sigset_t set;
 150
 151         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 152
 153         if (!access_ok(frame, sizeof(*frame)))
 154                 goto badframe;
 155         if (__get_user(*(__u64 *)&set, (__u64 __user *)&frame->uc.uc_sigmask))
 156                 goto badframe;
 157
 158         set_current_blocked(&set);
 159
 160         if (!ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext))
 161                 goto badframe;
 162
 163         if (restore_altstack32(&frame->uc.uc_stack))
 164                 goto badframe;
 165
 166         return regs->ax;
 167
 168 badframe:
 169         signal_fault(regs, frame, "32bit rt sigreturn");
 170         return 0;
 171 }
 172
 173 /*
 174  * Set up a signal frame.
 175  */
 176
 177 #define get_user_seg(seg)       ({ unsigned int v; savesegment(seg, v); v; })
 178
 179 static __always_inline int
 180 __unsafe_setup_sigcontext32(struct sigcontext_32 __user *sc,
 181                             void __user *fpstate,
 182                             struct pt_regs *regs, unsigned int mask)
 183 {
 184         unsafe_put_user(get_user_seg(gs), (unsigned int __user *)&sc->gs, Efault);
 185 #ifdef CONFIG_IA32_EMULATION
 186         unsafe_put_user(get_user_seg(fs), (unsigned int __user *)&sc->fs, Efault);
 187         unsafe_put_user(get_user_seg(ds), (unsigned int __user *)&sc->ds, Efault);
 188         unsafe_put_user(get_user_seg(es), (unsigned int __user *)&sc->es, Efault);
 189 #else
 190         unsafe_put_user(regs->fs, (unsigned int __user *)&sc->fs, Efault);
 191         unsafe_put_user(regs->es, (unsigned int __user *)&sc->es, Efault);
 192         unsafe_put_user(regs->ds, (unsigned int __user *)&sc->ds, Efault);
 193 #endif
 194
 195         unsafe_put_user(regs->di, &sc->di, Efault);
 196         unsafe_put_user(regs->si, &sc->si, Efault);
 197         unsafe_put_user(regs->bp, &sc->bp, Efault);
 198         unsafe_put_user(regs->sp, &sc->sp, Efault);
 199         unsafe_put_user(regs->bx, &sc->bx, Efault);
 200         unsafe_put_user(regs->dx, &sc->dx, Efault);
 201         unsafe_put_user(regs->cx, &sc->cx, Efault);
 202         unsafe_put_user(regs->ax, &sc->ax, Efault);
 203         unsafe_put_user(current->thread.trap_nr, &sc->trapno, Efault);
 204         unsafe_put_user(current->thread.error_code, &sc->err, Efault);
 205         unsafe_put_user(regs->ip, &sc->ip, Efault);
 206         unsafe_put_user(regs->cs, (unsigned int __user *)&sc->cs, Efault);
 207         unsafe_put_user(regs->flags, &sc->flags, Efault);
 208         unsafe_put_user(regs->sp, &sc->sp_at_signal, Efault);
 209         unsafe_put_user(regs->ss, (unsigned int __user *)&sc->ss, Efault);
 210
 211         unsafe_put_user(ptr_to_compat(fpstate), &sc->fpstate, Efault);
 212
 213         /* non-iBCS2 extensions.. */
 214         unsafe_put_user(mask, &sc->oldmask, Efault);
 215         unsafe_put_user(current->thread.cr2, &sc->cr2, Efault);
 216         return 0;
 217
 218 Efault:
 219         return -EFAULT;
 220 }
 221
 222 #define unsafe_put_sigcontext32(sc, fp, regs, set, label)               \
 223 do {                                                                    \
 224         if (__unsafe_setup_sigcontext32(sc, fp, regs, set->sig[0]))     \
 225                 goto label;                                             \
 226 } while(0)
 227
 228 int ia32_setup_frame(struct ksignal *ksig, struct pt_regs *regs)
 229 {
 230         sigset32_t *set = (sigset32_t *) sigmask_to_save();
 231         struct sigframe_ia32 __user *frame;
 232         void __user *restorer;
 233         void __user *fp = NULL;
 234
 235         /* copy_to_user optimizes that into a single 8 byte store */
 236         static const struct {
 237                 u16 poplmovl;
 238                 u32 val;
 239                 u16 int80;
 240         } __attribute__((packed)) code = {
 241                 0xb858,          /* popl %eax ; movl $...,%eax */
 242                 __NR_ia32_sigreturn,
 243                 0x80cd,         /* int $0x80 */
 244         };
 245
 246         frame = get_sigframe(ksig, regs, sizeof(*frame), &fp);
 247
 248         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 249                 restorer = ksig->ka.sa.sa_restorer;
 250         } else {
 251                 /* Return stub is in 32bit vsyscall page */
 252                 if (current->mm->context.vdso)
 253                         restorer = current->mm->context.vdso +
 254                                 vdso_image_32.sym___kernel_sigreturn;
 255                 else
 256                         restorer = &frame->retcode;
 257         }
 258
 259         if (!user_access_begin(frame, sizeof(*frame)))
 260                 return -EFAULT;
 261
 262         unsafe_put_user(ksig->sig, &frame->sig, Efault);
 263         unsafe_put_sigcontext32(&frame->sc, fp, regs, set, Efault);
 264         unsafe_put_user(set->sig[1], &frame->extramask[0], Efault);
 265         unsafe_put_user(ptr_to_compat(restorer), &frame->pretcode, Efault);
 266         /*
 267          * These are actually not used anymore, but left because some
 268          * gdb versions depend on them as a marker.
 269          */
 270         unsafe_put_user(*((u64 *)&code), (u64 __user *)frame->retcode, Efault);
 271         user_access_end();
 272
 273         /* Set up registers for signal handler */
 274         regs->sp = (unsigned long) frame;
 275         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 276
 277         /* Make -mregparm=3 work */
 278         regs->ax = ksig->sig;
 279         regs->dx = 0;
 280         regs->cx = 0;
 281
 282 #ifdef CONFIG_IA32_EMULATION
 283         loadsegment(ds, __USER_DS);
 284         loadsegment(es, __USER_DS);
 285 #else
 286         regs->ds = __USER_DS;
 287         regs->es = __USER_DS;
 288 #endif
 289
 290         regs->cs = __USER32_CS;
 291         regs->ss = __USER_DS;
 292
 293         return 0;
 294 Efault:
 295         user_access_end();
 296         return -EFAULT;
 297 }
 298
 299 int ia32_setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
 300 {
 301         sigset32_t *set = (sigset32_t *) sigmask_to_save();
 302         struct rt_sigframe_ia32 __user *frame;
 303         void __user *restorer;
 304         void __user *fp = NULL;
 305
 306         /* unsafe_put_user optimizes that into a single 8 byte store */
 307         static const struct {
 308                 u8 movl;
 309                 u32 val;
 310                 u16 int80;
 311                 u8  pad;
 312         } __attribute__((packed)) code = {
 313                 0xb8,
 314                 __NR_ia32_rt_sigreturn,
 315                 0x80cd,
 316                 0,
 317         };
 318
 319         frame = get_sigframe(ksig, regs, sizeof(*frame), &fp);
 320
 321         if (!user_access_begin(frame, sizeof(*frame)))
 322                 return -EFAULT;
 323
 324         unsafe_put_user(ksig->sig, &frame->sig, Efault);
 325         unsafe_put_user(ptr_to_compat(&frame->info), &frame->pinfo, Efault);
 326         unsafe_put_user(ptr_to_compat(&frame->uc), &frame->puc, Efault);
 327
 328         /* Create the ucontext.  */
 329         if (static_cpu_has(X86_FEATURE_XSAVE))
 330                 unsafe_put_user(UC_FP_XSTATE, &frame->uc.uc_flags, Efault);
 331         else
 332                 unsafe_put_user(0, &frame->uc.uc_flags, Efault);
 333         unsafe_put_user(0, &frame->uc.uc_link, Efault);
 334         unsafe_save_altstack32(&frame->uc.uc_stack, regs->sp, Efault);
 335
 336         if (ksig->ka.sa.sa_flags & SA_RESTORER)
 337                 restorer = ksig->ka.sa.sa_restorer;
 338         else
 339                 restorer = current->mm->context.vdso +
 340                         vdso_image_32.sym___kernel_rt_sigreturn;
 341         unsafe_put_user(ptr_to_compat(restorer), &frame->pretcode, Efault);
 342
 343         /*
 344          * Not actually used anymore, but left because some gdb
 345          * versions need it.
 346          */
 347         unsafe_put_user(*((u64 *)&code), (u64 __user *)frame->retcode, Efault);
 348         unsafe_put_sigcontext32(&frame->uc.uc_mcontext, fp, regs, set, Efault);
 349         unsafe_put_user(*(__u64 *)set, (__u64 __user *)&frame->uc.uc_sigmask, Efault);
 350         user_access_end();
 351
 352         if (__copy_siginfo_to_user32(&frame->info, &ksig->info))
 353                 return -EFAULT;
 354
 355         /* Set up registers for signal handler */
 356         regs->sp = (unsigned long) frame;
 357         regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
 358
 359         /* Make -mregparm=3 work */
 360         regs->ax = ksig->sig;
 361         regs->dx = (unsigned long) &frame->info;
 362         regs->cx = (unsigned long) &frame->uc;
 363
 364 #ifdef CONFIG_IA32_EMULATION
 365         loadsegment(ds, __USER_DS);
 366         loadsegment(es, __USER_DS);
 367 #else
 368         regs->ds = __USER_DS;
 369         regs->es = __USER_DS;
 370 #endif
 371
 372         regs->cs = __USER32_CS;
 373         regs->ss = __USER_DS;
 374
 375         return 0;
 376 Efault:
 377         user_access_end();
 378         return -EFAULT;
 379 }