1// SPDX-License-Identifier: GPL-2.0 2/* linux/arch/sparc/kernel/signal.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx) 7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) 8 */ 9 10#include <linux/sched.h> 11#include <linux/kernel.h> 12#include <linux/signal.h> 13#include <linux/errno.h> 14#include <linux/wait.h> 15#include <linux/ptrace.h> 16#include <linux/unistd.h> 17#include <linux/mm.h> 18#include <linux/tty.h> 19#include <linux/smp.h> 20#include <linux/binfmts.h> /* do_coredum */ 21#include <linux/bitops.h> 22#include <linux/resume_user_mode.h> 23 24#include <linux/uaccess.h> 25#include <asm/ptrace.h> 26#include <asm/cacheflush.h> /* flush_sig_insns */ 27#include <asm/switch_to.h> 28 29#include "sigutil.h" 30#include "kernel.h" 31 32extern void fpsave(unsigned long *fpregs, unsigned long *fsr, 33 void *fpqueue, unsigned long *fpqdepth); 34extern void fpload(unsigned long *fpregs, unsigned long *fsr); 35 36struct signal_frame { 37 struct sparc_stackf ss; 38 __siginfo32_t info; 39 __siginfo_fpu_t __user *fpu_save; 40 unsigned long insns[2] __attribute__ ((aligned (8))); 41 unsigned int extramask[_NSIG_WORDS - 1]; 42 unsigned int extra_size; /* Should be 0 */ 43 __siginfo_rwin_t __user *rwin_save; 44} __attribute__((aligned(8))); 45 46struct rt_signal_frame { 47 struct sparc_stackf ss; 48 siginfo_t info; 49 struct pt_regs regs; 50 sigset_t mask; 51 __siginfo_fpu_t __user *fpu_save; 52 unsigned int insns[2]; 53 stack_t stack; 54 unsigned int extra_size; /* Should be 0 */ 55 __siginfo_rwin_t __user *rwin_save; 56} __attribute__((aligned(8))); 57 58/* Align macros */ 59#define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7))) 60#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7))) 61 62/* Checks if the fp is valid. We always build signal frames which are 63 * 16-byte aligned, therefore we can always enforce that the restore 64 * frame has that property as well. 65 */ 66static inline bool invalid_frame_pointer(void __user *fp, int fplen) 67{ 68 if ((((unsigned long) fp) & 15) || !access_ok(fp, fplen)) 69 return true; 70 71 return false; 72} 73 74asmlinkage void do_sigreturn(struct pt_regs *regs) 75{ 76 unsigned long up_psr, pc, npc, ufp; 77 struct signal_frame __user *sf; 78 sigset_t set; 79 __siginfo_fpu_t __user *fpu_save; 80 __siginfo_rwin_t __user *rwin_save; 81 int err; 82 83 /* Always make any pending restarted system calls return -EINTR */ 84 current->restart_block.fn = do_no_restart_syscall; 85 86 synchronize_user_stack(); 87 88 sf = (struct signal_frame __user *) regs->u_regs[UREG_FP]; 89 90 /* 1. Make sure we are not getting garbage from the user */ 91 if (invalid_frame_pointer(sf, sizeof(*sf))) 92 goto segv_and_exit; 93 94 if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP])) 95 goto segv_and_exit; 96 97 if (ufp & 0x7) 98 goto segv_and_exit; 99 100 err = __get_user(pc, &sf->info.si_regs.pc); 101 err |= __get_user(npc, &sf->info.si_regs.npc); 102 103 if ((pc | npc) & 3) 104 goto segv_and_exit; 105 106 /* 2. Restore the state */ 107 up_psr = regs->psr; 108 err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs)); 109 110 /* User can only change condition codes and FPU enabling in %psr. */ 111 regs->psr = (up_psr & ~(PSR_ICC | PSR_EF)) 112 | (regs->psr & (PSR_ICC | PSR_EF)); 113 114 /* Prevent syscall restart. */ 115 pt_regs_clear_syscall(regs); 116 117 err |= __get_user(fpu_save, &sf->fpu_save); 118 if (fpu_save) 119 err |= restore_fpu_state(regs, fpu_save); 120 err |= __get_user(rwin_save, &sf->rwin_save); 121 if (rwin_save) 122 err |= restore_rwin_state(rwin_save); 123 124 /* This is pretty much atomic, no amount locking would prevent 125 * the races which exist anyways. 126 */ 127 err |= __get_user(set.sig[0], &sf->info.si_mask); 128 err |= __copy_from_user(&set.sig[1], &sf->extramask, 129 (_NSIG_WORDS-1) * sizeof(unsigned int)); 130 131 if (err) 132 goto segv_and_exit; 133 134 set_current_blocked(&set); 135 return; 136 137segv_and_exit: 138 force_sig(SIGSEGV); 139} 140 141asmlinkage void do_rt_sigreturn(struct pt_regs *regs) 142{ 143 struct rt_signal_frame __user *sf; 144 unsigned int psr, pc, npc, ufp; 145 __siginfo_fpu_t __user *fpu_save; 146 __siginfo_rwin_t __user *rwin_save; 147 sigset_t set; 148 int err; 149 150 synchronize_user_stack(); 151 sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP]; 152 if (invalid_frame_pointer(sf, sizeof(*sf))) 153 goto segv; 154 155 if (get_user(ufp, &sf->regs.u_regs[UREG_FP])) 156 goto segv; 157 158 if (ufp & 0x7) 159 goto segv; 160 161 err = __get_user(pc, &sf->regs.pc); 162 err |= __get_user(npc, &sf->regs.npc); 163 err |= ((pc | npc) & 0x03); 164 165 err |= __get_user(regs->y, &sf->regs.y); 166 err |= __get_user(psr, &sf->regs.psr); 167 168 err |= __copy_from_user(®s->u_regs[UREG_G1], 169 &sf->regs.u_regs[UREG_G1], 15 * sizeof(u32)); 170 171 regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC); 172 173 /* Prevent syscall restart. */ 174 pt_regs_clear_syscall(regs); 175 176 err |= __get_user(fpu_save, &sf->fpu_save); 177 if (!err && fpu_save) 178 err |= restore_fpu_state(regs, fpu_save); 179 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); 180 err |= restore_altstack(&sf->stack); 181 182 if (err) 183 goto segv; 184 185 regs->pc = pc; 186 regs->npc = npc; 187 188 err |= __get_user(rwin_save, &sf->rwin_save); 189 if (!err && rwin_save) { 190 if (restore_rwin_state(rwin_save)) 191 goto segv; 192 } 193 194 set_current_blocked(&set); 195 return; 196segv: 197 force_sig(SIGSEGV); 198} 199 200static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize) 201{ 202 unsigned long sp = regs->u_regs[UREG_FP]; 203 204 /* 205 * If we are on the alternate signal stack and would overflow it, don't. 206 * Return an always-bogus address instead so we will die with SIGSEGV. 207 */ 208 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) 209 return (void __user *) -1L; 210 211 /* This is the X/Open sanctioned signal stack switching. */ 212 sp = sigsp(sp, ksig) - framesize; 213 214 /* Always align the stack frame. This handles two cases. First, 215 * sigaltstack need not be mindful of platform specific stack 216 * alignment. Second, if we took this signal because the stack 217 * is not aligned properly, we'd like to take the signal cleanly 218 * and report that. 219 */ 220 sp &= ~15UL; 221 222 return (void __user *) sp; 223} 224 225static int setup_frame(struct ksignal *ksig, struct pt_regs *regs, 226 sigset_t *oldset) 227{ 228 struct signal_frame __user *sf; 229 int sigframe_size, err, wsaved; 230 void __user *tail; 231 232 /* 1. Make sure everything is clean */ 233 synchronize_user_stack(); 234 235 wsaved = current_thread_info()->w_saved; 236 237 sigframe_size = sizeof(*sf); 238 if (used_math()) 239 sigframe_size += sizeof(__siginfo_fpu_t); 240 if (wsaved) 241 sigframe_size += sizeof(__siginfo_rwin_t); 242 243 sf = (struct signal_frame __user *) 244 get_sigframe(ksig, regs, sigframe_size); 245 246 if (invalid_frame_pointer(sf, sigframe_size)) { 247 force_exit_sig(SIGILL); 248 return -EINVAL; 249 } 250 251 tail = sf + 1; 252 253 /* 2. Save the current process state */ 254 err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs)); 255 256 err |= __put_user(0, &sf->extra_size); 257 258 if (used_math()) { 259 __siginfo_fpu_t __user *fp = tail; 260 tail += sizeof(*fp); 261 err |= save_fpu_state(regs, fp); 262 err |= __put_user(fp, &sf->fpu_save); 263 } else { 264 err |= __put_user(0, &sf->fpu_save); 265 } 266 if (wsaved) { 267 __siginfo_rwin_t __user *rwp = tail; 268 tail += sizeof(*rwp); 269 err |= save_rwin_state(wsaved, rwp); 270 err |= __put_user(rwp, &sf->rwin_save); 271 } else { 272 err |= __put_user(0, &sf->rwin_save); 273 } 274 275 err |= __put_user(oldset->sig[0], &sf->info.si_mask); 276 err |= __copy_to_user(sf->extramask, &oldset->sig[1], 277 (_NSIG_WORDS - 1) * sizeof(unsigned int)); 278 if (!wsaved) { 279 err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], 280 sizeof(struct reg_window32)); 281 } else { 282 struct reg_window32 *rp; 283 284 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 285 err |= __copy_to_user(sf, rp, sizeof(struct reg_window32)); 286 } 287 if (err) 288 return err; 289 290 /* 3. signal handler back-trampoline and parameters */ 291 regs->u_regs[UREG_FP] = (unsigned long) sf; 292 regs->u_regs[UREG_I0] = ksig->sig; 293 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 294 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 295 296 /* 4. signal handler */ 297 regs->pc = (unsigned long) ksig->ka.sa.sa_handler; 298 regs->npc = (regs->pc + 4); 299 300 /* 5. return to kernel instructions */ 301 if (ksig->ka.ka_restorer) 302 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 303 else { 304 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2); 305 306 /* mov __NR_sigreturn, %g1 */ 307 err |= __put_user(0x821020d8, &sf->insns[0]); 308 309 /* t 0x10 */ 310 err |= __put_user(0x91d02010, &sf->insns[1]); 311 if (err) 312 return err; 313 314 /* Flush instruction space. */ 315 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 316 } 317 return 0; 318} 319 320static int setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs, 321 sigset_t *oldset) 322{ 323 struct rt_signal_frame __user *sf; 324 int sigframe_size, wsaved; 325 void __user *tail; 326 unsigned int psr; 327 int err; 328 329 synchronize_user_stack(); 330 wsaved = current_thread_info()->w_saved; 331 sigframe_size = sizeof(*sf); 332 if (used_math()) 333 sigframe_size += sizeof(__siginfo_fpu_t); 334 if (wsaved) 335 sigframe_size += sizeof(__siginfo_rwin_t); 336 sf = (struct rt_signal_frame __user *) 337 get_sigframe(ksig, regs, sigframe_size); 338 if (invalid_frame_pointer(sf, sigframe_size)) { 339 force_exit_sig(SIGILL); 340 return -EINVAL; 341 } 342 343 tail = sf + 1; 344 err = __put_user(regs->pc, &sf->regs.pc); 345 err |= __put_user(regs->npc, &sf->regs.npc); 346 err |= __put_user(regs->y, &sf->regs.y); 347 psr = regs->psr; 348 if (used_math()) 349 psr |= PSR_EF; 350 err |= __put_user(psr, &sf->regs.psr); 351 err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs)); 352 err |= __put_user(0, &sf->extra_size); 353 354 if (psr & PSR_EF) { 355 __siginfo_fpu_t __user *fp = tail; 356 tail += sizeof(*fp); 357 err |= save_fpu_state(regs, fp); 358 err |= __put_user(fp, &sf->fpu_save); 359 } else { 360 err |= __put_user(0, &sf->fpu_save); 361 } 362 if (wsaved) { 363 __siginfo_rwin_t __user *rwp = tail; 364 tail += sizeof(*rwp); 365 err |= save_rwin_state(wsaved, rwp); 366 err |= __put_user(rwp, &sf->rwin_save); 367 } else { 368 err |= __put_user(0, &sf->rwin_save); 369 } 370 err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t)); 371 372 /* Setup sigaltstack */ 373 err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]); 374 375 if (!wsaved) { 376 err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP], 377 sizeof(struct reg_window32)); 378 } else { 379 struct reg_window32 *rp; 380 381 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 382 err |= __copy_to_user(sf, rp, sizeof(struct reg_window32)); 383 } 384 385 err |= copy_siginfo_to_user(&sf->info, &ksig->info); 386 387 if (err) 388 return err; 389 390 regs->u_regs[UREG_FP] = (unsigned long) sf; 391 regs->u_regs[UREG_I0] = ksig->sig; 392 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 393 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs; 394 395 regs->pc = (unsigned long) ksig->ka.sa.sa_handler; 396 regs->npc = (regs->pc + 4); 397 398 if (ksig->ka.ka_restorer) 399 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 400 else { 401 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2); 402 403 /* mov __NR_rt_sigreturn, %g1 */ 404 err |= __put_user(0x82102065, &sf->insns[0]); 405 406 /* t 0x10 */ 407 err |= __put_user(0x91d02010, &sf->insns[1]); 408 if (err) 409 return err; 410 411 /* Flush instruction space. */ 412 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); 413 } 414 return 0; 415} 416 417static inline void 418handle_signal(struct ksignal *ksig, struct pt_regs *regs) 419{ 420 sigset_t *oldset = sigmask_to_save(); 421 int err; 422 423 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 424 err = setup_rt_frame(ksig, regs, oldset); 425 else 426 err = setup_frame(ksig, regs, oldset); 427 signal_setup_done(err, ksig, 0); 428} 429 430static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, 431 struct sigaction *sa) 432{ 433 switch(regs->u_regs[UREG_I0]) { 434 case ERESTART_RESTARTBLOCK: 435 case ERESTARTNOHAND: 436 no_system_call_restart: 437 regs->u_regs[UREG_I0] = EINTR; 438 regs->psr |= PSR_C; 439 break; 440 case ERESTARTSYS: 441 if (!(sa->sa_flags & SA_RESTART)) 442 goto no_system_call_restart; 443 fallthrough; 444 case ERESTARTNOINTR: 445 regs->u_regs[UREG_I0] = orig_i0; 446 regs->pc -= 4; 447 regs->npc -= 4; 448 } 449} 450 451/* Note that 'init' is a special process: it doesn't get signals it doesn't 452 * want to handle. Thus you cannot kill init even with a SIGKILL even by 453 * mistake. 454 */ 455static void do_signal(struct pt_regs *regs, unsigned long orig_i0) 456{ 457 struct ksignal ksig; 458 int restart_syscall; 459 bool has_handler; 460 461 /* It's a lot of work and synchronization to add a new ptrace 462 * register for GDB to save and restore in order to get 463 * orig_i0 correct for syscall restarts when debugging. 464 * 465 * Although it should be the case that most of the global 466 * registers are volatile across a system call, glibc already 467 * depends upon that fact that we preserve them. So we can't 468 * just use any global register to save away the orig_i0 value. 469 * 470 * In particular %g2, %g3, %g4, and %g5 are all assumed to be 471 * preserved across a system call trap by various pieces of 472 * code in glibc. 473 * 474 * %g7 is used as the "thread register". %g6 is not used in 475 * any fixed manner. %g6 is used as a scratch register and 476 * a compiler temporary, but its value is never used across 477 * a system call. Therefore %g6 is usable for orig_i0 storage. 478 */ 479 if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C)) 480 regs->u_regs[UREG_G6] = orig_i0; 481 482 has_handler = get_signal(&ksig); 483 484 /* If the debugger messes with the program counter, it clears 485 * the software "in syscall" bit, directing us to not perform 486 * a syscall restart. 487 */ 488 restart_syscall = 0; 489 if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C)) { 490 restart_syscall = 1; 491 orig_i0 = regs->u_regs[UREG_G6]; 492 } 493 494 if (has_handler) { 495 if (restart_syscall) 496 syscall_restart(orig_i0, regs, &ksig.ka.sa); 497 handle_signal(&ksig, regs); 498 } else { 499 if (restart_syscall) { 500 switch (regs->u_regs[UREG_I0]) { 501 case ERESTARTNOHAND: 502 case ERESTARTSYS: 503 case ERESTARTNOINTR: 504 /* replay the system call when we are done */ 505 regs->u_regs[UREG_I0] = orig_i0; 506 regs->pc -= 4; 507 regs->npc -= 4; 508 pt_regs_clear_syscall(regs); 509 fallthrough; 510 case ERESTART_RESTARTBLOCK: 511 regs->u_regs[UREG_G1] = __NR_restart_syscall; 512 regs->pc -= 4; 513 regs->npc -= 4; 514 pt_regs_clear_syscall(regs); 515 } 516 } 517 restore_saved_sigmask(); 518 } 519} 520 521void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, 522 unsigned long thread_info_flags) 523{ 524 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) 525 do_signal(regs, orig_i0); 526 if (thread_info_flags & _TIF_NOTIFY_RESUME) 527 resume_user_mode_work(regs); 528} 529 530asmlinkage int do_sys_sigstack(struct sigstack __user *ssptr, 531 struct sigstack __user *ossptr, 532 unsigned long sp) 533{ 534 int ret = -EFAULT; 535 536 /* First see if old state is wanted. */ 537 if (ossptr) { 538 if (put_user(current->sas_ss_sp + current->sas_ss_size, 539 &ossptr->the_stack) || 540 __put_user(on_sig_stack(sp), &ossptr->cur_status)) 541 goto out; 542 } 543 544 /* Now see if we want to update the new state. */ 545 if (ssptr) { 546 char *ss_sp; 547 548 if (get_user(ss_sp, &ssptr->the_stack)) 549 goto out; 550 /* If the current stack was set with sigaltstack, don't 551 swap stacks while we are on it. */ 552 ret = -EPERM; 553 if (current->sas_ss_sp && on_sig_stack(sp)) 554 goto out; 555 556 /* Since we don't know the extent of the stack, and we don't 557 track onstack-ness, but rather calculate it, we must 558 presume a size. Ho hum this interface is lossy. */ 559 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ; 560 current->sas_ss_size = SIGSTKSZ; 561 } 562 ret = 0; 563out: 564 return ret; 565} 566