1/* $Id: signal32.c,v 1.1.1.1 2007/08/03 18:52:18 Exp $ 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 <asm/uaccess.h> 25#include <asm/ptrace.h> 26#include <asm/svr4.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 33#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 34 35/* Signal frames: the original one (compatible with SunOS): 36 * 37 * Set up a signal frame... Make the stack look the way SunOS 38 * expects it to look which is basically: 39 * 40 * ---------------------------------- <-- %sp at signal time 41 * Struct sigcontext 42 * Signal address 43 * Ptr to sigcontext area above 44 * Signal code 45 * The signal number itself 46 * One register window 47 * ---------------------------------- <-- New %sp 48 */ 49struct signal_sframe32 { 50 struct reg_window32 sig_window; 51 int sig_num; 52 int sig_code; 53 /* struct sigcontext32 * */ u32 sig_scptr; 54 int sig_address; 55 struct sigcontext32 sig_context; 56 unsigned int extramask[_COMPAT_NSIG_WORDS - 1]; 57}; 58 59/* This magic should be in g_upper[0] for all upper parts 60 * to be valid. 61 */ 62#define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269 63typedef struct { 64 unsigned int g_upper[8]; 65 unsigned int o_upper[8]; 66 unsigned int asi; 67} siginfo_extra_v8plus_t; 68 69/* 70 * And the new one, intended to be used for Linux applications only 71 * (we have enough in there to work with clone). 72 * All the interesting bits are in the info field. 73 */ 74struct new_signal_frame32 { 75 struct sparc_stackf32 ss; 76 __siginfo32_t info; 77 /* __siginfo_fpu32_t * */ u32 fpu_save; 78 unsigned int insns[2]; 79 unsigned int extramask[_COMPAT_NSIG_WORDS - 1]; 80 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ 81 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ 82 siginfo_extra_v8plus_t v8plus; 83 __siginfo_fpu_t fpu_state; 84}; 85 86typedef struct compat_siginfo{ 87 int si_signo; 88 int si_errno; 89 int si_code; 90 91 union { 92 int _pad[SI_PAD_SIZE32]; 93 94 /* kill() */ 95 struct { 96 compat_pid_t _pid; /* sender's pid */ 97 unsigned int _uid; /* sender's uid */ 98 } _kill; 99 100 /* POSIX.1b timers */ 101 struct { 102 compat_timer_t _tid; /* timer id */ 103 int _overrun; /* overrun count */ 104 compat_sigval_t _sigval; /* same as below */ 105 int _sys_private; /* not to be passed to user */ 106 } _timer; 107 108 /* POSIX.1b signals */ 109 struct { 110 compat_pid_t _pid; /* sender's pid */ 111 unsigned int _uid; /* sender's uid */ 112 compat_sigval_t _sigval; 113 } _rt; 114 115 /* SIGCHLD */ 116 struct { 117 compat_pid_t _pid; /* which child */ 118 unsigned int _uid; /* sender's uid */ 119 int _status; /* exit code */ 120 compat_clock_t _utime; 121 compat_clock_t _stime; 122 } _sigchld; 123 124 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */ 125 struct { 126 u32 _addr; /* faulting insn/memory ref. */ 127 int _trapno; 128 } _sigfault; 129 130 /* SIGPOLL */ 131 struct { 132 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */ 133 int _fd; 134 } _sigpoll; 135 } _sifields; 136}compat_siginfo_t; 137 138struct rt_signal_frame32 { 139 struct sparc_stackf32 ss; 140 compat_siginfo_t info; 141 struct pt_regs32 regs; 142 compat_sigset_t mask; 143 /* __siginfo_fpu32_t * */ u32 fpu_save; 144 unsigned int insns[2]; 145 stack_t32 stack; 146 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */ 147 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */ 148 siginfo_extra_v8plus_t v8plus; 149 __siginfo_fpu_t fpu_state; 150}; 151 152/* Align macros */ 153#define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7))) 154#define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7))) 155#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7))) 156 157int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 158{ 159 int err; 160 161 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 162 return -EFAULT; 163 164 /* If you change siginfo_t structure, please be sure 165 this code is fixed accordingly. 166 It should never copy any pad contained in the structure 167 to avoid security leaks, but must copy the generic 168 3 ints plus the relevant union member. 169 This routine must convert siginfo from 64bit to 32bit as well 170 at the same time. */ 171 err = __put_user(from->si_signo, &to->si_signo); 172 err |= __put_user(from->si_errno, &to->si_errno); 173 err |= __put_user((short)from->si_code, &to->si_code); 174 if (from->si_code < 0) 175 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 176 else { 177 switch (from->si_code >> 16) { 178 case __SI_TIMER >> 16: 179 err |= __put_user(from->si_tid, &to->si_tid); 180 err |= __put_user(from->si_overrun, &to->si_overrun); 181 err |= __put_user(from->si_int, &to->si_int); 182 break; 183 case __SI_CHLD >> 16: 184 err |= __put_user(from->si_utime, &to->si_utime); 185 err |= __put_user(from->si_stime, &to->si_stime); 186 err |= __put_user(from->si_status, &to->si_status); 187 default: 188 err |= __put_user(from->si_pid, &to->si_pid); 189 err |= __put_user(from->si_uid, &to->si_uid); 190 break; 191 case __SI_FAULT >> 16: 192 err |= __put_user(from->si_trapno, &to->si_trapno); 193 err |= __put_user((unsigned long)from->si_addr, &to->si_addr); 194 break; 195 case __SI_POLL >> 16: 196 err |= __put_user(from->si_band, &to->si_band); 197 err |= __put_user(from->si_fd, &to->si_fd); 198 break; 199 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 200 case __SI_MESGQ >> 16: 201 err |= __put_user(from->si_pid, &to->si_pid); 202 err |= __put_user(from->si_uid, &to->si_uid); 203 err |= __put_user(from->si_int, &to->si_int); 204 break; 205 } 206 } 207 return err; 208} 209 210/* CAUTION: This is just a very minimalist implementation for the 211 * sake of compat_sys_rt_sigqueueinfo() 212 */ 213int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 214{ 215 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t))) 216 return -EFAULT; 217 218 if (copy_from_user(to, from, 3*sizeof(int)) || 219 copy_from_user(to->_sifields._pad, from->_sifields._pad, 220 SI_PAD_SIZE)) 221 return -EFAULT; 222 223 return 0; 224} 225 226static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) 227{ 228 unsigned long *fpregs = current_thread_info()->fpregs; 229 unsigned long fprs; 230 int err; 231 232 err = __get_user(fprs, &fpu->si_fprs); 233 fprs_write(0); 234 regs->tstate &= ~TSTATE_PEF; 235 if (fprs & FPRS_DL) 236 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32)); 237 if (fprs & FPRS_DU) 238 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32)); 239 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr); 240 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr); 241 current_thread_info()->fpsaved[0] |= fprs; 242 return err; 243} 244 245void do_new_sigreturn32(struct pt_regs *regs) 246{ 247 struct new_signal_frame32 __user *sf; 248 unsigned int psr; 249 unsigned pc, npc, fpu_save; 250 sigset_t set; 251 unsigned seta[_COMPAT_NSIG_WORDS]; 252 int err, i; 253 254 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 255 sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP]; 256 257 /* 1. Make sure we are not getting garbage from the user */ 258 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) || 259 (((unsigned long) sf) & 3)) 260 goto segv; 261 262 get_user(pc, &sf->info.si_regs.pc); 263 __get_user(npc, &sf->info.si_regs.npc); 264 265 if ((pc | npc) & 3) 266 goto segv; 267 268 if (test_thread_flag(TIF_32BIT)) { 269 pc &= 0xffffffff; 270 npc &= 0xffffffff; 271 } 272 regs->tpc = pc; 273 regs->tnpc = npc; 274 275 /* 2. Restore the state */ 276 err = __get_user(regs->y, &sf->info.si_regs.y); 277 err |= __get_user(psr, &sf->info.si_regs.psr); 278 279 for (i = UREG_G1; i <= UREG_I7; i++) 280 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 281 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 282 err |= __get_user(i, &sf->v8plus.g_upper[0]); 283 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 284 unsigned long asi; 285 286 for (i = UREG_G1; i <= UREG_I7; i++) 287 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 288 err |= __get_user(asi, &sf->v8plus.asi); 289 regs->tstate &= ~TSTATE_ASI; 290 regs->tstate |= ((asi & 0xffUL) << 24UL); 291 } 292 } 293 294 /* User can only change condition codes in %tstate. */ 295 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 296 regs->tstate |= psr_to_tstate_icc(psr); 297 298 err |= __get_user(fpu_save, &sf->fpu_save); 299 if (fpu_save) 300 err |= restore_fpu_state32(regs, &sf->fpu_state); 301 err |= __get_user(seta[0], &sf->info.si_mask); 302 err |= copy_from_user(seta+1, &sf->extramask, 303 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 304 if (err) 305 goto segv; 306 switch (_NSIG_WORDS) { 307 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32); 308 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32); 309 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32); 310 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32); 311 } 312 sigdelsetmask(&set, ~_BLOCKABLE); 313 spin_lock_irq(¤t->sighand->siglock); 314 current->blocked = set; 315 recalc_sigpending(); 316 spin_unlock_irq(¤t->sighand->siglock); 317 return; 318 319segv: 320 force_sig(SIGSEGV, current); 321} 322 323asmlinkage void do_sigreturn32(struct pt_regs *regs) 324{ 325 struct sigcontext32 __user *scptr; 326 unsigned int pc, npc, psr; 327 sigset_t set; 328 unsigned int seta[_COMPAT_NSIG_WORDS]; 329 int err; 330 331 /* Always make any pending restarted system calls return -EINTR */ 332 current_thread_info()->restart_block.fn = do_no_restart_syscall; 333 334 synchronize_user_stack(); 335 if (test_thread_flag(TIF_NEWSIGNALS)) { 336 do_new_sigreturn32(regs); 337 return; 338 } 339 340 scptr = (struct sigcontext32 __user *) 341 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL); 342 /* Check sanity of the user arg. */ 343 if (!access_ok(VERIFY_READ, scptr, sizeof(struct sigcontext32)) || 344 (((unsigned long) scptr) & 3)) 345 goto segv; 346 347 err = __get_user(pc, &scptr->sigc_pc); 348 err |= __get_user(npc, &scptr->sigc_npc); 349 350 if ((pc | npc) & 3) 351 goto segv; /* Nice try. */ 352 353 err |= __get_user(seta[0], &scptr->sigc_mask); 354 /* Note that scptr + 1 points to extramask */ 355 err |= copy_from_user(seta+1, scptr + 1, 356 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 357 if (err) 358 goto segv; 359 switch (_NSIG_WORDS) { 360 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32); 361 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32); 362 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32); 363 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32); 364 } 365 sigdelsetmask(&set, ~_BLOCKABLE); 366 spin_lock_irq(¤t->sighand->siglock); 367 current->blocked = set; 368 recalc_sigpending(); 369 spin_unlock_irq(¤t->sighand->siglock); 370 371 if (test_thread_flag(TIF_32BIT)) { 372 pc &= 0xffffffff; 373 npc &= 0xffffffff; 374 } 375 regs->tpc = pc; 376 regs->tnpc = npc; 377 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp); 378 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0); 379 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1); 380 381 /* User can only change condition codes in %tstate. */ 382 err |= __get_user(psr, &scptr->sigc_psr); 383 if (err) 384 goto segv; 385 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 386 regs->tstate |= psr_to_tstate_icc(psr); 387 return; 388 389segv: 390 force_sig(SIGSEGV, current); 391} 392 393asmlinkage void do_rt_sigreturn32(struct pt_regs *regs) 394{ 395 struct rt_signal_frame32 __user *sf; 396 unsigned int psr, pc, npc, fpu_save, u_ss_sp; 397 mm_segment_t old_fs; 398 sigset_t set; 399 compat_sigset_t seta; 400 stack_t st; 401 int err, i; 402 403 /* Always make any pending restarted system calls return -EINTR */ 404 current_thread_info()->restart_block.fn = do_no_restart_syscall; 405 406 synchronize_user_stack(); 407 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 408 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP]; 409 410 /* 1. Make sure we are not getting garbage from the user */ 411 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) || 412 (((unsigned long) sf) & 3)) 413 goto segv; 414 415 get_user(pc, &sf->regs.pc); 416 __get_user(npc, &sf->regs.npc); 417 418 if ((pc | npc) & 3) 419 goto segv; 420 421 if (test_thread_flag(TIF_32BIT)) { 422 pc &= 0xffffffff; 423 npc &= 0xffffffff; 424 } 425 regs->tpc = pc; 426 regs->tnpc = npc; 427 428 /* 2. Restore the state */ 429 err = __get_user(regs->y, &sf->regs.y); 430 err |= __get_user(psr, &sf->regs.psr); 431 432 for (i = UREG_G1; i <= UREG_I7; i++) 433 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]); 434 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) { 435 err |= __get_user(i, &sf->v8plus.g_upper[0]); 436 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) { 437 unsigned long asi; 438 439 for (i = UREG_G1; i <= UREG_I7; i++) 440 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]); 441 err |= __get_user(asi, &sf->v8plus.asi); 442 regs->tstate &= ~TSTATE_ASI; 443 regs->tstate |= ((asi & 0xffUL) << 24UL); 444 } 445 } 446 447 /* User can only change condition codes in %tstate. */ 448 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 449 regs->tstate |= psr_to_tstate_icc(psr); 450 451 err |= __get_user(fpu_save, &sf->fpu_save); 452 if (fpu_save) 453 err |= restore_fpu_state32(regs, &sf->fpu_state); 454 err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t)); 455 err |= __get_user(u_ss_sp, &sf->stack.ss_sp); 456 st.ss_sp = compat_ptr(u_ss_sp); 457 err |= __get_user(st.ss_flags, &sf->stack.ss_flags); 458 err |= __get_user(st.ss_size, &sf->stack.ss_size); 459 if (err) 460 goto segv; 461 462 /* It is more difficult to avoid calling this function than to 463 call it and ignore errors. */ 464 old_fs = get_fs(); 465 set_fs(KERNEL_DS); 466 do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf); 467 set_fs(old_fs); 468 469 switch (_NSIG_WORDS) { 470 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32); 471 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32); 472 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32); 473 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32); 474 } 475 sigdelsetmask(&set, ~_BLOCKABLE); 476 spin_lock_irq(¤t->sighand->siglock); 477 current->blocked = set; 478 recalc_sigpending(); 479 spin_unlock_irq(¤t->sighand->siglock); 480 return; 481segv: 482 force_sig(SIGSEGV, current); 483} 484 485/* Checks if the fp is valid */ 486static int invalid_frame_pointer(void __user *fp, int fplen) 487{ 488 if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen) 489 return 1; 490 return 0; 491} 492 493static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize) 494{ 495 unsigned long sp; 496 497 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 498 sp = regs->u_regs[UREG_FP]; 499 500 /* This is the X/Open sanctioned signal stack switching. */ 501 if (sa->sa_flags & SA_ONSTACK) { 502 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7)) 503 sp = current->sas_ss_sp + current->sas_ss_size; 504 } 505 return (void __user *)(sp - framesize); 506} 507 508static void 509setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info) 510{ 511 struct signal_sframe32 __user *sframep; 512 struct sigcontext32 __user *sc; 513 unsigned int seta[_COMPAT_NSIG_WORDS]; 514 int err = 0; 515 void __user *sig_address; 516 int sig_code; 517 unsigned long pc = regs->tpc; 518 unsigned long npc = regs->tnpc; 519 unsigned int psr; 520 521 if (test_thread_flag(TIF_32BIT)) { 522 pc &= 0xffffffff; 523 npc &= 0xffffffff; 524 } 525 526 synchronize_user_stack(); 527 save_and_clear_fpu(); 528 529 sframep = (struct signal_sframe32 __user *) 530 get_sigframe(sa, regs, SF_ALIGNEDSZ); 531 if (invalid_frame_pointer(sframep, sizeof(*sframep))){ 532 /* Don't change signal code and address, so that 533 * post mortem debuggers can have a look. 534 */ 535 do_exit(SIGILL); 536 } 537 538 sc = &sframep->sig_context; 539 540 /* We've already made sure frame pointer isn't in kernel space... */ 541 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK), 542 &sc->sigc_onstack); 543 544 switch (_NSIG_WORDS) { 545 case 4: seta[7] = (oldset->sig[3] >> 32); 546 seta[6] = oldset->sig[3]; 547 case 3: seta[5] = (oldset->sig[2] >> 32); 548 seta[4] = oldset->sig[2]; 549 case 2: seta[3] = (oldset->sig[1] >> 32); 550 seta[2] = oldset->sig[1]; 551 case 1: seta[1] = (oldset->sig[0] >> 32); 552 seta[0] = oldset->sig[0]; 553 } 554 err |= __put_user(seta[0], &sc->sigc_mask); 555 err |= __copy_to_user(sframep->extramask, seta + 1, 556 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 557 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp); 558 err |= __put_user(pc, &sc->sigc_pc); 559 err |= __put_user(npc, &sc->sigc_npc); 560 psr = tstate_to_psr(regs->tstate); 561 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 562 psr |= PSR_EF; 563 err |= __put_user(psr, &sc->sigc_psr); 564 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1); 565 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0); 566 err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins); 567 568 err |= copy_in_user((u32 __user *)sframep, 569 (u32 __user *)(regs->u_regs[UREG_FP]), 570 sizeof(struct reg_window32)); 571 572 set_thread_wsaved(0); /* So process is allowed to execute. */ 573 err |= __put_user(signr, &sframep->sig_num); 574 sig_address = NULL; 575 sig_code = 0; 576 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) { 577 sig_address = info->si_addr; 578 switch (signr) { 579 case SIGSEGV: 580 switch (info->si_code) { 581 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break; 582 default: sig_code = SUBSIG_PROTECTION; break; 583 } 584 break; 585 case SIGILL: 586 switch (info->si_code) { 587 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break; 588 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break; 589 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break; 590 default: sig_code = SUBSIG_STACK; break; 591 } 592 break; 593 case SIGFPE: 594 switch (info->si_code) { 595 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break; 596 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break; 597 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break; 598 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break; 599 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break; 600 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break; 601 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break; 602 default: sig_code = SUBSIG_FPERROR; break; 603 } 604 break; 605 case SIGBUS: 606 switch (info->si_code) { 607 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break; 608 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break; 609 default: sig_code = SUBSIG_BUSTIMEOUT; break; 610 } 611 break; 612 case SIGEMT: 613 switch (info->si_code) { 614 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break; 615 } 616 break; 617 case SIGSYS: 618 if (info->si_code == (__SI_FAULT|0x100)) { 619 /* See sys_sunos32.c */ 620 sig_code = info->si_trapno; 621 break; 622 } 623 default: 624 sig_address = NULL; 625 } 626 } 627 err |= __put_user(ptr_to_compat(sig_address), &sframep->sig_address); 628 err |= __put_user(sig_code, &sframep->sig_code); 629 err |= __put_user(ptr_to_compat(sc), &sframep->sig_scptr); 630 if (err) 631 goto sigsegv; 632 633 regs->u_regs[UREG_FP] = (unsigned long) sframep; 634 regs->tpc = (unsigned long) sa->sa_handler; 635 regs->tnpc = (regs->tpc + 4); 636 if (test_thread_flag(TIF_32BIT)) { 637 regs->tpc &= 0xffffffff; 638 regs->tnpc &= 0xffffffff; 639 } 640 return; 641 642sigsegv: 643 force_sigsegv(signr, current); 644} 645 646 647static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) 648{ 649 unsigned long *fpregs = current_thread_info()->fpregs; 650 unsigned long fprs; 651 int err = 0; 652 653 fprs = current_thread_info()->fpsaved[0]; 654 if (fprs & FPRS_DL) 655 err |= copy_to_user(&fpu->si_float_regs[0], fpregs, 656 (sizeof(unsigned int) * 32)); 657 if (fprs & FPRS_DU) 658 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16, 659 (sizeof(unsigned int) * 32)); 660 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr); 661 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr); 662 err |= __put_user(fprs, &fpu->si_fprs); 663 664 return err; 665} 666 667static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs, 668 int signo, sigset_t *oldset) 669{ 670 struct new_signal_frame32 __user *sf; 671 int sigframe_size; 672 u32 psr; 673 int i, err; 674 unsigned int seta[_COMPAT_NSIG_WORDS]; 675 676 /* 1. Make sure everything is clean */ 677 synchronize_user_stack(); 678 save_and_clear_fpu(); 679 680 sigframe_size = NF_ALIGNEDSZ; 681 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) 682 sigframe_size -= sizeof(__siginfo_fpu_t); 683 684 sf = (struct new_signal_frame32 __user *) 685 get_sigframe(&ka->sa, regs, sigframe_size); 686 687 if (invalid_frame_pointer(sf, sigframe_size)) 688 goto sigill; 689 690 if (get_thread_wsaved() != 0) 691 goto sigill; 692 693 /* 2. Save the current process state */ 694 if (test_thread_flag(TIF_32BIT)) { 695 regs->tpc &= 0xffffffff; 696 regs->tnpc &= 0xffffffff; 697 } 698 err = put_user(regs->tpc, &sf->info.si_regs.pc); 699 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc); 700 err |= __put_user(regs->y, &sf->info.si_regs.y); 701 psr = tstate_to_psr(regs->tstate); 702 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 703 psr |= PSR_EF; 704 err |= __put_user(psr, &sf->info.si_regs.psr); 705 for (i = 0; i < 16; i++) 706 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]); 707 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 708 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 709 for (i = 1; i < 16; i++) 710 err |= __put_user(((u32 *)regs->u_regs)[2*i], 711 &sf->v8plus.g_upper[i]); 712 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 713 &sf->v8plus.asi); 714 715 if (psr & PSR_EF) { 716 err |= save_fpu_state32(regs, &sf->fpu_state); 717 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); 718 } else { 719 err |= __put_user(0, &sf->fpu_save); 720 } 721 722 switch (_NSIG_WORDS) { 723 case 4: seta[7] = (oldset->sig[3] >> 32); 724 seta[6] = oldset->sig[3]; 725 case 3: seta[5] = (oldset->sig[2] >> 32); 726 seta[4] = oldset->sig[2]; 727 case 2: seta[3] = (oldset->sig[1] >> 32); 728 seta[2] = oldset->sig[1]; 729 case 1: seta[1] = (oldset->sig[0] >> 32); 730 seta[0] = oldset->sig[0]; 731 } 732 err |= __put_user(seta[0], &sf->info.si_mask); 733 err |= __copy_to_user(sf->extramask, seta + 1, 734 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int)); 735 736 err |= copy_in_user((u32 __user *)sf, 737 (u32 __user *)(regs->u_regs[UREG_FP]), 738 sizeof(struct reg_window32)); 739 740 if (err) 741 goto sigsegv; 742 743 /* 3. signal handler back-trampoline and parameters */ 744 regs->u_regs[UREG_FP] = (unsigned long) sf; 745 regs->u_regs[UREG_I0] = signo; 746 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 747 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 748 749 /* 4. signal handler */ 750 regs->tpc = (unsigned long) ka->sa.sa_handler; 751 regs->tnpc = (regs->tpc + 4); 752 if (test_thread_flag(TIF_32BIT)) { 753 regs->tpc &= 0xffffffff; 754 regs->tnpc &= 0xffffffff; 755 } 756 757 /* 5. return to kernel instructions */ 758 if (ka->ka_restorer) { 759 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer; 760 } else { 761 /* Flush instruction space. */ 762 unsigned long address = ((unsigned long)&(sf->insns[0])); 763 pgd_t *pgdp = pgd_offset(current->mm, address); 764 pud_t *pudp = pud_offset(pgdp, address); 765 pmd_t *pmdp = pmd_offset(pudp, address); 766 pte_t *ptep; 767 pte_t pte; 768 769 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 770 771 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/ 772 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/ 773 if (err) 774 goto sigsegv; 775 776 preempt_disable(); 777 ptep = pte_offset_map(pmdp, address); 778 pte = *ptep; 779 if (pte_present(pte)) { 780 unsigned long page = (unsigned long) 781 page_address(pte_page(pte)); 782 783 wmb(); 784 __asm__ __volatile__("flush %0 + %1" 785 : /* no outputs */ 786 : "r" (page), 787 "r" (address & (PAGE_SIZE - 1)) 788 : "memory"); 789 } 790 pte_unmap(ptep); 791 preempt_enable(); 792 } 793 return; 794 795sigill: 796 do_exit(SIGILL); 797sigsegv: 798 force_sigsegv(signo, current); 799} 800 801/* Setup a Solaris stack frame */ 802static void 803setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc, 804 struct pt_regs *regs, int signr, sigset_t *oldset) 805{ 806 svr4_signal_frame_t __user *sfp; 807 svr4_gregset_t __user *gr; 808 svr4_siginfo_t __user *si; 809 svr4_mcontext_t __user *mc; 810 svr4_gwindows_t __user *gw; 811 svr4_ucontext_t __user *uc; 812 svr4_sigset_t setv; 813 unsigned int psr; 814 int i, err; 815 816 synchronize_user_stack(); 817 save_and_clear_fpu(); 818 819 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL; 820 sfp = (svr4_signal_frame_t __user *) 821 get_sigframe(sa, regs, 822 sizeof(struct reg_window32) + SVR4_SF_ALIGNED); 823 824 if (invalid_frame_pointer(sfp, sizeof(*sfp))) 825 do_exit(SIGILL); 826 827 /* Start with a clean frame pointer and fill it */ 828 err = clear_user(sfp, sizeof(*sfp)); 829 830 /* Setup convenience variables */ 831 si = &sfp->si; 832 uc = &sfp->uc; 833 gw = &sfp->gw; 834 mc = &uc->mcontext; 835 gr = &mc->greg; 836 837 setv.sigbits[0] = oldset->sig[0]; 838 setv.sigbits[1] = (oldset->sig[0] >> 32); 839 if (_NSIG_WORDS >= 2) { 840 setv.sigbits[2] = oldset->sig[1]; 841 setv.sigbits[3] = (oldset->sig[1] >> 32); 842 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t)); 843 } else 844 err |= __copy_to_user(&uc->sigmask, &setv, 845 2 * sizeof(unsigned int)); 846 847 /* Store registers */ 848 if (test_thread_flag(TIF_32BIT)) { 849 regs->tpc &= 0xffffffff; 850 regs->tnpc &= 0xffffffff; 851 } 852 err |= __put_user(regs->tpc, &((*gr)[SVR4_PC])); 853 err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC])); 854 psr = tstate_to_psr(regs->tstate); 855 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 856 psr |= PSR_EF; 857 err |= __put_user(psr, &((*gr)[SVR4_PSR])); 858 err |= __put_user(regs->y, &((*gr)[SVR4_Y])); 859 860 /* Copy g[1..7] and o[0..7] registers */ 861 for (i = 0; i < 7; i++) 862 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i); 863 for (i = 0; i < 8; i++) 864 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i); 865 866 /* Setup sigaltstack */ 867 err |= __put_user(current->sas_ss_sp, &uc->stack.sp); 868 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags); 869 err |= __put_user(current->sas_ss_size, &uc->stack.size); 870 871 /* Save the currently window file: */ 872 873 /* 1. Link sfp->uc->gwins to our windows */ 874 err |= __put_user(ptr_to_compat(gw), &mc->gwin); 875 876 /* 2. Number of windows to restore at setcontext (): */ 877 err |= __put_user(get_thread_wsaved(), &gw->count); 878 879 /* 3. We just pay attention to the gw->count field on setcontext */ 880 set_thread_wsaved(0); /* So process is allowed to execute. */ 881 882 /* Setup the signal information. Solaris expects a bunch of 883 * information to be passed to the signal handler, we don't provide 884 * that much currently, should use siginfo. 885 */ 886 err |= __put_user(signr, &si->siginfo.signo); 887 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code); 888 if (err) 889 goto sigsegv; 890 891 regs->u_regs[UREG_FP] = (unsigned long) sfp; 892 regs->tpc = (unsigned long) sa->sa_handler; 893 regs->tnpc = (regs->tpc + 4); 894 if (test_thread_flag(TIF_32BIT)) { 895 regs->tpc &= 0xffffffff; 896 regs->tnpc &= 0xffffffff; 897 } 898 899 /* Arguments passed to signal handler */ 900 if (regs->u_regs[14]){ 901 struct reg_window32 __user *rw = (struct reg_window32 __user *) 902 (regs->u_regs[14] & 0x00000000ffffffffUL); 903 904 err |= __put_user(signr, &rw->ins[0]); 905 err |= __put_user((u64)si, &rw->ins[1]); 906 err |= __put_user((u64)uc, &rw->ins[2]); 907 err |= __put_user((u64)sfp, &rw->ins[6]); /* frame pointer */ 908 if (err) 909 goto sigsegv; 910 911 regs->u_regs[UREG_I0] = signr; 912 regs->u_regs[UREG_I1] = (u32)(u64) si; 913 regs->u_regs[UREG_I2] = (u32)(u64) uc; 914 } 915 return; 916 917sigsegv: 918 force_sigsegv(signr, current); 919} 920 921asmlinkage int 922svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs) 923{ 924 svr4_gregset_t __user *gr; 925 svr4_mcontext_t __user *mc; 926 svr4_sigset_t setv; 927 int i, err; 928 u32 psr; 929 930 synchronize_user_stack(); 931 save_and_clear_fpu(); 932 933 if (get_thread_wsaved()) 934 do_exit(SIGSEGV); 935 936 err = clear_user(uc, sizeof(*uc)); 937 938 /* Setup convenience variables */ 939 mc = &uc->mcontext; 940 gr = &mc->greg; 941 942 setv.sigbits[0] = current->blocked.sig[0]; 943 setv.sigbits[1] = (current->blocked.sig[0] >> 32); 944 if (_NSIG_WORDS >= 2) { 945 setv.sigbits[2] = current->blocked.sig[1]; 946 setv.sigbits[3] = (current->blocked.sig[1] >> 32); 947 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t)); 948 } else 949 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned)); 950 951 /* Store registers */ 952 if (test_thread_flag(TIF_32BIT)) { 953 regs->tpc &= 0xffffffff; 954 regs->tnpc &= 0xffffffff; 955 } 956 err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]); 957 err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]); 958 959 psr = tstate_to_psr(regs->tstate) & ~PSR_EF; 960 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 961 psr |= PSR_EF; 962 err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]); 963 964 err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]); 965 966 /* Copy g[1..7] and o[0..7] registers */ 967 for (i = 0; i < 7; i++) 968 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i); 969 for (i = 0; i < 8; i++) 970 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i); 971 972 /* Setup sigaltstack */ 973 err |= __put_user(current->sas_ss_sp, &uc->stack.sp); 974 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags); 975 err |= __put_user(current->sas_ss_size, &uc->stack.size); 976 977 /* The register file is not saved 978 * we have already stuffed all of it with sync_user_stack 979 */ 980 return (err ? -EFAULT : 0); 981} 982 983 984/* Set the context for a svr4 application, this is Solaris way to sigreturn */ 985asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs) 986{ 987 svr4_gregset_t __user *gr; 988 mm_segment_t old_fs; 989 u32 pc, npc, psr, u_ss_sp; 990 sigset_t set; 991 svr4_sigset_t setv; 992 int i, err; 993 stack_t st; 994 995 flush_user_windows(); 996 997 if (get_thread_wsaved()) 998 goto sigsegv; 999 1000 if (((unsigned long) c) & 3){ 1001 printk("Unaligned structure passed\n"); 1002 goto sigsegv; 1003 } 1004 1005 if (!__access_ok(c, sizeof(*c))) { 1006 /* Miguel, add nice debugging msg _here_. ;-) */ 1007 goto sigsegv; 1008 } 1009 1010 /* Check for valid PC and nPC */ 1011 gr = &c->mcontext.greg; 1012 err = __get_user(pc, &((*gr)[SVR4_PC])); 1013 err |= __get_user(npc, &((*gr)[SVR4_NPC])); 1014 if ((pc | npc) & 3) 1015 goto sigsegv; 1016 1017 /* Retrieve information from passed ucontext */ 1018 /* note that nPC is ored a 1, this is used to inform entry.S */ 1019 /* that we don't want it to mess with our PC and nPC */ 1020 1021 err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t)); 1022 set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32); 1023 if (_NSIG_WORDS >= 2) 1024 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32); 1025 1026 err |= __get_user(u_ss_sp, &c->stack.sp); 1027 st.ss_sp = compat_ptr(u_ss_sp); 1028 err |= __get_user(st.ss_flags, &c->stack.flags); 1029 err |= __get_user(st.ss_size, &c->stack.size); 1030 if (err) 1031 goto sigsegv; 1032 1033 /* It is more difficult to avoid calling this function than to 1034 call it and ignore errors. */ 1035 old_fs = get_fs(); 1036 set_fs(KERNEL_DS); 1037 do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]); 1038 set_fs(old_fs); 1039 1040 sigdelsetmask(&set, ~_BLOCKABLE); 1041 spin_lock_irq(¤t->sighand->siglock); 1042 current->blocked = set; 1043 recalc_sigpending(); 1044 spin_unlock_irq(¤t->sighand->siglock); 1045 regs->tpc = pc; 1046 regs->tnpc = npc | 1; 1047 if (test_thread_flag(TIF_32BIT)) { 1048 regs->tpc &= 0xffffffff; 1049 regs->tnpc &= 0xffffffff; 1050 } 1051 err |= __get_user(regs->y, &((*gr)[SVR4_Y])); 1052 err |= __get_user(psr, &((*gr)[SVR4_PSR])); 1053 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC); 1054 regs->tstate |= psr_to_tstate_icc(psr); 1055 1056 /* Restore g[1..7] and o[0..7] registers */ 1057 for (i = 0; i < 7; i++) 1058 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i); 1059 for (i = 0; i < 8; i++) 1060 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i); 1061 if (err) 1062 goto sigsegv; 1063 1064 return -EINTR; 1065sigsegv: 1066 return -EFAULT; 1067} 1068 1069static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs, 1070 unsigned long signr, sigset_t *oldset, 1071 siginfo_t *info) 1072{ 1073 struct rt_signal_frame32 __user *sf; 1074 int sigframe_size; 1075 u32 psr; 1076 int i, err; 1077 compat_sigset_t seta; 1078 1079 /* 1. Make sure everything is clean */ 1080 synchronize_user_stack(); 1081 save_and_clear_fpu(); 1082 1083 sigframe_size = RT_ALIGNEDSZ; 1084 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) 1085 sigframe_size -= sizeof(__siginfo_fpu_t); 1086 1087 sf = (struct rt_signal_frame32 __user *) 1088 get_sigframe(&ka->sa, regs, sigframe_size); 1089 1090 if (invalid_frame_pointer(sf, sigframe_size)) 1091 goto sigill; 1092 1093 if (get_thread_wsaved() != 0) 1094 goto sigill; 1095 1096 /* 2. Save the current process state */ 1097 if (test_thread_flag(TIF_32BIT)) { 1098 regs->tpc &= 0xffffffff; 1099 regs->tnpc &= 0xffffffff; 1100 } 1101 err = put_user(regs->tpc, &sf->regs.pc); 1102 err |= __put_user(regs->tnpc, &sf->regs.npc); 1103 err |= __put_user(regs->y, &sf->regs.y); 1104 psr = tstate_to_psr(regs->tstate); 1105 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 1106 psr |= PSR_EF; 1107 err |= __put_user(psr, &sf->regs.psr); 1108 for (i = 0; i < 16; i++) 1109 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]); 1110 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size); 1111 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]); 1112 for (i = 1; i < 16; i++) 1113 err |= __put_user(((u32 *)regs->u_regs)[2*i], 1114 &sf->v8plus.g_upper[i]); 1115 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL, 1116 &sf->v8plus.asi); 1117 1118 if (psr & PSR_EF) { 1119 err |= save_fpu_state32(regs, &sf->fpu_state); 1120 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); 1121 } else { 1122 err |= __put_user(0, &sf->fpu_save); 1123 } 1124 1125 /* Update the siginfo structure. */ 1126 err |= copy_siginfo_to_user32(&sf->info, info); 1127 1128 /* Setup sigaltstack */ 1129 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp); 1130 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags); 1131 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size); 1132 1133 switch (_NSIG_WORDS) { 1134 case 4: seta.sig[7] = (oldset->sig[3] >> 32); 1135 seta.sig[6] = oldset->sig[3]; 1136 case 3: seta.sig[5] = (oldset->sig[2] >> 32); 1137 seta.sig[4] = oldset->sig[2]; 1138 case 2: seta.sig[3] = (oldset->sig[1] >> 32); 1139 seta.sig[2] = oldset->sig[1]; 1140 case 1: seta.sig[1] = (oldset->sig[0] >> 32); 1141 seta.sig[0] = oldset->sig[0]; 1142 } 1143 err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t)); 1144 1145 err |= copy_in_user((u32 __user *)sf, 1146 (u32 __user *)(regs->u_regs[UREG_FP]), 1147 sizeof(struct reg_window32)); 1148 if (err) 1149 goto sigsegv; 1150 1151 /* 3. signal handler back-trampoline and parameters */ 1152 regs->u_regs[UREG_FP] = (unsigned long) sf; 1153 regs->u_regs[UREG_I0] = signr; 1154 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 1155 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs; 1156 1157 /* 4. signal handler */ 1158 regs->tpc = (unsigned long) ka->sa.sa_handler; 1159 regs->tnpc = (regs->tpc + 4); 1160 if (test_thread_flag(TIF_32BIT)) { 1161 regs->tpc &= 0xffffffff; 1162 regs->tnpc &= 0xffffffff; 1163 } 1164 1165 /* 5. return to kernel instructions */ 1166 if (ka->ka_restorer) 1167 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer; 1168 else { 1169 /* Flush instruction space. */ 1170 unsigned long address = ((unsigned long)&(sf->insns[0])); 1171 pgd_t *pgdp = pgd_offset(current->mm, address); 1172 pud_t *pudp = pud_offset(pgdp, address); 1173 pmd_t *pmdp = pmd_offset(pudp, address); 1174 pte_t *ptep; 1175 1176 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2); 1177 1178 /* mov __NR_rt_sigreturn, %g1 */ 1179 err |= __put_user(0x82102065, &sf->insns[0]); 1180 1181 /* t 0x10 */ 1182 err |= __put_user(0x91d02010, &sf->insns[1]); 1183 if (err) 1184 goto sigsegv; 1185 1186 preempt_disable(); 1187 ptep = pte_offset_map(pmdp, address); 1188 if (pte_present(*ptep)) { 1189 unsigned long page = (unsigned long) 1190 page_address(pte_page(*ptep)); 1191 1192 wmb(); 1193 __asm__ __volatile__("flush %0 + %1" 1194 : /* no outputs */ 1195 : "r" (page), 1196 "r" (address & (PAGE_SIZE - 1)) 1197 : "memory"); 1198 } 1199 pte_unmap(ptep); 1200 preempt_enable(); 1201 } 1202 return; 1203 1204sigill: 1205 do_exit(SIGILL); 1206sigsegv: 1207 force_sigsegv(signr, current); 1208} 1209 1210static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka, 1211 siginfo_t *info, 1212 sigset_t *oldset, struct pt_regs *regs, 1213 int svr4_signal) 1214{ 1215 if (svr4_signal) 1216 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc, 1217 regs, signr, oldset); 1218 else { 1219 if (ka->sa.sa_flags & SA_SIGINFO) 1220 setup_rt_frame32(ka, regs, signr, oldset, info); 1221 else if (test_thread_flag(TIF_NEWSIGNALS)) 1222 new_setup_frame32(ka, regs, signr, oldset); 1223 else 1224 setup_frame32(&ka->sa, regs, signr, oldset, info); 1225 } 1226 spin_lock_irq(¤t->sighand->siglock); 1227 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 1228 if (!(ka->sa.sa_flags & SA_NOMASK)) 1229 sigaddset(¤t->blocked,signr); 1230 recalc_sigpending(); 1231 spin_unlock_irq(¤t->sighand->siglock); 1232} 1233 1234static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs, 1235 struct sigaction *sa) 1236{ 1237 switch (regs->u_regs[UREG_I0]) { 1238 case ERESTART_RESTARTBLOCK: 1239 case ERESTARTNOHAND: 1240 no_system_call_restart: 1241 regs->u_regs[UREG_I0] = EINTR; 1242 regs->tstate |= TSTATE_ICARRY; 1243 break; 1244 case ERESTARTSYS: 1245 if (!(sa->sa_flags & SA_RESTART)) 1246 goto no_system_call_restart; 1247 /* fallthrough */ 1248 case ERESTARTNOINTR: 1249 regs->u_regs[UREG_I0] = orig_i0; 1250 regs->tpc -= 4; 1251 regs->tnpc -= 4; 1252 } 1253} 1254 1255/* Note that 'init' is a special process: it doesn't get signals it doesn't 1256 * want to handle. Thus you cannot kill init even with a SIGKILL even by 1257 * mistake. 1258 */ 1259void do_signal32(sigset_t *oldset, struct pt_regs * regs, 1260 unsigned long orig_i0, int restart_syscall) 1261{ 1262 siginfo_t info; 1263 struct signal_deliver_cookie cookie; 1264 struct k_sigaction ka; 1265 int signr; 1266 int svr4_signal = current->personality == PER_SVR4; 1267 1268 cookie.restart_syscall = restart_syscall; 1269 cookie.orig_i0 = orig_i0; 1270 1271 signr = get_signal_to_deliver(&info, &ka, regs, &cookie); 1272 if (signr > 0) { 1273 if (cookie.restart_syscall) 1274 syscall_restart32(orig_i0, regs, &ka.sa); 1275 handle_signal32(signr, &ka, &info, oldset, 1276 regs, svr4_signal); 1277 1278 /* a signal was successfully delivered; the saved 1279 * sigmask will have been stored in the signal frame, 1280 * and will be restored by sigreturn, so we can simply 1281 * clear the TIF_RESTORE_SIGMASK flag. 1282 */ 1283 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1284 clear_thread_flag(TIF_RESTORE_SIGMASK); 1285 return; 1286 } 1287 if (cookie.restart_syscall && 1288 (regs->u_regs[UREG_I0] == ERESTARTNOHAND || 1289 regs->u_regs[UREG_I0] == ERESTARTSYS || 1290 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) { 1291 /* replay the system call when we are done */ 1292 regs->u_regs[UREG_I0] = cookie.orig_i0; 1293 regs->tpc -= 4; 1294 regs->tnpc -= 4; 1295 } 1296 if (cookie.restart_syscall && 1297 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) { 1298 regs->u_regs[UREG_G1] = __NR_restart_syscall; 1299 regs->tpc -= 4; 1300 regs->tnpc -= 4; 1301 } 1302 1303 /* if there's no signal to deliver, we just put the saved sigmask 1304 * back 1305 */ 1306 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 1307 clear_thread_flag(TIF_RESTORE_SIGMASK); 1308 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 1309 } 1310} 1311 1312struct sigstack32 { 1313 u32 the_stack; 1314 int cur_status; 1315}; 1316 1317asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp) 1318{ 1319 struct sigstack32 __user *ssptr = 1320 (struct sigstack32 __user *)((unsigned long)(u_ssptr)); 1321 struct sigstack32 __user *ossptr = 1322 (struct sigstack32 __user *)((unsigned long)(u_ossptr)); 1323 int ret = -EFAULT; 1324 1325 /* First see if old state is wanted. */ 1326 if (ossptr) { 1327 if (put_user(current->sas_ss_sp + current->sas_ss_size, 1328 &ossptr->the_stack) || 1329 __put_user(on_sig_stack(sp), &ossptr->cur_status)) 1330 goto out; 1331 } 1332 1333 /* Now see if we want to update the new state. */ 1334 if (ssptr) { 1335 u32 ss_sp; 1336 1337 if (get_user(ss_sp, &ssptr->the_stack)) 1338 goto out; 1339 1340 /* If the current stack was set with sigaltstack, don't 1341 * swap stacks while we are on it. 1342 */ 1343 ret = -EPERM; 1344 if (current->sas_ss_sp && on_sig_stack(sp)) 1345 goto out; 1346 1347 /* Since we don't know the extent of the stack, and we don't 1348 * track onstack-ness, but rather calculate it, we must 1349 * presume a size. Ho hum this interface is lossy. 1350 */ 1351 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ; 1352 current->sas_ss_size = SIGSTKSZ; 1353 } 1354 1355 ret = 0; 1356out: 1357 return ret; 1358} 1359 1360asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp) 1361{ 1362 stack_t uss, uoss; 1363 u32 u_ss_sp = 0; 1364 int ret; 1365 mm_segment_t old_fs; 1366 stack_t32 __user *uss32 = compat_ptr(ussa); 1367 stack_t32 __user *uoss32 = compat_ptr(uossa); 1368 1369 if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) || 1370 __get_user(uss.ss_flags, &uss32->ss_flags) || 1371 __get_user(uss.ss_size, &uss32->ss_size))) 1372 return -EFAULT; 1373 uss.ss_sp = compat_ptr(u_ss_sp); 1374 old_fs = get_fs(); 1375 set_fs(KERNEL_DS); 1376 ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL, 1377 uossa ? (stack_t __user *) &uoss : NULL, sp); 1378 set_fs(old_fs); 1379 if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) || 1380 __put_user(uoss.ss_flags, &uoss32->ss_flags) || 1381 __put_user(uoss.ss_size, &uoss32->ss_size))) 1382 return -EFAULT; 1383 return ret; 1384} 1385