1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright IBM Corp. 1999, 2006 4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 5 * 6 * Based on Intel version 7 * 8 * Copyright (C) 1991, 1992 Linus Torvalds 9 * 10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 11 */ 12 13#include <linux/sched.h> 14#include <linux/sched/task_stack.h> 15#include <linux/rseq.h> 16#include <linux/mm.h> 17#include <linux/smp.h> 18#include <linux/kernel.h> 19#include <linux/signal.h> 20#include <linux/entry-common.h> 21#include <linux/errno.h> 22#include <linux/wait.h> 23#include <linux/ptrace.h> 24#include <linux/unistd.h> 25#include <linux/stddef.h> 26#include <linux/tty.h> 27#include <linux/personality.h> 28#include <linux/binfmts.h> 29#include <linux/syscalls.h> 30#include <linux/compat.h> 31#include <asm/ucontext.h> 32#include <linux/uaccess.h> 33#include <asm/access-regs.h> 34#include <asm/lowcore.h> 35#include <asm/vdso.h> 36#include "entry.h" 37 38/* 39 * Layout of an old-style signal-frame: 40 * ----------------------------------------- 41 * | save area (_SIGNAL_FRAMESIZE) | 42 * ----------------------------------------- 43 * | struct sigcontext | 44 * | oldmask | 45 * | _sigregs * | 46 * ----------------------------------------- 47 * | _sigregs with | 48 * | _s390_regs_common | 49 * | _s390_fp_regs | 50 * ----------------------------------------- 51 * | int signo | 52 * ----------------------------------------- 53 * | _sigregs_ext with | 54 * | gprs_high 64 byte (opt) | 55 * | vxrs_low 128 byte (opt) | 56 * | vxrs_high 256 byte (opt) | 57 * | reserved 128 byte (opt) | 58 * ----------------------------------------- 59 * | __u16 svc_insn | 60 * ----------------------------------------- 61 * The svc_insn entry with the sigreturn system call opcode does not 62 * have a fixed position and moves if gprs_high or vxrs exist. 63 * Future extensions will be added to _sigregs_ext. 64 */ 65struct sigframe 66{ 67 __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; 68 struct sigcontext sc; 69 _sigregs sregs; 70 int signo; 71 _sigregs_ext sregs_ext; 72 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ 73}; 74 75/* 76 * Layout of an rt signal-frame: 77 * ----------------------------------------- 78 * | save area (_SIGNAL_FRAMESIZE) | 79 * ----------------------------------------- 80 * | svc __NR_rt_sigreturn 2 byte | 81 * ----------------------------------------- 82 * | struct siginfo | 83 * ----------------------------------------- 84 * | struct ucontext_extended with | 85 * | unsigned long uc_flags | 86 * | struct ucontext *uc_link | 87 * | stack_t uc_stack | 88 * | _sigregs uc_mcontext with | 89 * | _s390_regs_common | 90 * | _s390_fp_regs | 91 * | sigset_t uc_sigmask | 92 * | _sigregs_ext uc_mcontext_ext | 93 * | gprs_high 64 byte (opt) | 94 * | vxrs_low 128 byte (opt) | 95 * | vxrs_high 256 byte (opt)| 96 * | reserved 128 byte (opt) | 97 * ----------------------------------------- 98 * Future extensions will be added to _sigregs_ext. 99 */ 100struct rt_sigframe 101{ 102 __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; 103 __u16 svc_insn; 104 struct siginfo info; 105 struct ucontext_extended uc; 106}; 107 108/* Store registers needed to create the signal frame */ 109static void store_sigregs(void) 110{ 111 save_access_regs(current->thread.acrs); 112 save_user_fpu_regs(); 113} 114 115/* Load registers after signal return */ 116static void load_sigregs(void) 117{ 118 restore_access_regs(current->thread.acrs); 119} 120 121/* Returns non-zero on fault. */ 122static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs) 123{ 124 _sigregs user_sregs; 125 126 /* Copy a 'clean' PSW mask to the user to avoid leaking 127 information about whether PER is currently on. */ 128 user_sregs.regs.psw.mask = PSW_USER_BITS | 129 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI)); 130 user_sregs.regs.psw.addr = regs->psw.addr; 131 memcpy(&user_sregs.regs.gprs, ®s->gprs, sizeof(sregs->regs.gprs)); 132 memcpy(&user_sregs.regs.acrs, current->thread.acrs, 133 sizeof(user_sregs.regs.acrs)); 134 fpregs_store(&user_sregs.fpregs, ¤t->thread.ufpu); 135 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs))) 136 return -EFAULT; 137 return 0; 138} 139 140static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs) 141{ 142 _sigregs user_sregs; 143 144 /* Always make any pending restarted system call return -EINTR */ 145 current->restart_block.fn = do_no_restart_syscall; 146 147 if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs))) 148 return -EFAULT; 149 150 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI)) 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(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs)); 165 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, 166 sizeof(current->thread.acrs)); 167 168 fpregs_load(&user_sregs.fpregs, ¤t->thread.ufpu); 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. */ 175static 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 (cpu_has_vx()) { 183 for (i = 0; i < __NUM_VXRS_LOW; i++) 184 vxrs[i] = current->thread.ufpu.vxrs[i].low; 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.ufpu.vxrs + __NUM_VXRS_LOW, 189 sizeof(sregs_ext->vxrs_high))) 190 return -EFAULT; 191 } 192 return 0; 193} 194 195static 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 (cpu_has_vx()) { 203 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low, 204 sizeof(sregs_ext->vxrs_low)) || 205 __copy_from_user(current->thread.ufpu.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 current->thread.ufpu.vxrs[i].low = vxrs[i]; 211 } 212 return 0; 213} 214 215SYSCALL_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_user_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]; 232badframe: 233 force_sig(SIGSEGV); 234 return 0; 235} 236 237SYSCALL_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_user_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]; 256badframe: 257 force_sig(SIGSEGV); 258 return 0; 259} 260 261/* 262 * Determine which stack to use.. 263 */ 264static inline void __user * 265get_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 285static 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 (cpu_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; 335 else 336 restorer = VDSO64_SYMBOL(current, sigreturn); 337 338 /* Set up registers for signal handler */ 339 regs->gprs[14] = restorer; 340 regs->gprs[15] = (unsigned long) frame; 341 /* Force default amode and default user address space control. */ 342 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA | 343 (PSW_USER_BITS & PSW_MASK_ASC) | 344 (regs->psw.mask & ~PSW_MASK_ASC); 345 regs->psw.addr = (unsigned long) ka->sa.sa_handler; 346 347 regs->gprs[2] = sig; 348 regs->gprs[3] = (unsigned long) &frame->sc; 349 350 /* We forgot to include these in the sigcontext. 351 To avoid breaking binary compatibility, they are passed as args. */ 352 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 353 sig == SIGTRAP || sig == SIGFPE) { 354 /* set extra registers only for synchronous signals */ 355 regs->gprs[4] = regs->int_code & 127; 356 regs->gprs[5] = regs->int_parm_long; 357 regs->gprs[6] = current->thread.last_break; 358 } 359 return 0; 360} 361 362static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, 363 struct pt_regs *regs) 364{ 365 struct rt_sigframe __user *frame; 366 unsigned long uc_flags, restorer; 367 size_t frame_size; 368 369 frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext); 370 /* 371 * gprs_high are only present for a 31-bit task running on 372 * a 64-bit kernel (see compat_signal.c) but the space for 373 * gprs_high need to be allocated if vector registers are 374 * included in the signal frame on a 31-bit system. 375 */ 376 uc_flags = 0; 377 if (cpu_has_vx()) { 378 frame_size += sizeof(_sigregs_ext); 379 uc_flags |= UC_VXRS; 380 } 381 frame = get_sigframe(&ksig->ka, regs, frame_size); 382 if (frame == (void __user *) -1UL) 383 return -EFAULT; 384 385 /* Set up backchain. */ 386 if (__put_user(regs->gprs[15], (addr_t __user *) frame)) 387 return -EFAULT; 388 389 /* Set up to return from userspace. If provided, use a stub 390 already in userspace. */ 391 if (ksig->ka.sa.sa_flags & SA_RESTORER) 392 restorer = (unsigned long) ksig->ka.sa.sa_restorer; 393 else 394 restorer = VDSO64_SYMBOL(current, rt_sigreturn); 395 396 /* Create siginfo on the signal stack */ 397 if (copy_siginfo_to_user(&frame->info, &ksig->info)) 398 return -EFAULT; 399 400 /* Store registers needed to create the signal frame */ 401 store_sigregs(); 402 403 /* Create ucontext on the signal stack. */ 404 if (__put_user(uc_flags, &frame->uc.uc_flags) || 405 __put_user(NULL, &frame->uc.uc_link) || 406 __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || 407 save_sigregs(regs, &frame->uc.uc_mcontext) || 408 __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) || 409 save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext)) 410 return -EFAULT; 411 412 /* Set up registers for signal handler */ 413 regs->gprs[14] = restorer; 414 regs->gprs[15] = (unsigned long) frame; 415 /* Force default amode and default user address space control. */ 416 regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA | 417 (PSW_USER_BITS & PSW_MASK_ASC) | 418 (regs->psw.mask & ~PSW_MASK_ASC); 419 regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler; 420 421 regs->gprs[2] = ksig->sig; 422 regs->gprs[3] = (unsigned long) &frame->info; 423 regs->gprs[4] = (unsigned long) &frame->uc; 424 regs->gprs[5] = current->thread.last_break; 425 return 0; 426} 427 428static void handle_signal(struct ksignal *ksig, sigset_t *oldset, 429 struct pt_regs *regs) 430{ 431 int ret; 432 433 /* Set up the stack frame */ 434 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 435 ret = setup_rt_frame(ksig, oldset, regs); 436 else 437 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs); 438 439 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); 440} 441 442/* 443 * Note that 'init' is a special process: it doesn't get signals it doesn't 444 * want to handle. Thus you cannot kill init even with a SIGKILL even by 445 * mistake. 446 * 447 * Note that we go through the signals twice: once to check the signals that 448 * the kernel can handle, and then we build all the user-level signal handling 449 * stack-frames in one go after that. 450 */ 451 452void arch_do_signal_or_restart(struct pt_regs *regs) 453{ 454 struct ksignal ksig; 455 sigset_t *oldset = sigmask_to_save(); 456 457 /* 458 * Get signal to deliver. When running under ptrace, at this point 459 * the debugger may change all our registers, including the system 460 * call information. 461 */ 462 current->thread.system_call = 463 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0; 464 465 if (get_signal(&ksig)) { 466 /* Whee! Actually deliver the signal. */ 467 if (current->thread.system_call) { 468 regs->int_code = current->thread.system_call; 469 /* Check for system call restarting. */ 470 switch (regs->gprs[2]) { 471 case -ERESTART_RESTARTBLOCK: 472 case -ERESTARTNOHAND: 473 regs->gprs[2] = -EINTR; 474 break; 475 case -ERESTARTSYS: 476 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) { 477 regs->gprs[2] = -EINTR; 478 break; 479 } 480 fallthrough; 481 case -ERESTARTNOINTR: 482 regs->gprs[2] = regs->orig_gpr2; 483 regs->psw.addr = 484 __rewind_psw(regs->psw, 485 regs->int_code >> 16); 486 break; 487 } 488 } 489 /* No longer in a system call */ 490 clear_pt_regs_flag(regs, PIF_SYSCALL); 491 492 rseq_signal_deliver(&ksig, regs); 493 if (is_compat_task()) 494 handle_signal32(&ksig, oldset, regs); 495 else 496 handle_signal(&ksig, oldset, regs); 497 return; 498 } 499 500 /* No handlers present - check for system call restart */ 501 clear_pt_regs_flag(regs, PIF_SYSCALL); 502 if (current->thread.system_call) { 503 regs->int_code = current->thread.system_call; 504 switch (regs->gprs[2]) { 505 case -ERESTART_RESTARTBLOCK: 506 /* Restart with sys_restart_syscall */ 507 regs->gprs[2] = regs->orig_gpr2; 508 current->restart_block.arch_data = regs->psw.addr; 509 if (is_compat_task()) 510 regs->psw.addr = VDSO32_SYMBOL(current, restart_syscall); 511 else 512 regs->psw.addr = VDSO64_SYMBOL(current, restart_syscall); 513 if (test_thread_flag(TIF_SINGLE_STEP)) 514 clear_thread_flag(TIF_PER_TRAP); 515 break; 516 case -ERESTARTNOHAND: 517 case -ERESTARTSYS: 518 case -ERESTARTNOINTR: 519 regs->gprs[2] = regs->orig_gpr2; 520 regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16); 521 if (test_thread_flag(TIF_SINGLE_STEP)) 522 clear_thread_flag(TIF_PER_TRAP); 523 break; 524 } 525 } 526 527 /* 528 * If there's no signal to deliver, we just put the saved sigmask back. 529 */ 530 restore_saved_sigmask(); 531} 532