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