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