1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * arch/sh64/kernel/signal.c 7 * 8 * Copyright (C) 2000, 2001 Paolo Alberelli 9 * Copyright (C) 2003 Paul Mundt 10 * Copyright (C) 2004 Richard Curnow 11 * 12 * Started from sh version. 13 * 14 */ 15#include <linux/rwsem.h> 16#include <linux/sched.h> 17#include <linux/mm.h> 18#include <linux/smp.h> 19#include <linux/kernel.h> 20#include <linux/signal.h> 21#include <linux/errno.h> 22#include <linux/wait.h> 23#include <linux/personality.h> 24#include <linux/freezer.h> 25#include <linux/ptrace.h> 26#include <linux/unistd.h> 27#include <linux/stddef.h> 28#include <linux/personality.h> 29#include <asm/ucontext.h> 30#include <asm/uaccess.h> 31#include <asm/pgtable.h> 32 33 34#define REG_RET 9 35#define REG_ARG1 2 36#define REG_ARG2 3 37#define REG_ARG3 4 38#define REG_SP 15 39#define REG_PR 18 40#define REF_REG_RET regs->regs[REG_RET] 41#define REF_REG_SP regs->regs[REG_SP] 42#define DEREF_REG_PR regs->regs[REG_PR] 43 44#define DEBUG_SIG 0 45 46#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 47 48asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset); 49 50/* 51 * Atomically swap in the new signal mask, and wait for a signal. 52 */ 53 54asmlinkage int 55sys_sigsuspend(old_sigset_t mask, 56 unsigned long r3, unsigned long r4, unsigned long r5, 57 unsigned long r6, unsigned long r7, 58 struct pt_regs * regs) 59{ 60 sigset_t saveset; 61 62 mask &= _BLOCKABLE; 63 spin_lock_irq(¤t->sighand->siglock); 64 saveset = current->blocked; 65 siginitset(¤t->blocked, mask); 66 recalc_sigpending(); 67 spin_unlock_irq(¤t->sighand->siglock); 68 69 REF_REG_RET = -EINTR; 70 while (1) { 71 current->state = TASK_INTERRUPTIBLE; 72 schedule(); 73 regs->pc += 4; /* because sys_sigreturn decrements the pc */ 74 if (do_signal(regs, &saveset)) { 75 /* pc now points at signal handler. Need to decrement 76 it because entry.S will increment it. */ 77 regs->pc -= 4; 78 return -EINTR; 79 } 80 } 81} 82 83asmlinkage int 84sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, 85 unsigned long r4, unsigned long r5, unsigned long r6, 86 unsigned long r7, 87 struct pt_regs * regs) 88{ 89 sigset_t saveset, newset; 90 91 if (sigsetsize != sizeof(sigset_t)) 92 return -EINVAL; 93 94 if (copy_from_user(&newset, unewset, sizeof(newset))) 95 return -EFAULT; 96 sigdelsetmask(&newset, ~_BLOCKABLE); 97 spin_lock_irq(¤t->sighand->siglock); 98 saveset = current->blocked; 99 current->blocked = newset; 100 recalc_sigpending(); 101 spin_unlock_irq(¤t->sighand->siglock); 102 103 REF_REG_RET = -EINTR; 104 while (1) { 105 current->state = TASK_INTERRUPTIBLE; 106 schedule(); 107 regs->pc += 4; /* because sys_sigreturn decrements the pc */ 108 if (do_signal(regs, &saveset)) { 109 /* pc now points at signal handler. Need to decrement 110 it because entry.S will increment it. */ 111 regs->pc -= 4; 112 return -EINTR; 113 } 114 } 115} 116 117asmlinkage int 118sys_sigaction(int sig, const struct old_sigaction __user *act, 119 struct old_sigaction __user *oact) 120{ 121 struct k_sigaction new_ka, old_ka; 122 int ret; 123 124 if (act) { 125 old_sigset_t mask; 126 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 127 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 128 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) 129 return -EFAULT; 130 __get_user(new_ka.sa.sa_flags, &act->sa_flags); 131 __get_user(mask, &act->sa_mask); 132 siginitset(&new_ka.sa.sa_mask, mask); 133 } 134 135 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 136 137 if (!ret && oact) { 138 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 139 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 140 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) 141 return -EFAULT; 142 __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 143 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); 144 } 145 146 return ret; 147} 148 149asmlinkage int 150sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, 151 unsigned long r4, unsigned long r5, unsigned long r6, 152 unsigned long r7, 153 struct pt_regs * regs) 154{ 155 return do_sigaltstack(uss, uoss, REF_REG_SP); 156} 157 158 159/* 160 * Do a signal return; undo the signal stack. 161 */ 162 163struct sigframe 164{ 165 struct sigcontext sc; 166 unsigned long extramask[_NSIG_WORDS-1]; 167 long long retcode[2]; 168}; 169 170struct rt_sigframe 171{ 172 struct siginfo __user *pinfo; 173 void *puc; 174 struct siginfo info; 175 struct ucontext uc; 176 long long retcode[2]; 177}; 178 179#ifdef CONFIG_SH_FPU 180static inline int 181restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc) 182{ 183 int err = 0; 184 int fpvalid; 185 186 err |= __get_user (fpvalid, &sc->sc_fpvalid); 187 conditional_used_math(fpvalid); 188 if (! fpvalid) 189 return err; 190 191 if (current == last_task_used_math) { 192 last_task_used_math = NULL; 193 regs->sr |= SR_FD; 194 } 195 196 err |= __copy_from_user(¤t->thread.fpu.hard, &sc->sc_fpregs[0], 197 (sizeof(long long) * 32) + (sizeof(int) * 1)); 198 199 return err; 200} 201 202static inline int 203setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc) 204{ 205 int err = 0; 206 int fpvalid; 207 208 fpvalid = !!used_math(); 209 err |= __put_user(fpvalid, &sc->sc_fpvalid); 210 if (! fpvalid) 211 return err; 212 213 if (current == last_task_used_math) { 214 grab_fpu(); 215 fpsave(¤t->thread.fpu.hard); 216 release_fpu(); 217 last_task_used_math = NULL; 218 regs->sr |= SR_FD; 219 } 220 221 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.fpu.hard, 222 (sizeof(long long) * 32) + (sizeof(int) * 1)); 223 clear_used_math(); 224 225 return err; 226} 227#else 228static inline int 229restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc) 230{} 231static inline int 232setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc) 233{} 234#endif 235 236static int 237restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p) 238{ 239 unsigned int err = 0; 240 unsigned long long current_sr, new_sr; 241#define SR_MASK 0xffff8cfd 242 243#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 244 245 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); 246 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); 247 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); 248 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); 249 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]); 250 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]); 251 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]); 252 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]); 253 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]); 254 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]); 255 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]); 256 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]); 257 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]); 258 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]); 259 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]); 260 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]); 261 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]); 262 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]); 263 264 /* Prevent the signal handler manipulating SR in a way that can 265 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be 266 modified */ 267 current_sr = regs->sr; 268 err |= __get_user(new_sr, &sc->sc_sr); 269 regs->sr &= SR_MASK; 270 regs->sr |= (new_sr & ~SR_MASK); 271 272 COPY(pc); 273 274#undef COPY 275 276 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr 277 * has been restored above.) */ 278 err |= restore_sigcontext_fpu(regs, sc); 279 280 regs->syscall_nr = -1; /* disable syscall checks */ 281 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]); 282 return err; 283} 284 285asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3, 286 unsigned long r4, unsigned long r5, 287 unsigned long r6, unsigned long r7, 288 struct pt_regs * regs) 289{ 290 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP; 291 sigset_t set; 292 long long ret; 293 294 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 295 goto badframe; 296 297 if (__get_user(set.sig[0], &frame->sc.oldmask) 298 || (_NSIG_WORDS > 1 299 && __copy_from_user(&set.sig[1], &frame->extramask, 300 sizeof(frame->extramask)))) 301 goto badframe; 302 303 sigdelsetmask(&set, ~_BLOCKABLE); 304 305 spin_lock_irq(¤t->sighand->siglock); 306 current->blocked = set; 307 recalc_sigpending(); 308 spin_unlock_irq(¤t->sighand->siglock); 309 310 if (restore_sigcontext(regs, &frame->sc, &ret)) 311 goto badframe; 312 regs->pc -= 4; 313 314 return (int) ret; 315 316badframe: 317 force_sig(SIGSEGV, current); 318 return 0; 319} 320 321asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3, 322 unsigned long r4, unsigned long r5, 323 unsigned long r6, unsigned long r7, 324 struct pt_regs * regs) 325{ 326 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP; 327 sigset_t set; 328 stack_t __user st; 329 long long ret; 330 331 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 332 goto badframe; 333 334 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 335 goto badframe; 336 337 sigdelsetmask(&set, ~_BLOCKABLE); 338 spin_lock_irq(¤t->sighand->siglock); 339 current->blocked = set; 340 recalc_sigpending(); 341 spin_unlock_irq(¤t->sighand->siglock); 342 343 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret)) 344 goto badframe; 345 regs->pc -= 4; 346 347 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st))) 348 goto badframe; 349 /* It is more difficult to avoid calling this function than to 350 call it and ignore errors. */ 351 do_sigaltstack(&st, NULL, REF_REG_SP); 352 353 return (int) ret; 354 355badframe: 356 force_sig(SIGSEGV, current); 357 return 0; 358} 359 360/* 361 * Set up a signal frame. 362 */ 363 364static int 365setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 366 unsigned long mask) 367{ 368 int err = 0; 369 370 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */ 371 err |= setup_sigcontext_fpu(regs, sc); 372 373#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 374 375 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]); 376 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]); 377 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]); 378 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]); 379 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]); 380 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]); 381 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]); 382 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]); 383 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]); 384 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]); 385 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]); 386 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]); 387 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]); 388 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]); 389 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]); 390 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]); 391 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]); 392 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]); 393 COPY(sr); COPY(pc); 394 395#undef COPY 396 397 err |= __put_user(mask, &sc->oldmask); 398 399 return err; 400} 401 402/* 403 * Determine which stack to use.. 404 */ 405static inline void __user * 406get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 407{ 408 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp)) 409 sp = current->sas_ss_sp + current->sas_ss_size; 410 411 return (void __user *)((sp - frame_size) & -8ul); 412} 413 414void sa_default_restorer(void); /* See comments below */ 415void sa_default_rt_restorer(void); /* See comments below */ 416 417static void setup_frame(int sig, struct k_sigaction *ka, 418 sigset_t *set, struct pt_regs *regs) 419{ 420 struct sigframe __user *frame; 421 int err = 0; 422 int signal; 423 424 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame)); 425 426 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 427 goto give_sigsegv; 428 429 signal = current_thread_info()->exec_domain 430 && current_thread_info()->exec_domain->signal_invmap 431 && sig < 32 432 ? current_thread_info()->exec_domain->signal_invmap[sig] 433 : sig; 434 435 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 436 437 /* Give up earlier as i386, in case */ 438 if (err) 439 goto give_sigsegv; 440 441 if (_NSIG_WORDS > 1) { 442 err |= __copy_to_user(frame->extramask, &set->sig[1], 443 sizeof(frame->extramask)); } 444 445 /* Give up earlier as i386, in case */ 446 if (err) 447 goto give_sigsegv; 448 449 /* Set up to return from userspace. If provided, use a stub 450 already in userspace. */ 451 if (ka->sa.sa_flags & SA_RESTORER) { 452 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1; 453 454 /* 455 * On SH5 all edited pointers are subject to NEFF 456 */ 457 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ? 458 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR; 459 } else { 460 /* 461 * Different approach on SH5. 462 * . Endianness independent asm code gets placed in entry.S . 463 * This is limited to four ASM instructions corresponding 464 * to two long longs in size. 465 * . err checking is done on the else branch only 466 * . flush_icache_range() is called upon __put_user() only 467 * . all edited pointers are subject to NEFF 468 * . being code, linker turns ShMedia bit on, always 469 * dereference index -1. 470 */ 471 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01; 472 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ? 473 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR; 474 475 if (__copy_to_user(frame->retcode, 476 (unsigned long long)sa_default_restorer & (~1), 16) != 0) 477 goto give_sigsegv; 478 479 /* Cohere the trampoline with the I-cache. */ 480 flush_cache_sigtramp(DEREF_REG_PR-1, DEREF_REG_PR-1+16); 481 } 482 483 /* 484 * Set up registers for signal handler. 485 * All edited pointers are subject to NEFF. 486 */ 487 regs->regs[REG_SP] = (unsigned long) frame; 488 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ? 489 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP]; 490 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */ 491 492 493 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc; 494 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc; 495 496 regs->pc = (unsigned long) ka->sa.sa_handler; 497 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc; 498 499 set_fs(USER_DS); 500 501#if DEBUG_SIG 502 /* Broken %016Lx */ 503 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n", 504 signal, 505 current->comm, current->pid, frame, 506 regs->pc >> 32, regs->pc & 0xffffffff, 507 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff); 508#endif 509 510 return; 511 512give_sigsegv: 513 force_sigsegv(sig, current); 514} 515 516static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 517 sigset_t *set, struct pt_regs *regs) 518{ 519 struct rt_sigframe __user *frame; 520 int err = 0; 521 int signal; 522 523 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame)); 524 525 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 526 goto give_sigsegv; 527 528 signal = current_thread_info()->exec_domain 529 && current_thread_info()->exec_domain->signal_invmap 530 && sig < 32 531 ? current_thread_info()->exec_domain->signal_invmap[sig] 532 : sig; 533 534 err |= __put_user(&frame->info, &frame->pinfo); 535 err |= __put_user(&frame->uc, &frame->puc); 536 err |= copy_siginfo_to_user(&frame->info, info); 537 538 /* Give up earlier as i386, in case */ 539 if (err) 540 goto give_sigsegv; 541 542 /* Create the ucontext. */ 543 err |= __put_user(0, &frame->uc.uc_flags); 544 err |= __put_user(0, &frame->uc.uc_link); 545 err |= __put_user((void *)current->sas_ss_sp, 546 &frame->uc.uc_stack.ss_sp); 547 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]), 548 &frame->uc.uc_stack.ss_flags); 549 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 550 err |= setup_sigcontext(&frame->uc.uc_mcontext, 551 regs, set->sig[0]); 552 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 553 554 /* Give up earlier as i386, in case */ 555 if (err) 556 goto give_sigsegv; 557 558 /* Set up to return from userspace. If provided, use a stub 559 already in userspace. */ 560 if (ka->sa.sa_flags & SA_RESTORER) { 561 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1; 562 563 /* 564 * On SH5 all edited pointers are subject to NEFF 565 */ 566 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ? 567 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR; 568 } else { 569 /* 570 * Different approach on SH5. 571 * . Endianness independent asm code gets placed in entry.S . 572 * This is limited to four ASM instructions corresponding 573 * to two long longs in size. 574 * . err checking is done on the else branch only 575 * . flush_icache_range() is called upon __put_user() only 576 * . all edited pointers are subject to NEFF 577 * . being code, linker turns ShMedia bit on, always 578 * dereference index -1. 579 */ 580 581 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01; 582 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ? 583 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR; 584 585 if (__copy_to_user(frame->retcode, 586 (unsigned long long)sa_default_rt_restorer & (~1), 16) != 0) 587 goto give_sigsegv; 588 589 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15); 590 } 591 592 /* 593 * Set up registers for signal handler. 594 * All edited pointers are subject to NEFF. 595 */ 596 regs->regs[REG_SP] = (unsigned long) frame; 597 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ? 598 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP]; 599 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */ 600 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info; 601 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext; 602 regs->pc = (unsigned long) ka->sa.sa_handler; 603 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc; 604 605 set_fs(USER_DS); 606 607#if DEBUG_SIG 608 /* Broken %016Lx */ 609 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n", 610 signal, 611 current->comm, current->pid, frame, 612 regs->pc >> 32, regs->pc & 0xffffffff, 613 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff); 614#endif 615 616 return; 617 618give_sigsegv: 619 force_sigsegv(sig, current); 620} 621 622/* 623 * OK, we're invoking a handler 624 */ 625 626static void 627handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 628 sigset_t *oldset, struct pt_regs * regs) 629{ 630 /* Are we from a system call? */ 631 if (regs->syscall_nr >= 0) { 632 /* If so, check system call restarting.. */ 633 switch (regs->regs[REG_RET]) { 634 case -ERESTART_RESTARTBLOCK: 635 case -ERESTARTNOHAND: 636 regs->regs[REG_RET] = -EINTR; 637 break; 638 639 case -ERESTARTSYS: 640 if (!(ka->sa.sa_flags & SA_RESTART)) { 641 regs->regs[REG_RET] = -EINTR; 642 break; 643 } 644 /* fallthrough */ 645 case -ERESTARTNOINTR: 646 /* Decode syscall # */ 647 regs->regs[REG_RET] = regs->syscall_nr; 648 regs->pc -= 4; 649 } 650 } 651 652 /* Set up the stack frame */ 653 if (ka->sa.sa_flags & SA_SIGINFO) 654 setup_rt_frame(sig, ka, info, oldset, regs); 655 else 656 setup_frame(sig, ka, oldset, regs); 657 658 spin_lock_irq(¤t->sighand->siglock); 659 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 660 if (!(ka->sa.sa_flags & SA_NODEFER)) 661 sigaddset(¤t->blocked,sig); 662 recalc_sigpending(); 663 spin_unlock_irq(¤t->sighand->siglock); 664} 665 666/* 667 * Note that 'init' is a special process: it doesn't get signals it doesn't 668 * want to handle. Thus you cannot kill init even with a SIGKILL even by 669 * mistake. 670 * 671 * Note that we go through the signals twice: once to check the signals that 672 * the kernel can handle, and then we build all the user-level signal handling 673 * stack-frames in one go after that. 674 */ 675int do_signal(struct pt_regs *regs, sigset_t *oldset) 676{ 677 siginfo_t info; 678 int signr; 679 struct k_sigaction ka; 680 681 /* 682 * We want the common case to go fast, which 683 * is why we may in certain cases get here from 684 * kernel mode. Just return without doing anything 685 * if so. 686 */ 687 if (!user_mode(regs)) 688 return 1; 689 690 if (try_to_freeze()) 691 goto no_signal; 692 693 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 694 oldset = ¤t->saved_sigmask; 695 else if (!oldset) 696 oldset = ¤t->blocked; 697 698 signr = get_signal_to_deliver(&info, &ka, regs, 0); 699 700 if (signr > 0) { 701 /* Whee! Actually deliver the signal. */ 702 handle_signal(signr, &info, &ka, oldset, regs); 703 704 /* 705 * If a signal was successfully delivered, the saved sigmask 706 * is in its frame, and we can clear the TIF_RESTORE_SIGMASK 707 * flag. 708 */ 709 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 710 clear_thread_flag(TIF_RESTORE_SIGMASK); 711 712 return 1; 713 } 714 715no_signal: 716 /* Did we come from a system call? */ 717 if (regs->syscall_nr >= 0) { 718 /* Restart the system call - no handlers present */ 719 switch (regs->regs[REG_RET]) { 720 case -ERESTARTNOHAND: 721 case -ERESTARTSYS: 722 case -ERESTARTNOINTR: 723 /* Decode Syscall # */ 724 regs->regs[REG_RET] = regs->syscall_nr; 725 regs->pc -= 4; 726 break; 727 728 case -ERESTART_RESTARTBLOCK: 729 regs->regs[REG_RET] = __NR_restart_syscall; 730 regs->pc -= 4; 731 break; 732 } 733 } 734 735 /* No signal to deliver -- put the saved sigmask back */ 736 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 737 clear_thread_flag(TIF_RESTORE_SIGMASK); 738 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 739 } 740 741 return 0; 742} 743