1 /* 2 * Copyright IBM Corp. 2000, 2006 3 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 4 * Gerhard Tonn (ton@de.ibm.com) 5 * 6 * Copyright (C) 1991, 1992 Linus Torvalds 7 * 8 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 9 */ 10 11 #include <linux/compat.h> 12 #include <linux/sched.h> 13 #include <linux/sched/task_stack.h> 14 #include <linux/mm.h> 15 #include <linux/smp.h> 16 #include <linux/kernel.h> 17 #include <linux/signal.h> 18 #include <linux/errno.h> 19 #include <linux/wait.h> 20 #include <linux/ptrace.h> 21 #include <linux/unistd.h> 22 #include <linux/stddef.h> 23 #include <linux/tty.h> 24 #include <linux/personality.h> 25 #include <linux/binfmts.h> 26 #include <asm/ucontext.h> 27 #include <linux/uaccess.h> 28 #include <asm/lowcore.h> 29 #include <asm/switch_to.h> 30 #include "compat_linux.h" 31 #include "compat_ptrace.h" 32 #include "entry.h" 33 34 typedef struct 35 { 36 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 37 struct sigcontext32 sc; 38 _sigregs32 sregs; 39 int signo; 40 _sigregs_ext32 sregs_ext; 41 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ 42 } sigframe32; 43 44 typedef struct 45 { 46 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 47 __u16 svc_insn; 48 compat_siginfo_t info; 49 struct ucontext32 uc; 50 } rt_sigframe32; 51 52 static inline void sigset_to_sigset32(unsigned long *set64, 53 compat_sigset_word *set32) 54 { 55 set32[0] = (compat_sigset_word) set64[0]; 56 set32[1] = (compat_sigset_word)(set64[0] >> 32); 57 } 58 59 static inline void sigset32_to_sigset(compat_sigset_word *set32, 60 unsigned long *set64) 61 { 62 set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32); 63 } 64 65 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from) 66 { 67 int err; 68 69 /* If you change siginfo_t structure, please be sure 70 this code is fixed accordingly. 71 It should never copy any pad contained in the structure 72 to avoid security leaks, but must copy the generic 73 3 ints plus the relevant union member. 74 This routine must convert siginfo from 64bit to 32bit as well 75 at the same time. */ 76 err = __put_user(from->si_signo, &to->si_signo); 77 err |= __put_user(from->si_errno, &to->si_errno); 78 err |= __put_user(from->si_code, &to->si_code); 79 if (from->si_code < 0) 80 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 81 else { 82 switch (siginfo_layout(from->si_signo, from->si_code)) { 83 case SIL_RT: 84 err |= __put_user(from->si_int, &to->si_int); 85 /* fallthrough */ 86 case SIL_KILL: 87 err |= __put_user(from->si_pid, &to->si_pid); 88 err |= __put_user(from->si_uid, &to->si_uid); 89 break; 90 case SIL_CHLD: 91 err |= __put_user(from->si_pid, &to->si_pid); 92 err |= __put_user(from->si_uid, &to->si_uid); 93 err |= __put_user(from->si_utime, &to->si_utime); 94 err |= __put_user(from->si_stime, &to->si_stime); 95 err |= __put_user(from->si_status, &to->si_status); 96 break; 97 case SIL_FAULT: 98 err |= __put_user((unsigned long) from->si_addr, 99 &to->si_addr); 100 break; 101 case SIL_POLL: 102 err |= __put_user(from->si_band, &to->si_band); 103 err |= __put_user(from->si_fd, &to->si_fd); 104 break; 105 case SIL_TIMER: 106 err |= __put_user(from->si_tid, &to->si_tid); 107 err |= __put_user(from->si_overrun, &to->si_overrun); 108 err |= __put_user(from->si_int, &to->si_int); 109 break; 110 default: 111 break; 112 } 113 } 114 return err ? -EFAULT : 0; 115 } 116 117 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 118 { 119 int err; 120 u32 tmp; 121 122 err = __get_user(to->si_signo, &from->si_signo); 123 err |= __get_user(to->si_errno, &from->si_errno); 124 err |= __get_user(to->si_code, &from->si_code); 125 126 if (to->si_code < 0) 127 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 128 else { 129 switch (siginfo_layout(to->si_signo, to->si_code)) { 130 case SIL_RT: 131 err |= __get_user(to->si_int, &from->si_int); 132 /* fallthrough */ 133 case SIL_KILL: 134 err |= __get_user(to->si_pid, &from->si_pid); 135 err |= __get_user(to->si_uid, &from->si_uid); 136 break; 137 case SIL_CHLD: 138 err |= __get_user(to->si_pid, &from->si_pid); 139 err |= __get_user(to->si_uid, &from->si_uid); 140 err |= __get_user(to->si_utime, &from->si_utime); 141 err |= __get_user(to->si_stime, &from->si_stime); 142 err |= __get_user(to->si_status, &from->si_status); 143 break; 144 case SIL_FAULT: 145 err |= __get_user(tmp, &from->si_addr); 146 to->si_addr = (void __force __user *) 147 (u64) (tmp & PSW32_ADDR_INSN); 148 break; 149 case SIL_POLL: 150 err |= __get_user(to->si_band, &from->si_band); 151 err |= __get_user(to->si_fd, &from->si_fd); 152 break; 153 case SIL_TIMER: 154 err |= __get_user(to->si_tid, &from->si_tid); 155 err |= __get_user(to->si_overrun, &from->si_overrun); 156 err |= __get_user(to->si_int, &from->si_int); 157 break; 158 default: 159 break; 160 } 161 } 162 return err ? -EFAULT : 0; 163 } 164 165 /* Store registers needed to create the signal frame */ 166 static void store_sigregs(void) 167 { 168 save_access_regs(current->thread.acrs); 169 save_fpu_regs(); 170 } 171 172 /* Load registers after signal return */ 173 static void load_sigregs(void) 174 { 175 restore_access_regs(current->thread.acrs); 176 } 177 178 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 179 { 180 _sigregs32 user_sregs; 181 int i; 182 183 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32); 184 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI; 185 user_sregs.regs.psw.mask |= PSW32_USER_BITS; 186 user_sregs.regs.psw.addr = (__u32) regs->psw.addr | 187 (__u32)(regs->psw.mask & PSW_MASK_BA); 188 for (i = 0; i < NUM_GPRS; i++) 189 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i]; 190 memcpy(&user_sregs.regs.acrs, current->thread.acrs, 191 sizeof(user_sregs.regs.acrs)); 192 fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 193 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32))) 194 return -EFAULT; 195 return 0; 196 } 197 198 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 199 { 200 _sigregs32 user_sregs; 201 int i; 202 203 /* Alwys make any pending restarted system call return -EINTR */ 204 current->restart_block.fn = do_no_restart_syscall; 205 206 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs))) 207 return -EFAULT; 208 209 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI)) 210 return -EINVAL; 211 212 /* Test the floating-point-control word. */ 213 if (test_fp_ctl(user_sregs.fpregs.fpc)) 214 return -EINVAL; 215 216 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */ 217 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) | 218 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 | 219 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 | 220 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE); 221 /* Check for invalid user address space control. */ 222 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) 223 regs->psw.mask = PSW_ASC_PRIMARY | 224 (regs->psw.mask & ~PSW_MASK_ASC); 225 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN); 226 for (i = 0; i < NUM_GPRS; i++) 227 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i]; 228 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, 229 sizeof(current->thread.acrs)); 230 fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 231 232 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */ 233 return 0; 234 } 235 236 static int save_sigregs_ext32(struct pt_regs *regs, 237 _sigregs_ext32 __user *sregs_ext) 238 { 239 __u32 gprs_high[NUM_GPRS]; 240 __u64 vxrs[__NUM_VXRS_LOW]; 241 int i; 242 243 /* Save high gprs to signal stack */ 244 for (i = 0; i < NUM_GPRS; i++) 245 gprs_high[i] = regs->gprs[i] >> 32; 246 if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high, 247 sizeof(sregs_ext->gprs_high))) 248 return -EFAULT; 249 250 /* Save vector registers to signal stack */ 251 if (MACHINE_HAS_VX) { 252 for (i = 0; i < __NUM_VXRS_LOW; i++) 253 vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1); 254 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs, 255 sizeof(sregs_ext->vxrs_low)) || 256 __copy_to_user(&sregs_ext->vxrs_high, 257 current->thread.fpu.vxrs + __NUM_VXRS_LOW, 258 sizeof(sregs_ext->vxrs_high))) 259 return -EFAULT; 260 } 261 return 0; 262 } 263 264 static int restore_sigregs_ext32(struct pt_regs *regs, 265 _sigregs_ext32 __user *sregs_ext) 266 { 267 __u32 gprs_high[NUM_GPRS]; 268 __u64 vxrs[__NUM_VXRS_LOW]; 269 int i; 270 271 /* Restore high gprs from signal stack */ 272 if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high, 273 sizeof(sregs_ext->gprs_high))) 274 return -EFAULT; 275 for (i = 0; i < NUM_GPRS; i++) 276 *(__u32 *)®s->gprs[i] = gprs_high[i]; 277 278 /* Restore vector registers from signal stack */ 279 if (MACHINE_HAS_VX) { 280 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low, 281 sizeof(sregs_ext->vxrs_low)) || 282 __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW, 283 &sregs_ext->vxrs_high, 284 sizeof(sregs_ext->vxrs_high))) 285 return -EFAULT; 286 for (i = 0; i < __NUM_VXRS_LOW; i++) 287 *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i]; 288 } 289 return 0; 290 } 291 292 COMPAT_SYSCALL_DEFINE0(sigreturn) 293 { 294 struct pt_regs *regs = task_pt_regs(current); 295 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 296 compat_sigset_t cset; 297 sigset_t set; 298 299 if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 300 goto badframe; 301 sigset32_to_sigset(cset.sig, set.sig); 302 set_current_blocked(&set); 303 save_fpu_regs(); 304 if (restore_sigregs32(regs, &frame->sregs)) 305 goto badframe; 306 if (restore_sigregs_ext32(regs, &frame->sregs_ext)) 307 goto badframe; 308 load_sigregs(); 309 return regs->gprs[2]; 310 badframe: 311 force_sig(SIGSEGV, current); 312 return 0; 313 } 314 315 COMPAT_SYSCALL_DEFINE0(rt_sigreturn) 316 { 317 struct pt_regs *regs = task_pt_regs(current); 318 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 319 compat_sigset_t cset; 320 sigset_t set; 321 322 if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset))) 323 goto badframe; 324 sigset32_to_sigset(cset.sig, set.sig); 325 set_current_blocked(&set); 326 if (compat_restore_altstack(&frame->uc.uc_stack)) 327 goto badframe; 328 save_fpu_regs(); 329 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 330 goto badframe; 331 if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 332 goto badframe; 333 load_sigregs(); 334 return regs->gprs[2]; 335 badframe: 336 force_sig(SIGSEGV, current); 337 return 0; 338 } 339 340 /* 341 * Set up a signal frame. 342 */ 343 344 345 /* 346 * Determine which stack to use.. 347 */ 348 static inline void __user * 349 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 350 { 351 unsigned long sp; 352 353 /* Default to using normal stack */ 354 sp = (unsigned long) A(regs->gprs[15]); 355 356 /* Overflow on alternate signal stack gives SIGSEGV. */ 357 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 358 return (void __user *) -1UL; 359 360 /* This is the X/Open sanctioned signal stack switching. */ 361 if (ka->sa.sa_flags & SA_ONSTACK) { 362 if (! sas_ss_flags(sp)) 363 sp = current->sas_ss_sp + current->sas_ss_size; 364 } 365 366 return (void __user *)((sp - frame_size) & -8ul); 367 } 368 369 static int setup_frame32(struct ksignal *ksig, sigset_t *set, 370 struct pt_regs *regs) 371 { 372 int sig = ksig->sig; 373 sigframe32 __user *frame; 374 struct sigcontext32 sc; 375 unsigned long restorer; 376 size_t frame_size; 377 378 /* 379 * gprs_high are always present for 31-bit compat tasks. 380 * The space for vector registers is only allocated if 381 * the machine supports it 382 */ 383 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved); 384 if (!MACHINE_HAS_VX) 385 frame_size -= sizeof(frame->sregs_ext.vxrs_low) + 386 sizeof(frame->sregs_ext.vxrs_high); 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], (unsigned int __user *) frame)) 393 return -EFAULT; 394 395 /* Create struct sigcontext32 on the signal stack */ 396 sigset_to_sigset32(set->sig, sc.oldmask); 397 sc.sregs = (__u32)(unsigned long __force) &frame->sregs; 398 if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc))) 399 return -EFAULT; 400 401 /* Store registers needed to create the signal frame */ 402 store_sigregs(); 403 404 /* Create _sigregs32 on the signal stack */ 405 if (save_sigregs32(regs, &frame->sregs)) 406 return -EFAULT; 407 408 /* Place signal number on stack to allow backtrace from handler. */ 409 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo)) 410 return -EFAULT; 411 412 /* Create _sigregs_ext32 on the signal stack */ 413 if (save_sigregs_ext32(regs, &frame->sregs_ext)) 414 return -EFAULT; 415 416 /* Set up to return from userspace. If provided, use a stub 417 already in userspace. */ 418 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 419 restorer = (unsigned long __force) 420 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 421 } else { 422 /* Signal frames without vectors registers are short ! */ 423 __u16 __user *svc = (void __user *) frame + frame_size - 2; 424 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc)) 425 return -EFAULT; 426 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 427 } 428 429 /* Set up registers for signal handler */ 430 regs->gprs[14] = restorer; 431 regs->gprs[15] = (__force __u64) frame; 432 /* Force 31 bit amode and default user address space control. */ 433 regs->psw.mask = PSW_MASK_BA | 434 (PSW_USER_BITS & PSW_MASK_ASC) | 435 (regs->psw.mask & ~PSW_MASK_ASC); 436 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler; 437 438 regs->gprs[2] = sig; 439 regs->gprs[3] = (__force __u64) &frame->sc; 440 441 /* We forgot to include these in the sigcontext. 442 To avoid breaking binary compatibility, they are passed as args. */ 443 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 444 sig == SIGTRAP || sig == SIGFPE) { 445 /* set extra registers only for synchronous signals */ 446 regs->gprs[4] = regs->int_code & 127; 447 regs->gprs[5] = regs->int_parm_long; 448 regs->gprs[6] = current->thread.last_break; 449 } 450 451 return 0; 452 } 453 454 static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set, 455 struct pt_regs *regs) 456 { 457 compat_sigset_t cset; 458 rt_sigframe32 __user *frame; 459 unsigned long restorer; 460 size_t frame_size; 461 u32 uc_flags; 462 463 frame_size = sizeof(*frame) - 464 sizeof(frame->uc.uc_mcontext_ext.__reserved); 465 /* 466 * gprs_high are always present for 31-bit compat tasks. 467 * The space for vector registers is only allocated if 468 * the machine supports it 469 */ 470 uc_flags = UC_GPRS_HIGH; 471 if (MACHINE_HAS_VX) { 472 uc_flags |= UC_VXRS; 473 } else 474 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) + 475 sizeof(frame->uc.uc_mcontext_ext.vxrs_high); 476 frame = get_sigframe(&ksig->ka, regs, frame_size); 477 if (frame == (void __user *) -1UL) 478 return -EFAULT; 479 480 /* Set up backchain. */ 481 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 482 return -EFAULT; 483 484 /* Set up to return from userspace. If provided, use a stub 485 already in userspace. */ 486 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 487 restorer = (unsigned long __force) 488 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 489 } else { 490 __u16 __user *svc = &frame->svc_insn; 491 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc)) 492 return -EFAULT; 493 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 494 } 495 496 /* Create siginfo on the signal stack */ 497 if (copy_siginfo_to_user32(&frame->info, &ksig->info)) 498 return -EFAULT; 499 500 /* Store registers needed to create the signal frame */ 501 store_sigregs(); 502 503 /* Create ucontext on the signal stack. */ 504 sigset_to_sigset32(set->sig, cset.sig); 505 if (__put_user(uc_flags, &frame->uc.uc_flags) || 506 __put_user(0, &frame->uc.uc_link) || 507 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || 508 save_sigregs32(regs, &frame->uc.uc_mcontext) || 509 __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) || 510 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 511 return -EFAULT; 512 513 /* Set up registers for signal handler */ 514 regs->gprs[14] = restorer; 515 regs->gprs[15] = (__force __u64) frame; 516 /* Force 31 bit amode and default user address space control. */ 517 regs->psw.mask = PSW_MASK_BA | 518 (PSW_USER_BITS & PSW_MASK_ASC) | 519 (regs->psw.mask & ~PSW_MASK_ASC); 520 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler; 521 522 regs->gprs[2] = ksig->sig; 523 regs->gprs[3] = (__force __u64) &frame->info; 524 regs->gprs[4] = (__force __u64) &frame->uc; 525 regs->gprs[5] = current->thread.last_break; 526 return 0; 527 } 528 529 /* 530 * OK, we're invoking a handler 531 */ 532 533 void handle_signal32(struct ksignal *ksig, sigset_t *oldset, 534 struct pt_regs *regs) 535 { 536 int ret; 537 538 /* Set up the stack frame */ 539 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 540 ret = setup_rt_frame32(ksig, oldset, regs); 541 else 542 ret = setup_frame32(ksig, oldset, regs); 543 544 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); 545 } 546 547