arch/s390/kernel/signal.c

   1 /*
   2  *    Copyright IBM Corp. 1999, 2006
   3  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   4  *
   5  *    Based on Intel version
   6  *
   7  *  Copyright (C) 1991, 1992  Linus Torvalds
   8  *
   9  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  10  */
  11
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/errno.h>
  18 #include <linux/wait.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/unistd.h>
  21 #include <linux/stddef.h>
  22 #include <linux/tty.h>
  23 #include <linux/personality.h>
  24 #include <linux/binfmts.h>
  25 #include <linux/tracehook.h>
  26 #include <linux/syscalls.h>
  27 #include <linux/compat.h>
  28 #include <asm/ucontext.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/lowcore.h>
  31 #include <asm/switch_to.h>
  32 #include "entry.h"
  33
  34 /*
  35  * Layout of an old-style signal-frame:
  36  *      -----------------------------------------
  37  *      | save area (_SIGNAL_FRAMESIZE)         |
  38  *      -----------------------------------------
  39  *      | struct sigcontext                     |
  40  *      |       oldmask                         |
  41  *      |       _sigregs *                      |
  42  *      -----------------------------------------
  43  *      | _sigregs with                         |
  44  *      |       _s390_regs_common               |
  45  *      |       _s390_fp_regs                   |
  46  *      -----------------------------------------
  47  *      | int signo                             |
  48  *      -----------------------------------------
  49  *      | _sigregs_ext with                     |
  50  *      |       gprs_high 64 byte (opt)         |
  51  *      |       vxrs_low 128 byte (opt)         |
  52  *      |       vxrs_high 256 byte (opt)        |
  53  *      |       reserved 128 byte (opt)         |
  54  *      -----------------------------------------
  55  *      | __u16 svc_insn                        |
  56  *      -----------------------------------------
  57  * The svc_insn entry with the sigreturn system call opcode does not
  58  * have a fixed position and moves if gprs_high or vxrs exist.
  59  * Future extensions will be added to _sigregs_ext.
  60  */
  61 struct sigframe
  62 {
  63         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  64         struct sigcontext sc;
  65         _sigregs sregs;
  66         int signo;
  67         _sigregs_ext sregs_ext;
  68         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
  69 };
  70
  71 /*
  72  * Layout of an rt signal-frame:
  73  *      -----------------------------------------
  74  *      | save area (_SIGNAL_FRAMESIZE)         |
  75  *      -----------------------------------------
  76  *      | svc __NR_rt_sigreturn 2 byte          |
  77  *      -----------------------------------------
  78  *      | struct siginfo                        |
  79  *      -----------------------------------------
  80  *      | struct ucontext_extended with         |
  81  *      |       unsigned long uc_flags          |
  82  *      |       struct ucontext *uc_link        |
  83  *      |       stack_t uc_stack                |
  84  *      |       _sigregs uc_mcontext with       |
  85  *      |               _s390_regs_common       |
  86  *      |               _s390_fp_regs           |
  87  *      |       sigset_t uc_sigmask             |
  88  *      |       _sigregs_ext uc_mcontext_ext    |
  89  *      |               gprs_high 64 byte (opt) |
  90  *      |               vxrs_low 128 byte (opt) |
  91  *      |               vxrs_high 256 byte (opt)|
  92  *      |               reserved 128 byte (opt) |
  93  *      -----------------------------------------
  94  * Future extensions will be added to _sigregs_ext.
  95  */
  96 struct rt_sigframe
  97 {
  98         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  99         __u16 svc_insn;
 100         struct siginfo info;
 101         struct ucontext_extended uc;
 102 };
 103
 104 /* Store registers needed to create the signal frame */
 105 static void store_sigregs(void)
 106 {
 107         save_access_regs(current->thread.acrs);
 108         save_fpu_regs();
 109 }
 110
 111 /* Load registers after signal return */
 112 static void load_sigregs(void)
 113 {
 114         restore_access_regs(current->thread.acrs);
 115 }
 116
 117 /* Returns non-zero on fault. */
 118 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 119 {
 120         _sigregs user_sregs;
 121
 122         /* Copy a 'clean' PSW mask to the user to avoid leaking
 123            information about whether PER is currently on.  */
 124         user_sregs.regs.psw.mask = PSW_USER_BITS |
 125                 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
 126         user_sregs.regs.psw.addr = regs->psw.addr;
 127         memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
 128         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
 129                sizeof(user_sregs.regs.acrs));
 130         fpregs_store(&user_sregs.fpregs, &current->thread.fpu);
 131         if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
 132                 return -EFAULT;
 133         return 0;
 134 }
 135
 136 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 137 {
 138         _sigregs user_sregs;
 139
 140         /* Alwys make any pending restarted system call return -EINTR */
 141         current->restart_block.fn = do_no_restart_syscall;
 142
 143         if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
 144                 return -EFAULT;
 145
 146         if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
 147                 return -EINVAL;
 148
 149         /* Test the floating-point-control word. */
 150         if (test_fp_ctl(user_sregs.fpregs.fpc))
 151                 return -EINVAL;
 152
 153         /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
 154         regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
 155                 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
 156         /* Check for invalid user address space control. */
 157         if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
 158                 regs->psw.mask = PSW_ASC_PRIMARY |
 159                         (regs->psw.mask & ~PSW_MASK_ASC);
 160         /* Check for invalid amode */
 161         if (regs->psw.mask & PSW_MASK_EA)
 162                 regs->psw.mask |= PSW_MASK_BA;
 163         regs->psw.addr = user_sregs.regs.psw.addr;
 164         memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
 165         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
 166                sizeof(current->thread.acrs));
 167
 168         fpregs_load(&user_sregs.fpregs, &current->thread.fpu);
 169
 170         clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
 171         return 0;
 172 }
 173
 174 /* Returns non-zero on fault. */
 175 static int save_sigregs_ext(struct pt_regs *regs,
 176                             _sigregs_ext __user *sregs_ext)
 177 {
 178         __u64 vxrs[__NUM_VXRS_LOW];
 179         int i;
 180
 181         /* Save vector registers to signal stack */
 182         if (is_vx_task(current)) {
 183                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 184                         vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
 185                 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
 186                                    sizeof(sregs_ext->vxrs_low)) ||
 187                     __copy_to_user(&sregs_ext->vxrs_high,
 188                                    current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 189                                    sizeof(sregs_ext->vxrs_high)))
 190                         return -EFAULT;
 191         }
 192         return 0;
 193 }
 194
 195 static int restore_sigregs_ext(struct pt_regs *regs,
 196                                _sigregs_ext __user *sregs_ext)
 197 {
 198         __u64 vxrs[__NUM_VXRS_LOW];
 199         int i;
 200
 201         /* Restore vector registers from signal stack */
 202         if (is_vx_task(current)) {
 203                 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
 204                                      sizeof(sregs_ext->vxrs_low)) ||
 205                     __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 206                                      &sregs_ext->vxrs_high,
 207                                      sizeof(sregs_ext->vxrs_high)))
 208                         return -EFAULT;
 209                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 210                         *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
 211         }
 212         return 0;
 213 }
 214
 215 SYSCALL_DEFINE0(sigreturn)
 216 {
 217         struct pt_regs *regs = task_pt_regs(current);
 218         struct sigframe __user *frame =
 219                 (struct sigframe __user *) regs->gprs[15];
 220         sigset_t set;
 221
 222         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
 223                 goto badframe;
 224         set_current_blocked(&set);
 225         save_fpu_regs();
 226         if (restore_sigregs(regs, &frame->sregs))
 227                 goto badframe;
 228         if (restore_sigregs_ext(regs, &frame->sregs_ext))
 229                 goto badframe;
 230         load_sigregs();
 231         return regs->gprs[2];
 232 badframe:
 233         force_sig(SIGSEGV, current);
 234         return 0;
 235 }
 236
 237 SYSCALL_DEFINE0(rt_sigreturn)
 238 {
 239         struct pt_regs *regs = task_pt_regs(current);
 240         struct rt_sigframe __user *frame =
 241                 (struct rt_sigframe __user *)regs->gprs[15];
 242         sigset_t set;
 243
 244         if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
 245                 goto badframe;
 246         set_current_blocked(&set);
 247         if (restore_altstack(&frame->uc.uc_stack))
 248                 goto badframe;
 249         save_fpu_regs();
 250         if (restore_sigregs(regs, &frame->uc.uc_mcontext))
 251                 goto badframe;
 252         if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
 253                 goto badframe;
 254         load_sigregs();
 255         return regs->gprs[2];
 256 badframe:
 257         force_sig(SIGSEGV, current);
 258         return 0;
 259 }
 260
 261 /*
 262  * Determine which stack to use..
 263  */
 264 static inline void __user *
 265 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 266 {
 267         unsigned long sp;
 268
 269         /* Default to using normal stack */
 270         sp = regs->gprs[15];
 271
 272         /* Overflow on alternate signal stack gives SIGSEGV. */
 273         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
 274                 return (void __user *) -1UL;
 275
 276         /* This is the X/Open sanctioned signal stack switching.  */
 277         if (ka->sa.sa_flags & SA_ONSTACK) {
 278                 if (! sas_ss_flags(sp))
 279                         sp = current->sas_ss_sp + current->sas_ss_size;
 280         }
 281
 282         return (void __user *)((sp - frame_size) & -8ul);
 283 }
 284
 285 static int setup_frame(int sig, struct k_sigaction *ka,
 286                        sigset_t *set, struct pt_regs * regs)
 287 {
 288         struct sigframe __user *frame;
 289         struct sigcontext sc;
 290         unsigned long restorer;
 291         size_t frame_size;
 292
 293         /*
 294          * gprs_high are only present for a 31-bit task running on
 295          * a 64-bit kernel (see compat_signal.c) but the space for
 296          * gprs_high need to be allocated if vector registers are
 297          * included in the signal frame on a 31-bit system.
 298          */
 299         frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
 300         if (MACHINE_HAS_VX)
 301                 frame_size += sizeof(frame->sregs_ext);
 302         frame = get_sigframe(ka, regs, frame_size);
 303         if (frame == (void __user *) -1UL)
 304                 return -EFAULT;
 305
 306         /* Set up backchain. */
 307         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
 308                 return -EFAULT;
 309
 310         /* Create struct sigcontext on the signal stack */
 311         memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
 312         sc.sregs = (_sigregs __user __force *) &frame->sregs;
 313         if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
 314                 return -EFAULT;
 315
 316         /* Store registers needed to create the signal frame */
 317         store_sigregs();
 318
 319         /* Create _sigregs on the signal stack */
 320         if (save_sigregs(regs, &frame->sregs))
 321                 return -EFAULT;
 322
 323         /* Place signal number on stack to allow backtrace from handler.  */
 324         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
 325                 return -EFAULT;
 326
 327         /* Create _sigregs_ext on the signal stack */
 328         if (save_sigregs_ext(regs, &frame->sregs_ext))
 329                 return -EFAULT;
 330
 331         /* Set up to return from userspace.  If provided, use a stub
 332            already in userspace.  */
 333         if (ka->sa.sa_flags & SA_RESTORER) {
 334                 restorer = (unsigned long) ka->sa.sa_restorer | PSW_ADDR_AMODE;
 335         } else {
 336                 /* Signal frame without vector registers are short ! */
 337                 __u16 __user *svc = (void __user *) frame + frame_size - 2;
 338                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
 339                         return -EFAULT;
 340                 restorer = (unsigned long) svc | PSW_ADDR_AMODE;
 341         }
 342
 343         /* Set up registers for signal handler */
 344         regs->gprs[14] = restorer;
 345         regs->gprs[15] = (unsigned long) frame;
 346         /* Force default amode and default user address space control. */
 347         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
 348                 (PSW_USER_BITS & PSW_MASK_ASC) |
 349                 (regs->psw.mask & ~PSW_MASK_ASC);
 350         regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
 351
 352         regs->gprs[2] = sig;
 353         regs->gprs[3] = (unsigned long) &frame->sc;
 354
 355         /* We forgot to include these in the sigcontext.
 356            To avoid breaking binary compatibility, they are passed as args. */
 357         if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
 358             sig == SIGTRAP || sig == SIGFPE) {
 359                 /* set extra registers only for synchronous signals */
 360                 regs->gprs[4] = regs->int_code & 127;
 361                 regs->gprs[5] = regs->int_parm_long;
 362                 regs->gprs[6] = task_thread_info(current)->last_break;
 363         }
 364         return 0;
 365 }
 366
 367 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 368                           struct pt_regs *regs)
 369 {
 370         struct rt_sigframe __user *frame;
 371         unsigned long uc_flags, restorer;
 372         size_t frame_size;
 373
 374         frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
 375         /*
 376          * gprs_high are only present for a 31-bit task running on
 377          * a 64-bit kernel (see compat_signal.c) but the space for
 378          * gprs_high need to be allocated if vector registers are
 379          * included in the signal frame on a 31-bit system.
 380          */
 381         uc_flags = 0;
 382         if (MACHINE_HAS_VX) {
 383                 frame_size += sizeof(_sigregs_ext);
 384                 if (is_vx_task(current))
 385                         uc_flags |= UC_VXRS;
 386         }
 387         frame = get_sigframe(&ksig->ka, regs, frame_size);
 388         if (frame == (void __user *) -1UL)
 389                 return -EFAULT;
 390
 391         /* Set up backchain. */
 392         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
 393                 return -EFAULT;
 394
 395         /* Set up to return from userspace.  If provided, use a stub
 396            already in userspace.  */
 397         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 398                 restorer = (unsigned long)
 399                         ksig->ka.sa.sa_restorer | PSW_ADDR_AMODE;
 400         } else {
 401                 __u16 __user *svc = &frame->svc_insn;
 402                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
 403                         return -EFAULT;
 404                 restorer = (unsigned long) svc | PSW_ADDR_AMODE;
 405         }
 406
 407         /* Create siginfo on the signal stack */
 408         if (copy_siginfo_to_user(&frame->info, &ksig->info))
 409                 return -EFAULT;
 410
 411         /* Store registers needed to create the signal frame */
 412         store_sigregs();
 413
 414         /* Create ucontext on the signal stack. */
 415         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
 416             __put_user(NULL, &frame->uc.uc_link) ||
 417             __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
 418             save_sigregs(regs, &frame->uc.uc_mcontext) ||
 419             __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
 420             save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
 421                 return -EFAULT;
 422
 423         /* Set up registers for signal handler */
 424         regs->gprs[14] = restorer;
 425         regs->gprs[15] = (unsigned long) frame;
 426         /* Force default amode and default user address space control. */
 427         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
 428                 (PSW_USER_BITS & PSW_MASK_ASC) |
 429                 (regs->psw.mask & ~PSW_MASK_ASC);
 430         regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler | PSW_ADDR_AMODE;
 431
 432         regs->gprs[2] = ksig->sig;
 433         regs->gprs[3] = (unsigned long) &frame->info;
 434         regs->gprs[4] = (unsigned long) &frame->uc;
 435         regs->gprs[5] = task_thread_info(current)->last_break;
 436         return 0;
 437 }
 438
 439 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
 440                           struct pt_regs *regs)
 441 {
 442         int ret;
 443
 444         /* Set up the stack frame */
 445         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 446                 ret = setup_rt_frame(ksig, oldset, regs);
 447         else
 448                 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
 449
 450         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
 451 }
 452
 453 /*
 454  * Note that 'init' is a special process: it doesn't get signals it doesn't
 455  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 456  * mistake.
 457  *
 458  * Note that we go through the signals twice: once to check the signals that
 459  * the kernel can handle, and then we build all the user-level signal handling
 460  * stack-frames in one go after that.
 461  */
 462 void do_signal(struct pt_regs *regs)
 463 {
 464         struct ksignal ksig;
 465         sigset_t *oldset = sigmask_to_save();
 466
 467         /*
 468          * Get signal to deliver. When running under ptrace, at this point
 469          * the debugger may change all our registers, including the system
 470          * call information.
 471          */
 472         current_thread_info()->system_call =
 473                 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
 474
 475         if (get_signal(&ksig)) {
 476                 /* Whee!  Actually deliver the signal.  */
 477                 if (current_thread_info()->system_call) {
 478                         regs->int_code = current_thread_info()->system_call;
 479                         /* Check for system call restarting. */
 480                         switch (regs->gprs[2]) {
 481                         case -ERESTART_RESTARTBLOCK:
 482                         case -ERESTARTNOHAND:
 483                                 regs->gprs[2] = -EINTR;
 484                                 break;
 485                         case -ERESTARTSYS:
 486                                 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
 487                                         regs->gprs[2] = -EINTR;
 488                                         break;
 489                                 }
 490                         /* fallthrough */
 491                         case -ERESTARTNOINTR:
 492                                 regs->gprs[2] = regs->orig_gpr2;
 493                                 regs->psw.addr =
 494                                         __rewind_psw(regs->psw,
 495                                                      regs->int_code >> 16);
 496                                 break;
 497                         }
 498                 }
 499                 /* No longer in a system call */
 500                 clear_pt_regs_flag(regs, PIF_SYSCALL);
 501
 502                 if (is_compat_task())
 503                         handle_signal32(&ksig, oldset, regs);
 504                 else
 505                         handle_signal(&ksig, oldset, regs);
 506                 return;
 507         }
 508
 509         /* No handlers present - check for system call restart */
 510         clear_pt_regs_flag(regs, PIF_SYSCALL);
 511         if (current_thread_info()->system_call) {
 512                 regs->int_code = current_thread_info()->system_call;
 513                 switch (regs->gprs[2]) {
 514                 case -ERESTART_RESTARTBLOCK:
 515                         /* Restart with sys_restart_syscall */
 516                         regs->int_code = __NR_restart_syscall;
 517                 /* fallthrough */
 518                 case -ERESTARTNOHAND:
 519                 case -ERESTARTSYS:
 520                 case -ERESTARTNOINTR:
 521                         /* Restart system call with magic TIF bit. */
 522                         regs->gprs[2] = regs->orig_gpr2;
 523                         set_pt_regs_flag(regs, PIF_SYSCALL);
 524                         if (test_thread_flag(TIF_SINGLE_STEP))
 525                                 clear_pt_regs_flag(regs, PIF_PER_TRAP);
 526                         break;
 527                 }
 528         }
 529
 530         /*
 531          * If there's no signal to deliver, we just put the saved sigmask back.
 532          */
 533         restore_saved_sigmask();
 534 }
 535
 536 void do_notify_resume(struct pt_regs *regs)
 537 {
 538         clear_thread_flag(TIF_NOTIFY_RESUME);
 539         tracehook_notify_resume(regs);
 540 }