1 // SPDX-License-Identifier: GPL-2.0 2 /* arch/sparc64/kernel/signal32.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 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 9 */ 10 11 #include <linux/sched.h> 12 #include <linux/kernel.h> 13 #include <linux/signal.h> 14 #include <linux/errno.h> 15 #include <linux/wait.h> 16 #include <linux/ptrace.h> 17 #include <linux/unistd.h> 18 #include <linux/mm.h> 19 #include <linux/tty.h> 20 #include <linux/binfmts.h> 21 #include <linux/compat.h> 22 #include <linux/bitops.h> 23 24 #include <linux/uaccess.h> 25 #include <asm/ptrace.h> 26 #include <asm/psrcompat.h> 27 #include <asm/fpumacro.h> 28 #include <asm/visasm.h> 29 #include <asm/compat_signal.h> 30 #include <asm/switch_to.h> 31 32 #include "sigutil.h" 33 #include "kernel.h" 34 35 /* This magic should be in g_upper[0] for all upper parts 36 * to be valid. 37 */ 38 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269 39 typedef struct { 40 unsigned int g_upper[8]; 41 unsigned int o_upper[8]; 42 unsigned int asi; 43 } siginfo_extra_v8plus_t; 44 45 struct signal_frame32 { 46 struct sparc_stackf32 ss; 47 __siginfo32_t info; 48 /* __siginfo_fpu_t * */ u32 fpu_save; 49 unsigned int insns[2]; 50 unsigned int extramask[_COMPAT_NSIG_WORDS - 1]; 51 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ 52 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ 53 siginfo_extra_v8plus_t v8plus; 54 /* __siginfo_rwin_t * */u32 rwin_save; 55 } __attribute__((aligned(8))); 56 57 struct rt_signal_frame32 { 58 struct sparc_stackf32 ss; 59 compat_siginfo_t info; 60 struct pt_regs32 regs; 61 compat_sigset_t mask; 62 /* __siginfo_fpu_t * */ u32 fpu_save; 63 unsigned int insns[2]; 64 compat_stack_t stack; 65 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ 66 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ 67 siginfo_extra_v8plus_t v8plus; 68 /* __siginfo_rwin_t * */u32 rwin_save; 69 } __attribute__((aligned(8))); 70 71 /* Checks if the fp is valid. We always build signal frames which are 72 * 16-byte aligned, therefore we can always enforce that the restore 73 * frame has that property as well. 74 */ 75 static bool invalid_frame_pointer(void __user *fp, int fplen) 76 { 77 if ((((unsigned long) fp) & 15) || 78 ((unsigned long)fp) > 0x100000000ULL - fplen) 79 return true; 80 return false; 81 } 82 83 void do_sigreturn32(struct pt_regs *regs) 84 { 85 struct signal_frame32 __user *sf; 86 compat_uptr_t fpu_save; 87 compat_uptr_t rwin_save; 88 unsigned int psr, ufp; 89 unsigned int pc, npc; 90 sigset_t set; 91 compat_sigset_t seta; 92 int err, i; 93 94 /* Always make any pending restarted system calls return -EINTR */ 95 current->restart_block.fn = do_no_restart_syscall; 96 97 synchronize_user_stack(); 98 99 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 100 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP]; 101 102 /* 1. Make sure we are not getting garbage from the user */ 103 if (invalid_frame_pointer(sf, sizeof(*sf))) 104 goto segv; 105 106 if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP])) 107 goto segv; 108 109 if (ufp & 0x7) 110 goto segv; 111 112 if (__get_user(pc, &sf->info.si_regs.pc) || 113 __get_user(npc, &sf->info.si_regs.npc)) 114 goto segv; 115 116 if ((pc | npc) & 3) 117 goto segv; 118 119 if (test_thread_flag(TIF_32BIT)) { 120 pc &= 0xffffffff; 121 npc &= 0xffffffff; 122 } 123 regs->tpc = pc; 124 regs->tnpc = npc; 125 126 /* 2. Restore the state */ 127 err = __get_user(regs->y, &sf->info.si_regs.y); 128 err |= __get_user(psr, &sf->info.si_regs.psr); 129 130 for (i = UREG_G1; i <= UREG_I7; i++) 131 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 132 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 133 err |= __get_user(i, &sf->v8plus.g_upper[0]); 134 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 135 unsigned long asi; 136 137 for (i = UREG_G1; i <= UREG_I7; i++) 138 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 139 err |= __get_user(asi, &sf->v8plus.asi); 140 regs->tstate &= ~TSTATE_ASI; 141 regs->tstate |= ((asi & 0xffUL) << 24UL); 142 } 143 } 144 145 /* User can only change condition codes in %tstate. */ 146 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 147 regs->tstate |= psr_to_tstate_icc(psr); 148 149 /* Prevent syscall restart. */ 150 pt_regs_clear_syscall(regs); 151 152 err |= __get_user(fpu_save, &sf->fpu_save); 153 if (!err && fpu_save) 154 err |= restore_fpu_state(regs, compat_ptr(fpu_save)); 155 err |= __get_user(rwin_save, &sf->rwin_save); 156 if (!err && rwin_save) { 157 if (restore_rwin_state(compat_ptr(rwin_save))) 158 goto segv; 159 } 160 err |= __get_user(seta.sig[0], &sf->info.si_mask); 161 err |= copy_from_user(&seta.sig[1], &sf->extramask, 162 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 163 if (err) 164 goto segv; 165 166 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32); 167 set_current_blocked(&set); 168 return; 169 170 segv: 171 force_sig(SIGSEGV); 172 } 173 174 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) 175 { 176 struct rt_signal_frame32 __user *sf; 177 unsigned int psr, pc, npc, ufp; 178 compat_uptr_t fpu_save; 179 compat_uptr_t rwin_save; 180 sigset_t set; 181 int err, i; 182 183 /* Always make any pending restarted system calls return -EINTR */ 184 current->restart_block.fn = do_no_restart_syscall; 185 186 synchronize_user_stack(); 187 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 188 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP]; 189 190 /* 1. Make sure we are not getting garbage from the user */ 191 if (invalid_frame_pointer(sf, sizeof(*sf))) 192 goto segv; 193 194 if (get_user(ufp, &sf->regs.u_regs[UREG_FP])) 195 goto segv; 196 197 if (ufp & 0x7) 198 goto segv; 199 200 if (__get_user(pc, &sf->regs.pc) || 201 __get_user(npc, &sf->regs.npc)) 202 goto segv; 203 204 if ((pc | npc) & 3) 205 goto segv; 206 207 if (test_thread_flag(TIF_32BIT)) { 208 pc &= 0xffffffff; 209 npc &= 0xffffffff; 210 } 211 regs->tpc = pc; 212 regs->tnpc = npc; 213 214 /* 2. Restore the state */ 215 err = __get_user(regs->y, &sf->regs.y); 216 err |= __get_user(psr, &sf->regs.psr); 217 218 for (i = UREG_G1; i <= UREG_I7; i++) 219 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]); 220 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 221 err |= __get_user(i, &sf->v8plus.g_upper[0]); 222 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 223 unsigned long asi; 224 225 for (i = UREG_G1; i <= UREG_I7; i++) 226 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 227 err |= __get_user(asi, &sf->v8plus.asi); 228 regs->tstate &= ~TSTATE_ASI; 229 regs->tstate |= ((asi & 0xffUL) << 24UL); 230 } 231 } 232 233 /* User can only change condition codes in %tstate. */ 234 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 235 regs->tstate |= psr_to_tstate_icc(psr); 236 237 /* Prevent syscall restart. */ 238 pt_regs_clear_syscall(regs); 239 240 err |= __get_user(fpu_save, &sf->fpu_save); 241 if (!err && fpu_save) 242 err |= restore_fpu_state(regs, compat_ptr(fpu_save)); 243 err |= get_compat_sigset(&set, &sf->mask); 244 err |= compat_restore_altstack(&sf->stack); 245 if (err) 246 goto segv; 247 248 err |= __get_user(rwin_save, &sf->rwin_save); 249 if (!err && rwin_save) { 250 if (restore_rwin_state(compat_ptr(rwin_save))) 251 goto segv; 252 } 253 254 set_current_blocked(&set); 255 return; 256 segv: 257 force_sig(SIGSEGV); 258 } 259 260 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize) 261 { 262 unsigned long sp; 263 264 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 265 sp = regs->u_regs[UREG_FP]; 266 267 /* 268 * If we are on the alternate signal stack and would overflow it, don't. 269 * Return an always-bogus address instead so we will die with SIGSEGV. 270 */ 271 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) 272 return (void __user *) -1L; 273 274 /* This is the X/Open sanctioned signal stack switching. */ 275 sp = sigsp(sp, ksig) - framesize; 276 277 /* Always align the stack frame. This handles two cases. First, 278 * sigaltstack need not be mindful of platform specific stack 279 * alignment. Second, if we took this signal because the stack 280 * is not aligned properly, we'd like to take the signal cleanly 281 * and report that. 282 */ 283 sp &= ~15UL; 284 285 return (void __user *) sp; 286 } 287 288 /* The I-cache flush instruction only works in the primary ASI, which 289 * right now is the nucleus, aka. kernel space. 290 * 291 * Therefore we have to kick the instructions out using the kernel 292 * side linear mapping of the physical address backing the user 293 * instructions. 294 */ 295 static void flush_signal_insns(unsigned long address) 296 { 297 unsigned long pstate, paddr; 298 pte_t *ptep, pte; 299 pgd_t *pgdp; 300 p4d_t *p4dp; 301 pud_t *pudp; 302 pmd_t *pmdp; 303 304 /* Commit all stores of the instructions we are about to flush. */ 305 wmb(); 306 307 /* Disable cross-call reception. In this way even a very wide 308 * munmap() on another cpu can't tear down the page table 309 * hierarchy from underneath us, since that can't complete 310 * until the IPI tlb flush returns. 311 */ 312 313 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate)); 314 __asm__ __volatile__("wrpr %0, %1, %%pstate" 315 : : "r" (pstate), "i" (PSTATE_IE)); 316 317 pgdp = pgd_offset(current->mm, address); 318 if (pgd_none(*pgdp)) 319 goto out_irqs_on; 320 p4dp = p4d_offset(pgdp, address); 321 if (p4d_none(*p4dp)) 322 goto out_irqs_on; 323 pudp = pud_offset(p4dp, address); 324 if (pud_none(*pudp)) 325 goto out_irqs_on; 326 pmdp = pmd_offset(pudp, address); 327 if (pmd_none(*pmdp)) 328 goto out_irqs_on; 329 330 ptep = pte_offset_map(pmdp, address); 331 pte = *ptep; 332 if (!pte_present(pte)) 333 goto out_unmap; 334 335 paddr = (unsigned long) page_address(pte_page(pte)); 336 337 __asm__ __volatile__("flush %0 + %1" 338 : /* no outputs */ 339 : "r" (paddr), 340 "r" (address & (PAGE_SIZE - 1)) 341 : "memory"); 342 343 out_unmap: 344 pte_unmap(ptep); 345 out_irqs_on: 346 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate)); 347 348 } 349 350 static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs, 351 sigset_t *oldset) 352 { 353 struct signal_frame32 __user *sf; 354 int i, err, wsaved; 355 void __user *tail; 356 int sigframe_size; 357 u32 psr; 358 compat_sigset_t seta; 359 360 /* 1. Make sure everything is clean */ 361 synchronize_user_stack(); 362 save_and_clear_fpu(); 363 364 wsaved = get_thread_wsaved(); 365 366 sigframe_size = sizeof(*sf); 367 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 368 sigframe_size += sizeof(__siginfo_fpu_t); 369 if (wsaved) 370 sigframe_size += sizeof(__siginfo_rwin_t); 371 372 sf = (struct signal_frame32 __user *) 373 get_sigframe(ksig, regs, sigframe_size); 374 375 if (invalid_frame_pointer(sf, sigframe_size)) { 376 if (show_unhandled_signals) 377 pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n", 378 current->comm, current->pid, (unsigned long)sf, 379 regs->tpc, regs->u_regs[UREG_I7]); 380 force_sigsegv(ksig->sig); 381 return -EINVAL; 382 } 383 384 tail = (sf + 1); 385 386 /* 2. Save the current process state */ 387 if (test_thread_flag(TIF_32BIT)) { 388 regs->tpc &= 0xffffffff; 389 regs->tnpc &= 0xffffffff; 390 } 391 err = put_user(regs->tpc, &sf->info.si_regs.pc); 392 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc); 393 err |= __put_user(regs->y, &sf->info.si_regs.y); 394 psr = tstate_to_psr(regs->tstate); 395 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 396 psr |= PSR_EF; 397 err |= __put_user(psr, &sf->info.si_regs.psr); 398 for (i = 0; i < 16; i++) 399 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 400 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 401 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 402 for (i = 1; i < 16; i++) 403 err |= __put_user(((u32 *)regs->u_regs)[2*i], 404 &sf->v8plus.g_upper[i]); 405 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 406 &sf->v8plus.asi); 407 408 if (psr & PSR_EF) { 409 __siginfo_fpu_t __user *fp = tail; 410 tail += sizeof(*fp); 411 err |= save_fpu_state(regs, fp); 412 err |= __put_user((u64)fp, &sf->fpu_save); 413 } else { 414 err |= __put_user(0, &sf->fpu_save); 415 } 416 if (wsaved) { 417 __siginfo_rwin_t __user *rwp = tail; 418 tail += sizeof(*rwp); 419 err |= save_rwin_state(wsaved, rwp); 420 err |= __put_user((u64)rwp, &sf->rwin_save); 421 set_thread_wsaved(0); 422 } else { 423 err |= __put_user(0, &sf->rwin_save); 424 } 425 426 /* If these change we need to know - assignments to seta relies on these sizes */ 427 BUILD_BUG_ON(_NSIG_WORDS != 1); 428 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2); 429 seta.sig[1] = (oldset->sig[0] >> 32); 430 seta.sig[0] = oldset->sig[0]; 431 432 err |= __put_user(seta.sig[0], &sf->info.si_mask); 433 err |= __copy_to_user(sf->extramask, &seta.sig[1], 434 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 435 436 if (!wsaved) { 437 err |= raw_copy_in_user((u32 __user *)sf, 438 (u32 __user *)(regs->u_regs[UREG_FP]), 439 sizeof(struct reg_window32)); 440 } else { 441 struct reg_window *rp; 442 443 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 444 for (i = 0; i < 8; i++) 445 err |= __put_user(rp->locals[i], &sf->ss.locals[i]); 446 for (i = 0; i < 6; i++) 447 err |= __put_user(rp->ins[i], &sf->ss.ins[i]); 448 err |= __put_user(rp->ins[6], &sf->ss.fp); 449 err |= __put_user(rp->ins[7], &sf->ss.callers_pc); 450 } 451 if (err) 452 return err; 453 454 /* 3. signal handler back-trampoline and parameters */ 455 regs->u_regs[UREG_FP] = (unsigned long) sf; 456 regs->u_regs[UREG_I0] = ksig->sig; 457 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 458 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 459 460 /* 4. signal handler */ 461 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler; 462 regs->tnpc = (regs->tpc + 4); 463 if (test_thread_flag(TIF_32BIT)) { 464 regs->tpc &= 0xffffffff; 465 regs->tnpc &= 0xffffffff; 466 } 467 468 /* 5. return to kernel instructions */ 469 if (ksig->ka.ka_restorer) { 470 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 471 } else { 472 unsigned long address = ((unsigned long)&(sf->insns[0])); 473 474 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 475 476 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/ 477 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/ 478 if (err) 479 return err; 480 flush_signal_insns(address); 481 } 482 return 0; 483 } 484 485 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs, 486 sigset_t *oldset) 487 { 488 struct rt_signal_frame32 __user *sf; 489 int i, err, wsaved; 490 void __user *tail; 491 int sigframe_size; 492 u32 psr; 493 494 /* 1. Make sure everything is clean */ 495 synchronize_user_stack(); 496 save_and_clear_fpu(); 497 498 wsaved = get_thread_wsaved(); 499 500 sigframe_size = sizeof(*sf); 501 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 502 sigframe_size += sizeof(__siginfo_fpu_t); 503 if (wsaved) 504 sigframe_size += sizeof(__siginfo_rwin_t); 505 506 sf = (struct rt_signal_frame32 __user *) 507 get_sigframe(ksig, regs, sigframe_size); 508 509 if (invalid_frame_pointer(sf, sigframe_size)) { 510 if (show_unhandled_signals) 511 pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n", 512 current->comm, current->pid, (unsigned long)sf, 513 regs->tpc, regs->u_regs[UREG_I7]); 514 force_sigsegv(ksig->sig); 515 return -EINVAL; 516 } 517 518 tail = (sf + 1); 519 520 /* 2. Save the current process state */ 521 if (test_thread_flag(TIF_32BIT)) { 522 regs->tpc &= 0xffffffff; 523 regs->tnpc &= 0xffffffff; 524 } 525 err = put_user(regs->tpc, &sf->regs.pc); 526 err |= __put_user(regs->tnpc, &sf->regs.npc); 527 err |= __put_user(regs->y, &sf->regs.y); 528 psr = tstate_to_psr(regs->tstate); 529 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 530 psr |= PSR_EF; 531 err |= __put_user(psr, &sf->regs.psr); 532 for (i = 0; i < 16; i++) 533 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]); 534 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 535 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 536 for (i = 1; i < 16; i++) 537 err |= __put_user(((u32 *)regs->u_regs)[2*i], 538 &sf->v8plus.g_upper[i]); 539 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 540 &sf->v8plus.asi); 541 542 if (psr & PSR_EF) { 543 __siginfo_fpu_t __user *fp = tail; 544 tail += sizeof(*fp); 545 err |= save_fpu_state(regs, fp); 546 err |= __put_user((u64)fp, &sf->fpu_save); 547 } else { 548 err |= __put_user(0, &sf->fpu_save); 549 } 550 if (wsaved) { 551 __siginfo_rwin_t __user *rwp = tail; 552 tail += sizeof(*rwp); 553 err |= save_rwin_state(wsaved, rwp); 554 err |= __put_user((u64)rwp, &sf->rwin_save); 555 set_thread_wsaved(0); 556 } else { 557 err |= __put_user(0, &sf->rwin_save); 558 } 559 560 /* Update the siginfo structure. */ 561 err |= copy_siginfo_to_user32(&sf->info, &ksig->info); 562 563 /* Setup sigaltstack */ 564 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]); 565 566 err |= put_compat_sigset(&sf->mask, oldset, sizeof(compat_sigset_t)); 567 568 if (!wsaved) { 569 err |= raw_copy_in_user((u32 __user *)sf, 570 (u32 __user *)(regs->u_regs[UREG_FP]), 571 sizeof(struct reg_window32)); 572 } else { 573 struct reg_window *rp; 574 575 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 576 for (i = 0; i < 8; i++) 577 err |= __put_user(rp->locals[i], &sf->ss.locals[i]); 578 for (i = 0; i < 6; i++) 579 err |= __put_user(rp->ins[i], &sf->ss.ins[i]); 580 err |= __put_user(rp->ins[6], &sf->ss.fp); 581 err |= __put_user(rp->ins[7], &sf->ss.callers_pc); 582 } 583 if (err) 584 return err; 585 586 /* 3. signal handler back-trampoline and parameters */ 587 regs->u_regs[UREG_FP] = (unsigned long) sf; 588 regs->u_regs[UREG_I0] = ksig->sig; 589 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 590 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs; 591 592 /* 4. signal handler */ 593 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler; 594 regs->tnpc = (regs->tpc + 4); 595 if (test_thread_flag(TIF_32BIT)) { 596 regs->tpc &= 0xffffffff; 597 regs->tnpc &= 0xffffffff; 598 } 599 600 /* 5. return to kernel instructions */ 601 if (ksig->ka.ka_restorer) 602 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 603 else { 604 unsigned long address = ((unsigned long)&(sf->insns[0])); 605 606 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 607 608 /* mov __NR_rt_sigreturn, %g1 */ 609 err |= __put_user(0x82102065, &sf->insns[0]); 610 611 /* t 0x10 */ 612 err |= __put_user(0x91d02010, &sf->insns[1]); 613 if (err) 614 return err; 615 616 flush_signal_insns(address); 617 } 618 return 0; 619 } 620 621 static inline void handle_signal32(struct ksignal *ksig, 622 struct pt_regs *regs) 623 { 624 sigset_t *oldset = sigmask_to_save(); 625 int err; 626 627 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 628 err = setup_rt_frame32(ksig, regs, oldset); 629 else 630 err = setup_frame32(ksig, regs, oldset); 631 632 signal_setup_done(err, ksig, 0); 633 } 634 635 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs, 636 struct sigaction *sa) 637 { 638 switch (regs->u_regs[UREG_I0]) { 639 case ERESTART_RESTARTBLOCK: 640 case ERESTARTNOHAND: 641 no_system_call_restart: 642 regs->u_regs[UREG_I0] = EINTR; 643 regs->tstate |= TSTATE_ICARRY; 644 break; 645 case ERESTARTSYS: 646 if (!(sa->sa_flags & SA_RESTART)) 647 goto no_system_call_restart; 648 fallthrough; 649 case ERESTARTNOINTR: 650 regs->u_regs[UREG_I0] = orig_i0; 651 regs->tpc -= 4; 652 regs->tnpc -= 4; 653 } 654 } 655 656 /* Note that 'init' is a special process: it doesn't get signals it doesn't 657 * want to handle. Thus you cannot kill init even with a SIGKILL even by 658 * mistake. 659 */ 660 void do_signal32(struct pt_regs * regs) 661 { 662 struct ksignal ksig; 663 unsigned long orig_i0 = 0; 664 int restart_syscall = 0; 665 bool has_handler = get_signal(&ksig); 666 667 if (pt_regs_is_syscall(regs) && 668 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) { 669 restart_syscall = 1; 670 orig_i0 = regs->u_regs[UREG_G6]; 671 } 672 673 if (has_handler) { 674 if (restart_syscall) 675 syscall_restart32(orig_i0, regs, &ksig.ka.sa); 676 handle_signal32(&ksig, regs); 677 } else { 678 if (restart_syscall) { 679 switch (regs->u_regs[UREG_I0]) { 680 case ERESTARTNOHAND: 681 case ERESTARTSYS: 682 case ERESTARTNOINTR: 683 /* replay the system call when we are done */ 684 regs->u_regs[UREG_I0] = orig_i0; 685 regs->tpc -= 4; 686 regs->tnpc -= 4; 687 pt_regs_clear_syscall(regs); 688 fallthrough; 689 case ERESTART_RESTARTBLOCK: 690 regs->u_regs[UREG_G1] = __NR_restart_syscall; 691 regs->tpc -= 4; 692 regs->tnpc -= 4; 693 pt_regs_clear_syscall(regs); 694 } 695 } 696 restore_saved_sigmask(); 697 } 698 } 699 700 struct sigstack32 { 701 u32 the_stack; 702 int cur_status; 703 }; 704 705 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp) 706 { 707 struct sigstack32 __user *ssptr = 708 (struct sigstack32 __user *)((unsigned long)(u_ssptr)); 709 struct sigstack32 __user *ossptr = 710 (struct sigstack32 __user *)((unsigned long)(u_ossptr)); 711 int ret = -EFAULT; 712 713 /* First see if old state is wanted. */ 714 if (ossptr) { 715 if (put_user(current->sas_ss_sp + current->sas_ss_size, 716 &ossptr->the_stack) || 717 __put_user(on_sig_stack(sp), &ossptr->cur_status)) 718 goto out; 719 } 720 721 /* Now see if we want to update the new state. */ 722 if (ssptr) { 723 u32 ss_sp; 724 725 if (get_user(ss_sp, &ssptr->the_stack)) 726 goto out; 727 728 /* If the current stack was set with sigaltstack, don't 729 * swap stacks while we are on it. 730 */ 731 ret = -EPERM; 732 if (current->sas_ss_sp && on_sig_stack(sp)) 733 goto out; 734 735 /* Since we don't know the extent of the stack, and we don't 736 * track onstack-ness, but rather calculate it, we must 737 * presume a size. Ho hum this interface is lossy. 738 */ 739 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ; 740 current->sas_ss_size = SIGSTKSZ; 741 } 742 743 ret = 0; 744 out: 745 return ret; 746 } 747 748 /* 749 * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as 750 * changes likely come with new fields that should be added below. 751 */ 752 static_assert(NSIGILL == 11); 753 static_assert(NSIGFPE == 15); 754 static_assert(NSIGSEGV == 9); 755 static_assert(NSIGBUS == 5); 756 static_assert(NSIGTRAP == 6); 757 static_assert(NSIGCHLD == 6); 758 static_assert(NSIGSYS == 2); 759 static_assert(sizeof(compat_siginfo_t) == 128); 760 static_assert(__alignof__(compat_siginfo_t) == 4); 761 static_assert(offsetof(compat_siginfo_t, si_signo) == 0x00); 762 static_assert(offsetof(compat_siginfo_t, si_errno) == 0x04); 763 static_assert(offsetof(compat_siginfo_t, si_code) == 0x08); 764 static_assert(offsetof(compat_siginfo_t, si_pid) == 0x0c); 765 static_assert(offsetof(compat_siginfo_t, si_uid) == 0x10); 766 static_assert(offsetof(compat_siginfo_t, si_tid) == 0x0c); 767 static_assert(offsetof(compat_siginfo_t, si_overrun) == 0x10); 768 static_assert(offsetof(compat_siginfo_t, si_status) == 0x14); 769 static_assert(offsetof(compat_siginfo_t, si_utime) == 0x18); 770 static_assert(offsetof(compat_siginfo_t, si_stime) == 0x1c); 771 static_assert(offsetof(compat_siginfo_t, si_value) == 0x14); 772 static_assert(offsetof(compat_siginfo_t, si_int) == 0x14); 773 static_assert(offsetof(compat_siginfo_t, si_ptr) == 0x14); 774 static_assert(offsetof(compat_siginfo_t, si_addr) == 0x0c); 775 static_assert(offsetof(compat_siginfo_t, si_trapno) == 0x10); 776 static_assert(offsetof(compat_siginfo_t, si_addr_lsb) == 0x10); 777 static_assert(offsetof(compat_siginfo_t, si_lower) == 0x14); 778 static_assert(offsetof(compat_siginfo_t, si_upper) == 0x18); 779 static_assert(offsetof(compat_siginfo_t, si_pkey) == 0x14); 780 static_assert(offsetof(compat_siginfo_t, si_perf_data) == 0x10); 781 static_assert(offsetof(compat_siginfo_t, si_perf_type) == 0x14); 782 static_assert(offsetof(compat_siginfo_t, si_perf_flags) == 0x18); 783 static_assert(offsetof(compat_siginfo_t, si_band) == 0x0c); 784 static_assert(offsetof(compat_siginfo_t, si_fd) == 0x10); 785