1 /* arch/sparc64/kernel/signal32.c 2 * 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 5 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx) 6 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) 7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 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/binfmts.h> 20 #include <linux/compat.h> 21 #include <linux/bitops.h> 22 #include <linux/tracehook.h> 23 24 #include <asm/uaccess.h> 25 #include <asm/ptrace.h> 26 #include <asm/pgtable.h> 27 #include <asm/psrcompat.h> 28 #include <asm/fpumacro.h> 29 #include <asm/visasm.h> 30 #include <asm/compat_signal.h> 31 #include <asm/switch_to.h> 32 33 #include "sigutil.h" 34 35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 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 typedef struct compat_siginfo{ 60 int si_signo; 61 int si_errno; 62 int si_code; 63 64 union { 65 int _pad[SI_PAD_SIZE32]; 66 67 /* kill() */ 68 struct { 69 compat_pid_t _pid; /* sender's pid */ 70 unsigned int _uid; /* sender's uid */ 71 } _kill; 72 73 /* POSIX.1b timers */ 74 struct { 75 compat_timer_t _tid; /* timer id */ 76 int _overrun; /* overrun count */ 77 compat_sigval_t _sigval; /* same as below */ 78 int _sys_private; /* not to be passed to user */ 79 } _timer; 80 81 /* POSIX.1b signals */ 82 struct { 83 compat_pid_t _pid; /* sender's pid */ 84 unsigned int _uid; /* sender's uid */ 85 compat_sigval_t _sigval; 86 } _rt; 87 88 /* SIGCHLD */ 89 struct { 90 compat_pid_t _pid; /* which child */ 91 unsigned int _uid; /* sender's uid */ 92 int _status; /* exit code */ 93 compat_clock_t _utime; 94 compat_clock_t _stime; 95 } _sigchld; 96 97 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */ 98 struct { 99 u32 _addr; /* faulting insn/memory ref. */ 100 int _trapno; 101 } _sigfault; 102 103 /* SIGPOLL */ 104 struct { 105 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */ 106 int _fd; 107 } _sigpoll; 108 } _sifields; 109 }compat_siginfo_t; 110 111 struct rt_signal_frame32 { 112 struct sparc_stackf32 ss; 113 compat_siginfo_t info; 114 struct pt_regs32 regs; 115 compat_sigset_t mask; 116 /* __siginfo_fpu_t * */ u32 fpu_save; 117 unsigned int insns[2]; 118 stack_t32 stack; 119 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ 120 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ 121 siginfo_extra_v8plus_t v8plus; 122 /* __siginfo_rwin_t * */u32 rwin_save; 123 } __attribute__((aligned(8))); 124 125 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 126 { 127 int err; 128 129 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 130 return -EFAULT; 131 132 /* If you change siginfo_t structure, please be sure 133 this code is fixed accordingly. 134 It should never copy any pad contained in the structure 135 to avoid security leaks, but must copy the generic 136 3 ints plus the relevant union member. 137 This routine must convert siginfo from 64bit to 32bit as well 138 at the same time. */ 139 err = __put_user(from->si_signo, &to->si_signo); 140 err |= __put_user(from->si_errno, &to->si_errno); 141 err |= __put_user((short)from->si_code, &to->si_code); 142 if (from->si_code < 0) 143 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 144 else { 145 switch (from->si_code >> 16) { 146 case __SI_TIMER >> 16: 147 err |= __put_user(from->si_tid, &to->si_tid); 148 err |= __put_user(from->si_overrun, &to->si_overrun); 149 err |= __put_user(from->si_int, &to->si_int); 150 break; 151 case __SI_CHLD >> 16: 152 err |= __put_user(from->si_utime, &to->si_utime); 153 err |= __put_user(from->si_stime, &to->si_stime); 154 err |= __put_user(from->si_status, &to->si_status); 155 default: 156 err |= __put_user(from->si_pid, &to->si_pid); 157 err |= __put_user(from->si_uid, &to->si_uid); 158 break; 159 case __SI_FAULT >> 16: 160 err |= __put_user(from->si_trapno, &to->si_trapno); 161 err |= __put_user((unsigned long)from->si_addr, &to->si_addr); 162 break; 163 case __SI_POLL >> 16: 164 err |= __put_user(from->si_band, &to->si_band); 165 err |= __put_user(from->si_fd, &to->si_fd); 166 break; 167 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 168 case __SI_MESGQ >> 16: 169 err |= __put_user(from->si_pid, &to->si_pid); 170 err |= __put_user(from->si_uid, &to->si_uid); 171 err |= __put_user(from->si_int, &to->si_int); 172 break; 173 } 174 } 175 return err; 176 } 177 178 /* CAUTION: This is just a very minimalist implementation for the 179 * sake of compat_sys_rt_sigqueueinfo() 180 */ 181 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 182 { 183 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t))) 184 return -EFAULT; 185 186 if (copy_from_user(to, from, 3*sizeof(int)) || 187 copy_from_user(to->_sifields._pad, from->_sifields._pad, 188 SI_PAD_SIZE)) 189 return -EFAULT; 190 191 return 0; 192 } 193 194 void do_sigreturn32(struct pt_regs *regs) 195 { 196 struct signal_frame32 __user *sf; 197 compat_uptr_t fpu_save; 198 compat_uptr_t rwin_save; 199 unsigned int psr; 200 unsigned pc, npc; 201 sigset_t set; 202 unsigned seta[_COMPAT_NSIG_WORDS]; 203 int err, i; 204 205 /* Always make any pending restarted system calls return -EINTR */ 206 current_thread_info()->restart_block.fn = do_no_restart_syscall; 207 208 synchronize_user_stack(); 209 210 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 211 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP]; 212 213 /* 1. Make sure we are not getting garbage from the user */ 214 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) || 215 (((unsigned long) sf) & 3)) 216 goto segv; 217 218 if (get_user(pc, &sf->info.si_regs.pc) || 219 __get_user(npc, &sf->info.si_regs.npc)) 220 goto segv; 221 222 if ((pc | npc) & 3) 223 goto segv; 224 225 if (test_thread_flag(TIF_32BIT)) { 226 pc &= 0xffffffff; 227 npc &= 0xffffffff; 228 } 229 regs->tpc = pc; 230 regs->tnpc = npc; 231 232 /* 2. Restore the state */ 233 err = __get_user(regs->y, &sf->info.si_regs.y); 234 err |= __get_user(psr, &sf->info.si_regs.psr); 235 236 for (i = UREG_G1; i <= UREG_I7; i++) 237 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 238 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 239 err |= __get_user(i, &sf->v8plus.g_upper[0]); 240 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 241 unsigned long asi; 242 243 for (i = UREG_G1; i <= UREG_I7; i++) 244 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 245 err |= __get_user(asi, &sf->v8plus.asi); 246 regs->tstate &= ~TSTATE_ASI; 247 regs->tstate |= ((asi & 0xffUL) << 24UL); 248 } 249 } 250 251 /* User can only change condition codes in %tstate. */ 252 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 253 regs->tstate |= psr_to_tstate_icc(psr); 254 255 /* Prevent syscall restart. */ 256 pt_regs_clear_syscall(regs); 257 258 err |= __get_user(fpu_save, &sf->fpu_save); 259 if (!err && fpu_save) 260 err |= restore_fpu_state(regs, compat_ptr(fpu_save)); 261 err |= __get_user(rwin_save, &sf->rwin_save); 262 if (!err && rwin_save) { 263 if (restore_rwin_state(compat_ptr(rwin_save))) 264 goto segv; 265 } 266 err |= __get_user(seta[0], &sf->info.si_mask); 267 err |= copy_from_user(seta+1, &sf->extramask, 268 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 269 if (err) 270 goto segv; 271 switch (_NSIG_WORDS) { 272 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32); 273 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32); 274 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32); 275 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32); 276 } 277 sigdelsetmask(&set, ~_BLOCKABLE); 278 set_current_blocked(&set); 279 return; 280 281 segv: 282 force_sig(SIGSEGV, current); 283 } 284 285 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) 286 { 287 struct rt_signal_frame32 __user *sf; 288 unsigned int psr, pc, npc, u_ss_sp; 289 compat_uptr_t fpu_save; 290 compat_uptr_t rwin_save; 291 mm_segment_t old_fs; 292 sigset_t set; 293 compat_sigset_t seta; 294 stack_t st; 295 int err, i; 296 297 /* Always make any pending restarted system calls return -EINTR */ 298 current_thread_info()->restart_block.fn = do_no_restart_syscall; 299 300 synchronize_user_stack(); 301 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 302 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP]; 303 304 /* 1. Make sure we are not getting garbage from the user */ 305 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) || 306 (((unsigned long) sf) & 3)) 307 goto segv; 308 309 if (get_user(pc, &sf->regs.pc) || 310 __get_user(npc, &sf->regs.npc)) 311 goto segv; 312 313 if ((pc | npc) & 3) 314 goto segv; 315 316 if (test_thread_flag(TIF_32BIT)) { 317 pc &= 0xffffffff; 318 npc &= 0xffffffff; 319 } 320 regs->tpc = pc; 321 regs->tnpc = npc; 322 323 /* 2. Restore the state */ 324 err = __get_user(regs->y, &sf->regs.y); 325 err |= __get_user(psr, &sf->regs.psr); 326 327 for (i = UREG_G1; i <= UREG_I7; i++) 328 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]); 329 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 330 err |= __get_user(i, &sf->v8plus.g_upper[0]); 331 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 332 unsigned long asi; 333 334 for (i = UREG_G1; i <= UREG_I7; i++) 335 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 336 err |= __get_user(asi, &sf->v8plus.asi); 337 regs->tstate &= ~TSTATE_ASI; 338 regs->tstate |= ((asi & 0xffUL) << 24UL); 339 } 340 } 341 342 /* User can only change condition codes in %tstate. */ 343 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 344 regs->tstate |= psr_to_tstate_icc(psr); 345 346 /* Prevent syscall restart. */ 347 pt_regs_clear_syscall(regs); 348 349 err |= __get_user(fpu_save, &sf->fpu_save); 350 if (!err && fpu_save) 351 err |= restore_fpu_state(regs, compat_ptr(fpu_save)); 352 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t)); 353 err |= __get_user(u_ss_sp, &sf->stack.ss_sp); 354 st.ss_sp = compat_ptr(u_ss_sp); 355 err |= __get_user(st.ss_flags, &sf->stack.ss_flags); 356 err |= __get_user(st.ss_size, &sf->stack.ss_size); 357 if (err) 358 goto segv; 359 360 /* It is more difficult to avoid calling this function than to 361 call it and ignore errors. */ 362 old_fs = get_fs(); 363 set_fs(KERNEL_DS); 364 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf); 365 set_fs(old_fs); 366 367 err |= __get_user(rwin_save, &sf->rwin_save); 368 if (!err && rwin_save) { 369 if (restore_rwin_state(compat_ptr(rwin_save))) 370 goto segv; 371 } 372 373 switch (_NSIG_WORDS) { 374 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32); 375 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32); 376 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32); 377 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32); 378 } 379 sigdelsetmask(&set, ~_BLOCKABLE); 380 set_current_blocked(&set); 381 return; 382 segv: 383 force_sig(SIGSEGV, current); 384 } 385 386 /* Checks if the fp is valid */ 387 static int invalid_frame_pointer(void __user *fp, int fplen) 388 { 389 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen) 390 return 1; 391 return 0; 392 } 393 394 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize) 395 { 396 unsigned long sp; 397 398 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 399 sp = regs->u_regs[UREG_FP]; 400 401 /* 402 * If we are on the alternate signal stack and would overflow it, don't. 403 * Return an always-bogus address instead so we will die with SIGSEGV. 404 */ 405 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) 406 return (void __user *) -1L; 407 408 /* This is the X/Open sanctioned signal stack switching. */ 409 if (sa->sa_flags & SA_ONSTACK) { 410 if (sas_ss_flags(sp) == 0) 411 sp = current->sas_ss_sp + current->sas_ss_size; 412 } 413 414 sp -= framesize; 415 416 /* Always align the stack frame. This handles two cases. First, 417 * sigaltstack need not be mindful of platform specific stack 418 * alignment. Second, if we took this signal because the stack 419 * is not aligned properly, we'd like to take the signal cleanly 420 * and report that. 421 */ 422 sp &= ~15UL; 423 424 return (void __user *) sp; 425 } 426 427 /* The I-cache flush instruction only works in the primary ASI, which 428 * right now is the nucleus, aka. kernel space. 429 * 430 * Therefore we have to kick the instructions out using the kernel 431 * side linear mapping of the physical address backing the user 432 * instructions. 433 */ 434 static void flush_signal_insns(unsigned long address) 435 { 436 unsigned long pstate, paddr; 437 pte_t *ptep, pte; 438 pgd_t *pgdp; 439 pud_t *pudp; 440 pmd_t *pmdp; 441 442 /* Commit all stores of the instructions we are about to flush. */ 443 wmb(); 444 445 /* Disable cross-call reception. In this way even a very wide 446 * munmap() on another cpu can't tear down the page table 447 * hierarchy from underneath us, since that can't complete 448 * until the IPI tlb flush returns. 449 */ 450 451 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate)); 452 __asm__ __volatile__("wrpr %0, %1, %%pstate" 453 : : "r" (pstate), "i" (PSTATE_IE)); 454 455 pgdp = pgd_offset(current->mm, address); 456 if (pgd_none(*pgdp)) 457 goto out_irqs_on; 458 pudp = pud_offset(pgdp, address); 459 if (pud_none(*pudp)) 460 goto out_irqs_on; 461 pmdp = pmd_offset(pudp, address); 462 if (pmd_none(*pmdp)) 463 goto out_irqs_on; 464 465 ptep = pte_offset_map(pmdp, address); 466 pte = *ptep; 467 if (!pte_present(pte)) 468 goto out_unmap; 469 470 paddr = (unsigned long) page_address(pte_page(pte)); 471 472 __asm__ __volatile__("flush %0 + %1" 473 : /* no outputs */ 474 : "r" (paddr), 475 "r" (address & (PAGE_SIZE - 1)) 476 : "memory"); 477 478 out_unmap: 479 pte_unmap(ptep); 480 out_irqs_on: 481 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate)); 482 483 } 484 485 static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, 486 int signo, sigset_t *oldset) 487 { 488 struct signal_frame32 __user *sf; 489 int i, err, wsaved; 490 void __user *tail; 491 int sigframe_size; 492 u32 psr; 493 unsigned int seta[_COMPAT_NSIG_WORDS]; 494 495 /* 1. Make sure everything is clean */ 496 synchronize_user_stack(); 497 save_and_clear_fpu(); 498 499 wsaved = get_thread_wsaved(); 500 501 sigframe_size = sizeof(*sf); 502 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 503 sigframe_size += sizeof(__siginfo_fpu_t); 504 if (wsaved) 505 sigframe_size += sizeof(__siginfo_rwin_t); 506 507 sf = (struct signal_frame32 __user *) 508 get_sigframe(&ka->sa, regs, sigframe_size); 509 510 if (invalid_frame_pointer(sf, sigframe_size)) 511 goto sigill; 512 513 tail = (sf + 1); 514 515 /* 2. Save the current process state */ 516 if (test_thread_flag(TIF_32BIT)) { 517 regs->tpc &= 0xffffffff; 518 regs->tnpc &= 0xffffffff; 519 } 520 err = put_user(regs->tpc, &sf->info.si_regs.pc); 521 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc); 522 err |= __put_user(regs->y, &sf->info.si_regs.y); 523 psr = tstate_to_psr(regs->tstate); 524 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 525 psr |= PSR_EF; 526 err |= __put_user(psr, &sf->info.si_regs.psr); 527 for (i = 0; i < 16; i++) 528 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 529 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 530 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 531 for (i = 1; i < 16; i++) 532 err |= __put_user(((u32 *)regs->u_regs)[2*i], 533 &sf->v8plus.g_upper[i]); 534 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 535 &sf->v8plus.asi); 536 537 if (psr & PSR_EF) { 538 __siginfo_fpu_t __user *fp = tail; 539 tail += sizeof(*fp); 540 err |= save_fpu_state(regs, fp); 541 err |= __put_user((u64)fp, &sf->fpu_save); 542 } else { 543 err |= __put_user(0, &sf->fpu_save); 544 } 545 if (wsaved) { 546 __siginfo_rwin_t __user *rwp = tail; 547 tail += sizeof(*rwp); 548 err |= save_rwin_state(wsaved, rwp); 549 err |= __put_user((u64)rwp, &sf->rwin_save); 550 set_thread_wsaved(0); 551 } else { 552 err |= __put_user(0, &sf->rwin_save); 553 } 554 555 switch (_NSIG_WORDS) { 556 case 4: seta[7] = (oldset->sig[3] >> 32); 557 seta[6] = oldset->sig[3]; 558 case 3: seta[5] = (oldset->sig[2] >> 32); 559 seta[4] = oldset->sig[2]; 560 case 2: seta[3] = (oldset->sig[1] >> 32); 561 seta[2] = oldset->sig[1]; 562 case 1: seta[1] = (oldset->sig[0] >> 32); 563 seta[0] = oldset->sig[0]; 564 } 565 err |= __put_user(seta[0], &sf->info.si_mask); 566 err |= __copy_to_user(sf->extramask, seta + 1, 567 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 568 569 if (!wsaved) { 570 err |= copy_in_user((u32 __user *)sf, 571 (u32 __user *)(regs->u_regs[UREG_FP]), 572 sizeof(struct reg_window32)); 573 } else { 574 struct reg_window *rp; 575 576 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 577 for (i = 0; i < 8; i++) 578 err |= __put_user(rp->locals[i], &sf->ss.locals[i]); 579 for (i = 0; i < 6; i++) 580 err |= __put_user(rp->ins[i], &sf->ss.ins[i]); 581 err |= __put_user(rp->ins[6], &sf->ss.fp); 582 err |= __put_user(rp->ins[7], &sf->ss.callers_pc); 583 } 584 if (err) 585 goto sigsegv; 586 587 /* 3. signal handler back-trampoline and parameters */ 588 regs->u_regs[UREG_FP] = (unsigned long) sf; 589 regs->u_regs[UREG_I0] = signo; 590 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 591 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 592 593 /* 4. signal handler */ 594 regs->tpc = (unsigned long) ka->sa.sa_handler; 595 regs->tnpc = (regs->tpc + 4); 596 if (test_thread_flag(TIF_32BIT)) { 597 regs->tpc &= 0xffffffff; 598 regs->tnpc &= 0xffffffff; 599 } 600 601 /* 5. return to kernel instructions */ 602 if (ka->ka_restorer) { 603 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer; 604 } else { 605 unsigned long address = ((unsigned long)&(sf->insns[0])); 606 607 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 608 609 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/ 610 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/ 611 if (err) 612 goto sigsegv; 613 flush_signal_insns(address); 614 } 615 return 0; 616 617 sigill: 618 do_exit(SIGILL); 619 return -EINVAL; 620 621 sigsegv: 622 force_sigsegv(signo, current); 623 return -EFAULT; 624 } 625 626 static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, 627 unsigned long signr, sigset_t *oldset, 628 siginfo_t *info) 629 { 630 struct rt_signal_frame32 __user *sf; 631 int i, err, wsaved; 632 void __user *tail; 633 int sigframe_size; 634 u32 psr; 635 compat_sigset_t seta; 636 637 /* 1. Make sure everything is clean */ 638 synchronize_user_stack(); 639 save_and_clear_fpu(); 640 641 wsaved = get_thread_wsaved(); 642 643 sigframe_size = sizeof(*sf); 644 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 645 sigframe_size += sizeof(__siginfo_fpu_t); 646 if (wsaved) 647 sigframe_size += sizeof(__siginfo_rwin_t); 648 649 sf = (struct rt_signal_frame32 __user *) 650 get_sigframe(&ka->sa, regs, sigframe_size); 651 652 if (invalid_frame_pointer(sf, sigframe_size)) 653 goto sigill; 654 655 tail = (sf + 1); 656 657 /* 2. Save the current process state */ 658 if (test_thread_flag(TIF_32BIT)) { 659 regs->tpc &= 0xffffffff; 660 regs->tnpc &= 0xffffffff; 661 } 662 err = put_user(regs->tpc, &sf->regs.pc); 663 err |= __put_user(regs->tnpc, &sf->regs.npc); 664 err |= __put_user(regs->y, &sf->regs.y); 665 psr = tstate_to_psr(regs->tstate); 666 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 667 psr |= PSR_EF; 668 err |= __put_user(psr, &sf->regs.psr); 669 for (i = 0; i < 16; i++) 670 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]); 671 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 672 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 673 for (i = 1; i < 16; i++) 674 err |= __put_user(((u32 *)regs->u_regs)[2*i], 675 &sf->v8plus.g_upper[i]); 676 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 677 &sf->v8plus.asi); 678 679 if (psr & PSR_EF) { 680 __siginfo_fpu_t __user *fp = tail; 681 tail += sizeof(*fp); 682 err |= save_fpu_state(regs, fp); 683 err |= __put_user((u64)fp, &sf->fpu_save); 684 } else { 685 err |= __put_user(0, &sf->fpu_save); 686 } 687 if (wsaved) { 688 __siginfo_rwin_t __user *rwp = tail; 689 tail += sizeof(*rwp); 690 err |= save_rwin_state(wsaved, rwp); 691 err |= __put_user((u64)rwp, &sf->rwin_save); 692 set_thread_wsaved(0); 693 } else { 694 err |= __put_user(0, &sf->rwin_save); 695 } 696 697 /* Update the siginfo structure. */ 698 err |= copy_siginfo_to_user32(&sf->info, info); 699 700 /* Setup sigaltstack */ 701 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp); 702 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags); 703 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size); 704 705 switch (_NSIG_WORDS) { 706 case 4: seta.sig[7] = (oldset->sig[3] >> 32); 707 seta.sig[6] = oldset->sig[3]; 708 case 3: seta.sig[5] = (oldset->sig[2] >> 32); 709 seta.sig[4] = oldset->sig[2]; 710 case 2: seta.sig[3] = (oldset->sig[1] >> 32); 711 seta.sig[2] = oldset->sig[1]; 712 case 1: seta.sig[1] = (oldset->sig[0] >> 32); 713 seta.sig[0] = oldset->sig[0]; 714 } 715 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t)); 716 717 if (!wsaved) { 718 err |= copy_in_user((u32 __user *)sf, 719 (u32 __user *)(regs->u_regs[UREG_FP]), 720 sizeof(struct reg_window32)); 721 } else { 722 struct reg_window *rp; 723 724 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 725 for (i = 0; i < 8; i++) 726 err |= __put_user(rp->locals[i], &sf->ss.locals[i]); 727 for (i = 0; i < 6; i++) 728 err |= __put_user(rp->ins[i], &sf->ss.ins[i]); 729 err |= __put_user(rp->ins[6], &sf->ss.fp); 730 err |= __put_user(rp->ins[7], &sf->ss.callers_pc); 731 } 732 if (err) 733 goto sigsegv; 734 735 /* 3. signal handler back-trampoline and parameters */ 736 regs->u_regs[UREG_FP] = (unsigned long) sf; 737 regs->u_regs[UREG_I0] = signr; 738 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 739 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs; 740 741 /* 4. signal handler */ 742 regs->tpc = (unsigned long) ka->sa.sa_handler; 743 regs->tnpc = (regs->tpc + 4); 744 if (test_thread_flag(TIF_32BIT)) { 745 regs->tpc &= 0xffffffff; 746 regs->tnpc &= 0xffffffff; 747 } 748 749 /* 5. return to kernel instructions */ 750 if (ka->ka_restorer) 751 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer; 752 else { 753 unsigned long address = ((unsigned long)&(sf->insns[0])); 754 755 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 756 757 /* mov __NR_rt_sigreturn, %g1 */ 758 err |= __put_user(0x82102065, &sf->insns[0]); 759 760 /* t 0x10 */ 761 err |= __put_user(0x91d02010, &sf->insns[1]); 762 if (err) 763 goto sigsegv; 764 765 flush_signal_insns(address); 766 } 767 return 0; 768 769 sigill: 770 do_exit(SIGILL); 771 return -EINVAL; 772 773 sigsegv: 774 force_sigsegv(signr, current); 775 return -EFAULT; 776 } 777 778 static inline int handle_signal32(unsigned long signr, struct k_sigaction *ka, 779 siginfo_t *info, 780 sigset_t *oldset, struct pt_regs *regs) 781 { 782 int err; 783 784 if (ka->sa.sa_flags & SA_SIGINFO) 785 err = setup_rt_frame32(ka, regs, signr, oldset, info); 786 else 787 err = setup_frame32(ka, regs, signr, oldset); 788 789 if (err) 790 return err; 791 792 block_sigmask(ka, signr); 793 tracehook_signal_handler(signr, info, ka, regs, 0); 794 795 return 0; 796 } 797 798 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs, 799 struct sigaction *sa) 800 { 801 switch (regs->u_regs[UREG_I0]) { 802 case ERESTART_RESTARTBLOCK: 803 case ERESTARTNOHAND: 804 no_system_call_restart: 805 regs->u_regs[UREG_I0] = EINTR; 806 regs->tstate |= TSTATE_ICARRY; 807 break; 808 case ERESTARTSYS: 809 if (!(sa->sa_flags & SA_RESTART)) 810 goto no_system_call_restart; 811 /* fallthrough */ 812 case ERESTARTNOINTR: 813 regs->u_regs[UREG_I0] = orig_i0; 814 regs->tpc -= 4; 815 regs->tnpc -= 4; 816 } 817 } 818 819 /* Note that 'init' is a special process: it doesn't get signals it doesn't 820 * want to handle. Thus you cannot kill init even with a SIGKILL even by 821 * mistake. 822 */ 823 void do_signal32(sigset_t *oldset, struct pt_regs * regs) 824 { 825 struct k_sigaction ka; 826 unsigned long orig_i0; 827 int restart_syscall; 828 siginfo_t info; 829 int signr; 830 831 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 832 833 restart_syscall = 0; 834 orig_i0 = 0; 835 if (pt_regs_is_syscall(regs) && 836 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) { 837 restart_syscall = 1; 838 orig_i0 = regs->u_regs[UREG_G6]; 839 } 840 841 if (signr > 0) { 842 if (restart_syscall) 843 syscall_restart32(orig_i0, regs, &ka.sa); 844 if (handle_signal32(signr, &ka, &info, oldset, regs) == 0) { 845 /* A signal was successfully delivered; the saved 846 * sigmask will have been stored in the signal frame, 847 * and will be restored by sigreturn, so we can simply 848 * clear the TS_RESTORE_SIGMASK flag. 849 */ 850 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 851 } 852 return; 853 } 854 if (restart_syscall && 855 (regs->u_regs[UREG_I0] == ERESTARTNOHAND || 856 regs->u_regs[UREG_I0] == ERESTARTSYS || 857 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) { 858 /* replay the system call when we are done */ 859 regs->u_regs[UREG_I0] = orig_i0; 860 regs->tpc -= 4; 861 regs->tnpc -= 4; 862 pt_regs_clear_syscall(regs); 863 } 864 if (restart_syscall && 865 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) { 866 regs->u_regs[UREG_G1] = __NR_restart_syscall; 867 regs->tpc -= 4; 868 regs->tnpc -= 4; 869 pt_regs_clear_syscall(regs); 870 } 871 872 /* If there's no signal to deliver, we just put the saved sigmask 873 * back 874 */ 875 if (current_thread_info()->status & TS_RESTORE_SIGMASK) { 876 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 877 set_current_blocked(¤t->saved_sigmask); 878 } 879 } 880 881 struct sigstack32 { 882 u32 the_stack; 883 int cur_status; 884 }; 885 886 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp) 887 { 888 struct sigstack32 __user *ssptr = 889 (struct sigstack32 __user *)((unsigned long)(u_ssptr)); 890 struct sigstack32 __user *ossptr = 891 (struct sigstack32 __user *)((unsigned long)(u_ossptr)); 892 int ret = -EFAULT; 893 894 /* First see if old state is wanted. */ 895 if (ossptr) { 896 if (put_user(current->sas_ss_sp + current->sas_ss_size, 897 &ossptr->the_stack) || 898 __put_user(on_sig_stack(sp), &ossptr->cur_status)) 899 goto out; 900 } 901 902 /* Now see if we want to update the new state. */ 903 if (ssptr) { 904 u32 ss_sp; 905 906 if (get_user(ss_sp, &ssptr->the_stack)) 907 goto out; 908 909 /* If the current stack was set with sigaltstack, don't 910 * swap stacks while we are on it. 911 */ 912 ret = -EPERM; 913 if (current->sas_ss_sp && on_sig_stack(sp)) 914 goto out; 915 916 /* Since we don't know the extent of the stack, and we don't 917 * track onstack-ness, but rather calculate it, we must 918 * presume a size. Ho hum this interface is lossy. 919 */ 920 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ; 921 current->sas_ss_size = SIGSTKSZ; 922 } 923 924 ret = 0; 925 out: 926 return ret; 927 } 928 929 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp) 930 { 931 stack_t uss, uoss; 932 u32 u_ss_sp = 0; 933 int ret; 934 mm_segment_t old_fs; 935 stack_t32 __user *uss32 = compat_ptr(ussa); 936 stack_t32 __user *uoss32 = compat_ptr(uossa); 937 938 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) || 939 __get_user(uss.ss_flags, &uss32->ss_flags) || 940 __get_user(uss.ss_size, &uss32->ss_size))) 941 return -EFAULT; 942 uss.ss_sp = compat_ptr(u_ss_sp); 943 old_fs = get_fs(); 944 set_fs(KERNEL_DS); 945 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL, 946 uossa ? (stack_t __user *) &uoss : NULL, sp); 947 set_fs(old_fs); 948 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) || 949 __put_user(uoss.ss_flags, &uoss32->ss_flags) || 950 __put_user(uoss.ss_size, &uoss32->ss_size))) 951 return -EFAULT; 952 return ret; 953 } 954