1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * arch/sparc64/kernel/signal.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 * Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net) 7 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx) 8 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) 9 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 10 */ 11 12 #ifdef CONFIG_COMPAT 13 #include <linux/compat.h> /* for compat_old_sigset_t */ 14 #endif 15 #include <linux/sched.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/tracehook.h> 22 #include <linux/unistd.h> 23 #include <linux/mm.h> 24 #include <linux/tty.h> 25 #include <linux/binfmts.h> 26 #include <linux/bitops.h> 27 #include <linux/context_tracking.h> 28 29 #include <linux/uaccess.h> 30 #include <asm/ptrace.h> 31 #include <asm/pgtable.h> 32 #include <asm/fpumacro.h> 33 #include <asm/uctx.h> 34 #include <asm/siginfo.h> 35 #include <asm/visasm.h> 36 #include <asm/switch_to.h> 37 #include <asm/cacheflush.h> 38 39 #include "sigutil.h" 40 #include "systbls.h" 41 #include "kernel.h" 42 #include "entry.h" 43 44 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 45 asmlinkage void sparc64_set_context(struct pt_regs *regs) 46 { 47 struct ucontext __user *ucp = (struct ucontext __user *) 48 regs->u_regs[UREG_I0]; 49 enum ctx_state prev_state = exception_enter(); 50 mc_gregset_t __user *grp; 51 unsigned long pc, npc, tstate; 52 unsigned long fp, i7; 53 unsigned char fenab; 54 int err; 55 56 synchronize_user_stack(); 57 if (get_thread_wsaved() || 58 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) || 59 (!__access_ok(ucp, sizeof(*ucp)))) 60 goto do_sigsegv; 61 grp = &ucp->uc_mcontext.mc_gregs; 62 err = __get_user(pc, &((*grp)[MC_PC])); 63 err |= __get_user(npc, &((*grp)[MC_NPC])); 64 if (err || ((pc | npc) & 3)) 65 goto do_sigsegv; 66 if (regs->u_regs[UREG_I1]) { 67 sigset_t set; 68 69 if (_NSIG_WORDS == 1) { 70 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0])) 71 goto do_sigsegv; 72 } else { 73 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t))) 74 goto do_sigsegv; 75 } 76 set_current_blocked(&set); 77 } 78 if (test_thread_flag(TIF_32BIT)) { 79 pc &= 0xffffffff; 80 npc &= 0xffffffff; 81 } 82 regs->tpc = pc; 83 regs->tnpc = npc; 84 err |= __get_user(regs->y, &((*grp)[MC_Y])); 85 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 86 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 87 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 88 err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1])); 89 err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2])); 90 err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3])); 91 err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4])); 92 err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5])); 93 err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6])); 94 95 /* Skip %g7 as that's the thread register in userspace. */ 96 97 err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0])); 98 err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1])); 99 err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2])); 100 err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3])); 101 err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4])); 102 err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5])); 103 err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6])); 104 err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7])); 105 106 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 107 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 108 err |= __put_user(fp, 109 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 110 err |= __put_user(i7, 111 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 112 113 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 114 if (fenab) { 115 unsigned long *fpregs = current_thread_info()->fpregs; 116 unsigned long fprs; 117 118 fprs_write(0); 119 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 120 if (fprs & FPRS_DL) 121 err |= copy_from_user(fpregs, 122 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs), 123 (sizeof(unsigned int) * 32)); 124 if (fprs & FPRS_DU) 125 err |= copy_from_user(fpregs+16, 126 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16, 127 (sizeof(unsigned int) * 32)); 128 err |= __get_user(current_thread_info()->xfsr[0], 129 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 130 err |= __get_user(current_thread_info()->gsr[0], 131 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 132 regs->tstate &= ~TSTATE_PEF; 133 } 134 if (err) 135 goto do_sigsegv; 136 out: 137 exception_exit(prev_state); 138 return; 139 do_sigsegv: 140 force_sig(SIGSEGV, current); 141 goto out; 142 } 143 144 asmlinkage void sparc64_get_context(struct pt_regs *regs) 145 { 146 struct ucontext __user *ucp = (struct ucontext __user *) 147 regs->u_regs[UREG_I0]; 148 enum ctx_state prev_state = exception_enter(); 149 mc_gregset_t __user *grp; 150 mcontext_t __user *mcp; 151 unsigned long fp, i7; 152 unsigned char fenab; 153 int err; 154 155 synchronize_user_stack(); 156 if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp))) 157 goto do_sigsegv; 158 159 #if 1 160 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */ 161 #else 162 fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF); 163 #endif 164 165 mcp = &ucp->uc_mcontext; 166 grp = &mcp->mc_gregs; 167 168 /* Skip over the trap instruction, first. */ 169 if (test_thread_flag(TIF_32BIT)) { 170 regs->tpc = (regs->tnpc & 0xffffffff); 171 regs->tnpc = (regs->tnpc + 4) & 0xffffffff; 172 } else { 173 regs->tpc = regs->tnpc; 174 regs->tnpc += 4; 175 } 176 err = 0; 177 if (_NSIG_WORDS == 1) 178 err |= __put_user(current->blocked.sig[0], 179 (unsigned long __user *)&ucp->uc_sigmask); 180 else 181 err |= __copy_to_user(&ucp->uc_sigmask, ¤t->blocked, 182 sizeof(sigset_t)); 183 184 err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE])); 185 err |= __put_user(regs->tpc, &((*grp)[MC_PC])); 186 err |= __put_user(regs->tnpc, &((*grp)[MC_NPC])); 187 err |= __put_user(regs->y, &((*grp)[MC_Y])); 188 err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1])); 189 err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2])); 190 err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3])); 191 err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4])); 192 err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5])); 193 err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6])); 194 err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7])); 195 err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0])); 196 err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1])); 197 err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2])); 198 err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3])); 199 err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4])); 200 err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5])); 201 err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6])); 202 err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7])); 203 204 err |= __get_user(fp, 205 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 206 err |= __get_user(i7, 207 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 208 err |= __put_user(fp, &(mcp->mc_fp)); 209 err |= __put_user(i7, &(mcp->mc_i7)); 210 211 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab)); 212 if (fenab) { 213 unsigned long *fpregs = current_thread_info()->fpregs; 214 unsigned long fprs; 215 216 fprs = current_thread_info()->fpsaved[0]; 217 if (fprs & FPRS_DL) 218 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs, 219 (sizeof(unsigned int) * 32)); 220 if (fprs & FPRS_DU) 221 err |= copy_to_user( 222 ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16, 223 (sizeof(unsigned int) * 32)); 224 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr)); 225 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr)); 226 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 227 } 228 if (err) 229 goto do_sigsegv; 230 out: 231 exception_exit(prev_state); 232 return; 233 do_sigsegv: 234 force_sig(SIGSEGV, current); 235 goto out; 236 } 237 238 /* Checks if the fp is valid. We always build rt signal frames which 239 * are 16-byte aligned, therefore we can always enforce that the 240 * restore frame has that property as well. 241 */ 242 static bool invalid_frame_pointer(void __user *fp) 243 { 244 if (((unsigned long) fp) & 15) 245 return true; 246 return false; 247 } 248 249 struct rt_signal_frame { 250 struct sparc_stackf ss; 251 siginfo_t info; 252 struct pt_regs regs; 253 __siginfo_fpu_t __user *fpu_save; 254 stack_t stack; 255 sigset_t mask; 256 __siginfo_rwin_t *rwin_save; 257 }; 258 259 void do_rt_sigreturn(struct pt_regs *regs) 260 { 261 unsigned long tpc, tnpc, tstate, ufp; 262 struct rt_signal_frame __user *sf; 263 __siginfo_fpu_t __user *fpu_save; 264 __siginfo_rwin_t __user *rwin_save; 265 sigset_t set; 266 int err; 267 268 /* Always make any pending restarted system calls return -EINTR */ 269 current->restart_block.fn = do_no_restart_syscall; 270 271 synchronize_user_stack (); 272 sf = (struct rt_signal_frame __user *) 273 (regs->u_regs [UREG_FP] + STACK_BIAS); 274 275 /* 1. Make sure we are not getting garbage from the user */ 276 if (invalid_frame_pointer(sf)) 277 goto segv; 278 279 if (get_user(ufp, &sf->regs.u_regs[UREG_FP])) 280 goto segv; 281 282 if ((ufp + STACK_BIAS) & 0x7) 283 goto segv; 284 285 err = __get_user(tpc, &sf->regs.tpc); 286 err |= __get_user(tnpc, &sf->regs.tnpc); 287 if (test_thread_flag(TIF_32BIT)) { 288 tpc &= 0xffffffff; 289 tnpc &= 0xffffffff; 290 } 291 err |= ((tpc | tnpc) & 3); 292 293 /* 2. Restore the state */ 294 err |= __get_user(regs->y, &sf->regs.y); 295 err |= __get_user(tstate, &sf->regs.tstate); 296 err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs)); 297 298 /* User can only change condition codes and %asi in %tstate. */ 299 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 300 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 301 302 err |= __get_user(fpu_save, &sf->fpu_save); 303 if (!err && fpu_save) 304 err |= restore_fpu_state(regs, fpu_save); 305 306 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); 307 err |= restore_altstack(&sf->stack); 308 if (err) 309 goto segv; 310 311 err |= __get_user(rwin_save, &sf->rwin_save); 312 if (!err && rwin_save) { 313 if (restore_rwin_state(rwin_save)) 314 goto segv; 315 } 316 317 regs->tpc = tpc; 318 regs->tnpc = tnpc; 319 320 /* Prevent syscall restart. */ 321 pt_regs_clear_syscall(regs); 322 323 set_current_blocked(&set); 324 return; 325 segv: 326 force_sig(SIGSEGV, current); 327 } 328 329 static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize) 330 { 331 unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS; 332 333 /* 334 * If we are on the alternate signal stack and would overflow it, don't. 335 * Return an always-bogus address instead so we will die with SIGSEGV. 336 */ 337 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) 338 return (void __user *) -1L; 339 340 /* This is the X/Open sanctioned signal stack switching. */ 341 sp = sigsp(sp, ksig) - framesize; 342 343 /* Always align the stack frame. This handles two cases. First, 344 * sigaltstack need not be mindful of platform specific stack 345 * alignment. Second, if we took this signal because the stack 346 * is not aligned properly, we'd like to take the signal cleanly 347 * and report that. 348 */ 349 sp &= ~15UL; 350 351 return (void __user *) sp; 352 } 353 354 static inline int 355 setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs) 356 { 357 struct rt_signal_frame __user *sf; 358 int wsaved, err, sf_size; 359 void __user *tail; 360 361 /* 1. Make sure everything is clean */ 362 synchronize_user_stack(); 363 save_and_clear_fpu(); 364 365 wsaved = get_thread_wsaved(); 366 367 sf_size = sizeof(struct rt_signal_frame); 368 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 369 sf_size += sizeof(__siginfo_fpu_t); 370 if (wsaved) 371 sf_size += sizeof(__siginfo_rwin_t); 372 sf = (struct rt_signal_frame __user *) 373 get_sigframe(ksig, regs, sf_size); 374 375 if (invalid_frame_pointer (sf)) { 376 do_exit(SIGILL); /* won't return, actually */ 377 return -EINVAL; 378 } 379 380 tail = (sf + 1); 381 382 /* 2. Save the current process state */ 383 err = copy_to_user(&sf->regs, regs, sizeof (*regs)); 384 385 if (current_thread_info()->fpsaved[0] & FPRS_FEF) { 386 __siginfo_fpu_t __user *fpu_save = tail; 387 tail += sizeof(__siginfo_fpu_t); 388 err |= save_fpu_state(regs, fpu_save); 389 err |= __put_user((u64)fpu_save, &sf->fpu_save); 390 } else { 391 err |= __put_user(0, &sf->fpu_save); 392 } 393 if (wsaved) { 394 __siginfo_rwin_t __user *rwin_save = tail; 395 tail += sizeof(__siginfo_rwin_t); 396 err |= save_rwin_state(wsaved, rwin_save); 397 err |= __put_user((u64)rwin_save, &sf->rwin_save); 398 set_thread_wsaved(0); 399 } else { 400 err |= __put_user(0, &sf->rwin_save); 401 } 402 403 /* Setup sigaltstack */ 404 err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]); 405 406 err |= copy_to_user(&sf->mask, sigmask_to_save(), sizeof(sigset_t)); 407 408 if (!wsaved) { 409 err |= copy_in_user((u64 __user *)sf, 410 (u64 __user *)(regs->u_regs[UREG_FP] + 411 STACK_BIAS), 412 sizeof(struct reg_window)); 413 } else { 414 struct reg_window *rp; 415 416 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 417 err |= copy_to_user(sf, rp, sizeof(struct reg_window)); 418 } 419 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 420 err |= copy_siginfo_to_user(&sf->info, &ksig->info); 421 else { 422 err |= __put_user(ksig->sig, &sf->info.si_signo); 423 err |= __put_user(SI_NOINFO, &sf->info.si_code); 424 } 425 if (err) 426 return err; 427 428 /* 3. signal handler back-trampoline and parameters */ 429 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS; 430 regs->u_regs[UREG_I0] = ksig->sig; 431 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 432 433 /* The sigcontext is passed in this way because of how it 434 * is defined in GLIBC's /usr/include/bits/sigcontext.h 435 * for sparc64. It includes the 128 bytes of siginfo_t. 436 */ 437 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 438 439 /* 5. signal handler */ 440 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler; 441 regs->tnpc = (regs->tpc + 4); 442 if (test_thread_flag(TIF_32BIT)) { 443 regs->tpc &= 0xffffffff; 444 regs->tnpc &= 0xffffffff; 445 } 446 /* 4. return to kernel instructions */ 447 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 448 return 0; 449 } 450 451 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, 452 struct sigaction *sa) 453 { 454 switch (regs->u_regs[UREG_I0]) { 455 case ERESTART_RESTARTBLOCK: 456 case ERESTARTNOHAND: 457 no_system_call_restart: 458 regs->u_regs[UREG_I0] = EINTR; 459 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY); 460 break; 461 case ERESTARTSYS: 462 if (!(sa->sa_flags & SA_RESTART)) 463 goto no_system_call_restart; 464 /* fallthrough */ 465 case ERESTARTNOINTR: 466 regs->u_regs[UREG_I0] = orig_i0; 467 regs->tpc -= 4; 468 regs->tnpc -= 4; 469 } 470 } 471 472 /* Note that 'init' is a special process: it doesn't get signals it doesn't 473 * want to handle. Thus you cannot kill init even with a SIGKILL even by 474 * mistake. 475 */ 476 static void do_signal(struct pt_regs *regs, unsigned long orig_i0) 477 { 478 struct ksignal ksig; 479 int restart_syscall; 480 bool has_handler; 481 482 /* It's a lot of work and synchronization to add a new ptrace 483 * register for GDB to save and restore in order to get 484 * orig_i0 correct for syscall restarts when debugging. 485 * 486 * Although it should be the case that most of the global 487 * registers are volatile across a system call, glibc already 488 * depends upon that fact that we preserve them. So we can't 489 * just use any global register to save away the orig_i0 value. 490 * 491 * In particular %g2, %g3, %g4, and %g5 are all assumed to be 492 * preserved across a system call trap by various pieces of 493 * code in glibc. 494 * 495 * %g7 is used as the "thread register". %g6 is not used in 496 * any fixed manner. %g6 is used as a scratch register and 497 * a compiler temporary, but it's value is never used across 498 * a system call. Therefore %g6 is usable for orig_i0 storage. 499 */ 500 if (pt_regs_is_syscall(regs) && 501 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) 502 regs->u_regs[UREG_G6] = orig_i0; 503 504 #ifdef CONFIG_COMPAT 505 if (test_thread_flag(TIF_32BIT)) { 506 do_signal32(regs); 507 return; 508 } 509 #endif 510 511 has_handler = get_signal(&ksig); 512 513 restart_syscall = 0; 514 if (pt_regs_is_syscall(regs) && 515 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) { 516 restart_syscall = 1; 517 orig_i0 = regs->u_regs[UREG_G6]; 518 } 519 520 if (has_handler) { 521 if (restart_syscall) 522 syscall_restart(orig_i0, regs, &ksig.ka.sa); 523 signal_setup_done(setup_rt_frame(&ksig, regs), &ksig, 0); 524 } else { 525 if (restart_syscall) { 526 switch (regs->u_regs[UREG_I0]) { 527 case ERESTARTNOHAND: 528 case ERESTARTSYS: 529 case ERESTARTNOINTR: 530 /* replay the system call when we are done */ 531 regs->u_regs[UREG_I0] = orig_i0; 532 regs->tpc -= 4; 533 regs->tnpc -= 4; 534 pt_regs_clear_syscall(regs); 535 case ERESTART_RESTARTBLOCK: 536 regs->u_regs[UREG_G1] = __NR_restart_syscall; 537 regs->tpc -= 4; 538 regs->tnpc -= 4; 539 pt_regs_clear_syscall(regs); 540 } 541 } 542 restore_saved_sigmask(); 543 } 544 } 545 546 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags) 547 { 548 user_exit(); 549 if (thread_info_flags & _TIF_UPROBE) 550 uprobe_notify_resume(regs); 551 if (thread_info_flags & _TIF_SIGPENDING) 552 do_signal(regs, orig_i0); 553 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 554 clear_thread_flag(TIF_NOTIFY_RESUME); 555 tracehook_notify_resume(regs); 556 } 557 user_enter(); 558 } 559 560