1/* $Id: signal.c,v 1.1.1.1 2007/08/03 18:52:18 Exp $ 2 * arch/sparc64/kernel/signal.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#ifdef CONFIG_SPARC32_COMPAT 12#include <linux/compat.h> /* for compat_old_sigset_t */ 13#endif 14#include <linux/sched.h> 15#include <linux/kernel.h> 16#include <linux/signal.h> 17#include <linux/errno.h> 18#include <linux/wait.h> 19#include <linux/ptrace.h> 20#include <linux/unistd.h> 21#include <linux/mm.h> 22#include <linux/tty.h> 23#include <linux/binfmts.h> 24#include <linux/bitops.h> 25 26#include <asm/uaccess.h> 27#include <asm/ptrace.h> 28#include <asm/svr4.h> 29#include <asm/pgtable.h> 30#include <asm/fpumacro.h> 31#include <asm/uctx.h> 32#include <asm/siginfo.h> 33#include <asm/visasm.h> 34 35#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 36 37/* {set, get}context() needed for 64-bit SparcLinux userland. */ 38asmlinkage void sparc64_set_context(struct pt_regs *regs) 39{ 40 struct ucontext __user *ucp = (struct ucontext __user *) 41 regs->u_regs[UREG_I0]; 42 mc_gregset_t __user *grp; 43 unsigned long pc, npc, tstate; 44 unsigned long fp, i7; 45 unsigned char fenab; 46 int err; 47 48 flush_user_windows(); 49 if (get_thread_wsaved() || 50 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) || 51 (!__access_ok(ucp, sizeof(*ucp)))) 52 goto do_sigsegv; 53 grp = &ucp->uc_mcontext.mc_gregs; 54 err = __get_user(pc, &((*grp)[MC_PC])); 55 err |= __get_user(npc, &((*grp)[MC_NPC])); 56 if (err || ((pc | npc) & 3)) 57 goto do_sigsegv; 58 if (regs->u_regs[UREG_I1]) { 59 sigset_t set; 60 61 if (_NSIG_WORDS == 1) { 62 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0])) 63 goto do_sigsegv; 64 } else { 65 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t))) 66 goto do_sigsegv; 67 } 68 sigdelsetmask(&set, ~_BLOCKABLE); 69 spin_lock_irq(¤t->sighand->siglock); 70 current->blocked = set; 71 recalc_sigpending(); 72 spin_unlock_irq(¤t->sighand->siglock); 73 } 74 if (test_thread_flag(TIF_32BIT)) { 75 pc &= 0xffffffff; 76 npc &= 0xffffffff; 77 } 78 regs->tpc = pc; 79 regs->tnpc = npc; 80 err |= __get_user(regs->y, &((*grp)[MC_Y])); 81 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 82 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 83 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 84 err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1])); 85 err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2])); 86 err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3])); 87 err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4])); 88 err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5])); 89 err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6])); 90 err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7])); 91 err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0])); 92 err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1])); 93 err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2])); 94 err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3])); 95 err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4])); 96 err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5])); 97 err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6])); 98 err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7])); 99 100 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 101 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 102 err |= __put_user(fp, 103 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 104 err |= __put_user(i7, 105 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 106 107 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 108 if (fenab) { 109 unsigned long *fpregs = current_thread_info()->fpregs; 110 unsigned long fprs; 111 112 fprs_write(0); 113 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 114 if (fprs & FPRS_DL) 115 err |= copy_from_user(fpregs, 116 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs), 117 (sizeof(unsigned int) * 32)); 118 if (fprs & FPRS_DU) 119 err |= copy_from_user(fpregs+16, 120 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16, 121 (sizeof(unsigned int) * 32)); 122 err |= __get_user(current_thread_info()->xfsr[0], 123 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 124 err |= __get_user(current_thread_info()->gsr[0], 125 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 126 regs->tstate &= ~TSTATE_PEF; 127 } 128 if (err) 129 goto do_sigsegv; 130 131 return; 132do_sigsegv: 133 force_sig(SIGSEGV, current); 134} 135 136asmlinkage void sparc64_get_context(struct pt_regs *regs) 137{ 138 struct ucontext __user *ucp = (struct ucontext __user *) 139 regs->u_regs[UREG_I0]; 140 mc_gregset_t __user *grp; 141 mcontext_t __user *mcp; 142 unsigned long fp, i7; 143 unsigned char fenab; 144 int err; 145 146 synchronize_user_stack(); 147 if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp))) 148 goto do_sigsegv; 149 150 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */ 151 152 mcp = &ucp->uc_mcontext; 153 grp = &mcp->mc_gregs; 154 155 /* Skip over the trap instruction, first. */ 156 if (test_thread_flag(TIF_32BIT)) { 157 regs->tpc = (regs->tnpc & 0xffffffff); 158 regs->tnpc = (regs->tnpc + 4) & 0xffffffff; 159 } else { 160 regs->tpc = regs->tnpc; 161 regs->tnpc += 4; 162 } 163 err = 0; 164 if (_NSIG_WORDS == 1) 165 err |= __put_user(current->blocked.sig[0], 166 (unsigned long __user *)&ucp->uc_sigmask); 167 else 168 err |= __copy_to_user(&ucp->uc_sigmask, ¤t->blocked, 169 sizeof(sigset_t)); 170 171 err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE])); 172 err |= __put_user(regs->tpc, &((*grp)[MC_PC])); 173 err |= __put_user(regs->tnpc, &((*grp)[MC_NPC])); 174 err |= __put_user(regs->y, &((*grp)[MC_Y])); 175 err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1])); 176 err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2])); 177 err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3])); 178 err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4])); 179 err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5])); 180 err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6])); 181 err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7])); 182 err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0])); 183 err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1])); 184 err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2])); 185 err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3])); 186 err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4])); 187 err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5])); 188 err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6])); 189 err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7])); 190 191 err |= __get_user(fp, 192 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 193 err |= __get_user(i7, 194 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 195 err |= __put_user(fp, &(mcp->mc_fp)); 196 err |= __put_user(i7, &(mcp->mc_i7)); 197 198 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab)); 199 if (fenab) { 200 unsigned long *fpregs = current_thread_info()->fpregs; 201 unsigned long fprs; 202 203 fprs = current_thread_info()->fpsaved[0]; 204 if (fprs & FPRS_DL) 205 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs, 206 (sizeof(unsigned int) * 32)); 207 if (fprs & FPRS_DU) 208 err |= copy_to_user( 209 ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16, 210 (sizeof(unsigned int) * 32)); 211 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr)); 212 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr)); 213 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 214 } 215 if (err) 216 goto do_sigsegv; 217 218 return; 219do_sigsegv: 220 force_sig(SIGSEGV, current); 221} 222 223struct rt_signal_frame { 224 struct sparc_stackf ss; 225 siginfo_t info; 226 struct pt_regs regs; 227 __siginfo_fpu_t __user *fpu_save; 228 stack_t stack; 229 sigset_t mask; 230 __siginfo_fpu_t fpu_state; 231}; 232 233/* Align macros */ 234#define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7))) 235 236static long _sigpause_common(old_sigset_t set) 237{ 238 set &= _BLOCKABLE; 239 spin_lock_irq(¤t->sighand->siglock); 240 current->saved_sigmask = current->blocked; 241 siginitset(¤t->blocked, set); 242 recalc_sigpending(); 243 spin_unlock_irq(¤t->sighand->siglock); 244 245 current->state = TASK_INTERRUPTIBLE; 246 schedule(); 247 set_thread_flag(TIF_RESTORE_SIGMASK); 248 return -ERESTARTNOHAND; 249} 250 251asmlinkage long sys_sigpause(unsigned int set) 252{ 253 return _sigpause_common(set); 254} 255 256asmlinkage long sys_sigsuspend(old_sigset_t set) 257{ 258 return _sigpause_common(set); 259} 260 261static inline int 262restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) 263{ 264 unsigned long *fpregs = current_thread_info()->fpregs; 265 unsigned long fprs; 266 int err; 267 268 err = __get_user(fprs, &fpu->si_fprs); 269 fprs_write(0); 270 regs->tstate &= ~TSTATE_PEF; 271 if (fprs & FPRS_DL) 272 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], 273 (sizeof(unsigned int) * 32)); 274 if (fprs & FPRS_DU) 275 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], 276 (sizeof(unsigned int) * 32)); 277 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr); 278 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr); 279 current_thread_info()->fpsaved[0] |= fprs; 280 return err; 281} 282 283void do_rt_sigreturn(struct pt_regs *regs) 284{ 285 struct rt_signal_frame __user *sf; 286 unsigned long tpc, tnpc, tstate; 287 __siginfo_fpu_t __user *fpu_save; 288 mm_segment_t old_fs; 289 sigset_t set; 290 stack_t st; 291 int err; 292 293 /* Always make any pending restarted system calls return -EINTR */ 294 current_thread_info()->restart_block.fn = do_no_restart_syscall; 295 296 synchronize_user_stack (); 297 sf = (struct rt_signal_frame __user *) 298 (regs->u_regs [UREG_FP] + STACK_BIAS); 299 300 /* 1. Make sure we are not getting garbage from the user */ 301 if (((unsigned long) sf) & 3) 302 goto segv; 303 304 err = get_user(tpc, &sf->regs.tpc); 305 err |= __get_user(tnpc, &sf->regs.tnpc); 306 if (test_thread_flag(TIF_32BIT)) { 307 tpc &= 0xffffffff; 308 tnpc &= 0xffffffff; 309 } 310 err |= ((tpc | tnpc) & 3); 311 312 /* 2. Restore the state */ 313 err |= __get_user(regs->y, &sf->regs.y); 314 err |= __get_user(tstate, &sf->regs.tstate); 315 err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs)); 316 317 /* User can only change condition codes and %asi in %tstate. */ 318 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 319 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 320 321 err |= __get_user(fpu_save, &sf->fpu_save); 322 if (fpu_save) 323 err |= restore_fpu_state(regs, &sf->fpu_state); 324 325 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); 326 err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t)); 327 328 if (err) 329 goto segv; 330 331 regs->tpc = tpc; 332 regs->tnpc = tnpc; 333 334 /* It is more difficult to avoid calling this function than to 335 call it and ignore errors. */ 336 old_fs = get_fs(); 337 set_fs(KERNEL_DS); 338 do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf); 339 set_fs(old_fs); 340 341 sigdelsetmask(&set, ~_BLOCKABLE); 342 spin_lock_irq(¤t->sighand->siglock); 343 current->blocked = set; 344 recalc_sigpending(); 345 spin_unlock_irq(¤t->sighand->siglock); 346 return; 347segv: 348 force_sig(SIGSEGV, current); 349} 350 351/* Checks if the fp is valid */ 352static int invalid_frame_pointer(void __user *fp, int fplen) 353{ 354 if (((unsigned long) fp) & 7) 355 return 1; 356 return 0; 357} 358 359static inline int 360save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu) 361{ 362 unsigned long *fpregs = (unsigned long *)(regs+1); 363 unsigned long fprs; 364 int err = 0; 365 366 fprs = current_thread_info()->fpsaved[0]; 367 if (fprs & FPRS_DL) 368 err |= copy_to_user(&fpu->si_float_regs[0], fpregs, 369 (sizeof(unsigned int) * 32)); 370 if (fprs & FPRS_DU) 371 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16, 372 (sizeof(unsigned int) * 32)); 373 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr); 374 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr); 375 err |= __put_user(fprs, &fpu->si_fprs); 376 377 return err; 378} 379 380static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize) 381{ 382 unsigned long sp; 383 384 sp = regs->u_regs[UREG_FP] + STACK_BIAS; 385 386 /* This is the X/Open sanctioned signal stack switching. */ 387 if (ka->sa.sa_flags & SA_ONSTACK) { 388 if (!on_sig_stack(sp) && 389 !((current->sas_ss_sp + current->sas_ss_size) & 7)) 390 sp = current->sas_ss_sp + current->sas_ss_size; 391 } 392 return (void __user *)(sp - framesize); 393} 394 395static inline void 396setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs, 397 int signo, sigset_t *oldset, siginfo_t *info) 398{ 399 struct rt_signal_frame __user *sf; 400 int sigframe_size, err; 401 402 /* 1. Make sure everything is clean */ 403 synchronize_user_stack(); 404 save_and_clear_fpu(); 405 406 sigframe_size = RT_ALIGNEDSZ; 407 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF)) 408 sigframe_size -= sizeof(__siginfo_fpu_t); 409 410 sf = (struct rt_signal_frame __user *) 411 get_sigframe(ka, regs, sigframe_size); 412 413 if (invalid_frame_pointer (sf, sigframe_size)) 414 goto sigill; 415 416 if (get_thread_wsaved() != 0) 417 goto sigill; 418 419 /* 2. Save the current process state */ 420 err = copy_to_user(&sf->regs, regs, sizeof (*regs)); 421 422 if (current_thread_info()->fpsaved[0] & FPRS_FEF) { 423 err |= save_fpu_state(regs, &sf->fpu_state); 424 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save); 425 } else { 426 err |= __put_user(0, &sf->fpu_save); 427 } 428 429 /* Setup sigaltstack */ 430 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp); 431 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags); 432 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size); 433 434 err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t)); 435 436 err |= copy_in_user((u64 __user *)sf, 437 (u64 __user *)(regs->u_regs[UREG_FP]+STACK_BIAS), 438 sizeof(struct reg_window)); 439 440 if (info) 441 err |= copy_siginfo_to_user(&sf->info, info); 442 else { 443 err |= __put_user(signo, &sf->info.si_signo); 444 err |= __put_user(SI_NOINFO, &sf->info.si_code); 445 } 446 if (err) 447 goto sigsegv; 448 449 /* 3. signal handler back-trampoline and parameters */ 450 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS; 451 regs->u_regs[UREG_I0] = signo; 452 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 453 454 /* The sigcontext is passed in this way because of how it 455 * is defined in GLIBC's /usr/include/bits/sigcontext.h 456 * for sparc64. It includes the 128 bytes of siginfo_t. 457 */ 458 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 459 460 /* 5. signal handler */ 461 regs->tpc = (unsigned long) ka->sa.sa_handler; 462 regs->tnpc = (regs->tpc + 4); 463 if (test_thread_flag(TIF_32BIT)) { 464 regs->tpc &= 0xffffffff; 465 regs->tnpc &= 0xffffffff; 466 } 467 /* 4. return to kernel instructions */ 468 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer; 469 return; 470 471sigill: 472 do_exit(SIGILL); 473sigsegv: 474 force_sigsegv(signo, current); 475} 476 477static inline void handle_signal(unsigned long signr, struct k_sigaction *ka, 478 siginfo_t *info, 479 sigset_t *oldset, struct pt_regs *regs) 480{ 481 setup_rt_frame(ka, regs, signr, oldset, 482 (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL); 483 spin_lock_irq(¤t->sighand->siglock); 484 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 485 if (!(ka->sa.sa_flags & SA_NOMASK)) 486 sigaddset(¤t->blocked,signr); 487 recalc_sigpending(); 488 spin_unlock_irq(¤t->sighand->siglock); 489} 490 491static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, 492 struct sigaction *sa) 493{ 494 switch (regs->u_regs[UREG_I0]) { 495 case ERESTART_RESTARTBLOCK: 496 case ERESTARTNOHAND: 497 no_system_call_restart: 498 regs->u_regs[UREG_I0] = EINTR; 499 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY); 500 break; 501 case ERESTARTSYS: 502 if (!(sa->sa_flags & SA_RESTART)) 503 goto no_system_call_restart; 504 /* fallthrough */ 505 case ERESTARTNOINTR: 506 regs->u_regs[UREG_I0] = orig_i0; 507 regs->tpc -= 4; 508 regs->tnpc -= 4; 509 } 510} 511 512/* Note that 'init' is a special process: it doesn't get signals it doesn't 513 * want to handle. Thus you cannot kill init even with a SIGKILL even by 514 * mistake. 515 */ 516static void do_signal(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall) 517{ 518 siginfo_t info; 519 struct signal_deliver_cookie cookie; 520 struct k_sigaction ka; 521 int signr; 522 sigset_t *oldset; 523 524 cookie.restart_syscall = restart_syscall; 525 cookie.orig_i0 = orig_i0; 526 527 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 528 oldset = ¤t->saved_sigmask; 529 else 530 oldset = ¤t->blocked; 531 532#ifdef CONFIG_SPARC32_COMPAT 533 if (test_thread_flag(TIF_32BIT)) { 534 extern void do_signal32(sigset_t *, struct pt_regs *, 535 unsigned long, int); 536 do_signal32(oldset, regs, orig_i0, 537 cookie.restart_syscall); 538 return; 539 } 540#endif 541 542 signr = get_signal_to_deliver(&info, &ka, regs, &cookie); 543 if (signr > 0) { 544 if (cookie.restart_syscall) 545 syscall_restart(orig_i0, regs, &ka.sa); 546 handle_signal(signr, &ka, &info, oldset, regs); 547 548 /* a signal was successfully delivered; the saved 549 * sigmask will have been stored in the signal frame, 550 * and will be restored by sigreturn, so we can simply 551 * clear the TIF_RESTORE_SIGMASK flag. 552 */ 553 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 554 clear_thread_flag(TIF_RESTORE_SIGMASK); 555 return; 556 } 557 if (cookie.restart_syscall && 558 (regs->u_regs[UREG_I0] == ERESTARTNOHAND || 559 regs->u_regs[UREG_I0] == ERESTARTSYS || 560 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) { 561 /* replay the system call when we are done */ 562 regs->u_regs[UREG_I0] = cookie.orig_i0; 563 regs->tpc -= 4; 564 regs->tnpc -= 4; 565 } 566 if (cookie.restart_syscall && 567 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) { 568 regs->u_regs[UREG_G1] = __NR_restart_syscall; 569 regs->tpc -= 4; 570 regs->tnpc -= 4; 571 } 572 573 /* if there's no signal to deliver, we just put the saved sigmask 574 * back 575 */ 576 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 577 clear_thread_flag(TIF_RESTORE_SIGMASK); 578 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 579 } 580} 581 582void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall, 583 unsigned long thread_info_flags) 584{ 585 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)) 586 do_signal(regs, orig_i0, restart_syscall); 587} 588 589void ptrace_signal_deliver(struct pt_regs *regs, void *cookie) 590{ 591 struct signal_deliver_cookie *cp = cookie; 592 593 if (cp->restart_syscall && 594 (regs->u_regs[UREG_I0] == ERESTARTNOHAND || 595 regs->u_regs[UREG_I0] == ERESTARTSYS || 596 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) { 597 /* replay the system call when we are done */ 598 regs->u_regs[UREG_I0] = cp->orig_i0; 599 regs->tpc -= 4; 600 regs->tnpc -= 4; 601 cp->restart_syscall = 0; 602 } 603 if (cp->restart_syscall && 604 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) { 605 regs->u_regs[UREG_G1] = __NR_restart_syscall; 606 regs->tpc -= 4; 607 regs->tnpc -= 4; 608 cp->restart_syscall = 0; 609 } 610} 611