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