1 /* 2 * linux/arch/parisc/kernel/signal.c: Architecture-specific signal 3 * handling support. 4 * 5 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org> 6 * Copyright (C) 2000 Linuxcare, Inc. 7 * 8 * Based on the ia64, i386, and alpha versions. 9 * 10 * Like the IA-64, we are a recent enough port (we are *starting* 11 * with glibc2.2) that we do not need to support the old non-realtime 12 * Linux signals. Therefore we don't. HP/UX signals will go in 13 * arch/parisc/hpux/signal.c when we figure out how to do them. 14 */ 15 16 #include <linux/sched.h> 17 #include <linux/mm.h> 18 #include <linux/smp.h> 19 #include <linux/smp_lock.h> 20 #include <linux/kernel.h> 21 #include <linux/signal.h> 22 #include <linux/errno.h> 23 #include <linux/wait.h> 24 #include <linux/ptrace.h> 25 #include <linux/unistd.h> 26 #include <linux/stddef.h> 27 #include <linux/compat.h> 28 #include <linux/elf.h> 29 #include <linux/personality.h> 30 #include <asm/ucontext.h> 31 #include <asm/rt_sigframe.h> 32 #include <asm/uaccess.h> 33 #include <asm/pgalloc.h> 34 #include <asm/cacheflush.h> 35 #include <asm/offsets.h> 36 37 #ifdef CONFIG_COMPAT 38 #include <linux/compat.h> 39 #include "signal32.h" 40 #endif 41 42 #define DEBUG_SIG 0 43 #define DEBUG_SIG_LEVEL 2 44 45 #if DEBUG_SIG 46 #define DBG(LEVEL, ...) \ 47 ((DEBUG_SIG_LEVEL >= LEVEL) \ 48 ? printk(__VA_ARGS__) : (void) 0) 49 #else 50 #define DBG(LEVEL, ...) 51 #endif 52 53 54 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 55 56 /* gcc will complain if a pointer is cast to an integer of different 57 * size. If you really need to do this (and we do for an ELF32 user 58 * application in an ELF64 kernel) then you have to do a cast to an 59 * integer of the same size first. The A() macro accomplishes 60 * this. */ 61 #define A(__x) ((unsigned long)(__x)) 62 63 int do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall); 64 65 /* 66 * Atomically swap in the new signal mask, and wait for a signal. 67 */ 68 #ifdef __LP64__ 69 #include "sys32.h" 70 #endif 71 72 asmlinkage int 73 sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, struct pt_regs *regs) 74 { 75 sigset_t saveset, newset; 76 #ifdef __LP64__ 77 compat_sigset_t newset32; 78 79 if(personality(current->personality) == PER_LINUX32){ 80 /* XXX: Don't preclude handling different sized sigset_t's. */ 81 if (sigsetsize != sizeof(compat_sigset_t)) 82 return -EINVAL; 83 if (copy_from_user(&newset32, (compat_sigset_t __user *)unewset, sizeof(newset32))) 84 return -EFAULT; 85 sigset_32to64(&newset,&newset32); 86 87 } else 88 #endif 89 { 90 /* XXX: Don't preclude handling different sized sigset_t's. */ 91 if (sigsetsize != sizeof(sigset_t)) 92 return -EINVAL; 93 94 if (copy_from_user(&newset, unewset, sizeof(newset))) 95 return -EFAULT; 96 } 97 98 sigdelsetmask(&newset, ~_BLOCKABLE); 99 100 spin_lock_irq(¤t->sighand->siglock); 101 saveset = current->blocked; 102 current->blocked = newset; 103 recalc_sigpending(); 104 spin_unlock_irq(¤t->sighand->siglock); 105 106 regs->gr[28] = -EINTR; 107 while (1) { 108 current->state = TASK_INTERRUPTIBLE; 109 schedule(); 110 if (do_signal(&saveset, regs, 1)) 111 return -EINTR; 112 } 113 } 114 115 /* 116 * Do a signal return - restore sigcontext. 117 */ 118 119 /* Trampoline for calling rt_sigreturn() */ 120 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */ 121 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */ 122 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */ 123 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */ 124 #define INSN_NOP 0x08000240 /* nop */ 125 /* For debugging */ 126 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */ 127 128 static long 129 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs) 130 { 131 long err = 0; 132 133 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr)); 134 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr)); 135 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq)); 136 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq)); 137 err |= __get_user(regs->sar, &sc->sc_sar); 138 DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n", 139 regs->iaoq[0],regs->iaoq[1]); 140 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]); 141 return err; 142 } 143 144 void 145 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall) 146 { 147 struct rt_sigframe __user *frame; 148 struct siginfo si; 149 sigset_t set; 150 unsigned long usp = (regs->gr[30] & ~(0x01UL)); 151 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE; 152 #ifdef __LP64__ 153 compat_sigset_t compat_set; 154 struct compat_rt_sigframe __user * compat_frame; 155 156 if(personality(current->personality) == PER_LINUX32) 157 sigframe_size = PARISC_RT_SIGFRAME_SIZE32; 158 #endif 159 160 161 /* Unwind the user stack to get the rt_sigframe structure. */ 162 frame = (struct rt_sigframe __user *) 163 (usp - sigframe_size); 164 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame); 165 166 #ifdef __LP64__ 167 compat_frame = (struct compat_rt_sigframe __user *)frame; 168 169 if(personality(current->personality) == PER_LINUX32){ 170 DBG(2,"sys_rt_sigreturn: ELF32 process.\n"); 171 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set))) 172 goto give_sigsegv; 173 sigset_32to64(&set,&compat_set); 174 } else 175 #endif 176 { 177 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 178 goto give_sigsegv; 179 } 180 181 sigdelsetmask(&set, ~_BLOCKABLE); 182 spin_lock_irq(¤t->sighand->siglock); 183 current->blocked = set; 184 recalc_sigpending(); 185 spin_unlock_irq(¤t->sighand->siglock); 186 187 /* Good thing we saved the old gr[30], eh? */ 188 #ifdef __LP64__ 189 if(personality(current->personality) == PER_LINUX32){ 190 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n", 191 &compat_frame->uc.uc_mcontext); 192 // FIXME: Load upper half from register file 193 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 194 &compat_frame->regs, regs)) 195 goto give_sigsegv; 196 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 197 usp, &compat_frame->uc.uc_stack); 198 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT) 199 goto give_sigsegv; 200 } else 201 #endif 202 { 203 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n", 204 &frame->uc.uc_mcontext); 205 if (restore_sigcontext(&frame->uc.uc_mcontext, regs)) 206 goto give_sigsegv; 207 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 208 usp, &frame->uc.uc_stack); 209 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT) 210 goto give_sigsegv; 211 } 212 213 214 215 /* If we are on the syscall path IAOQ will not be restored, and 216 * if we are on the interrupt path we must not corrupt gr31. 217 */ 218 if (in_syscall) 219 regs->gr[31] = regs->iaoq[0]; 220 #if DEBUG_SIG 221 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]); 222 show_regs(regs); 223 #endif 224 return; 225 226 give_sigsegv: 227 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n"); 228 si.si_signo = SIGSEGV; 229 si.si_errno = 0; 230 si.si_code = SI_KERNEL; 231 si.si_pid = current->pid; 232 si.si_uid = current->uid; 233 si.si_addr = &frame->uc; 234 force_sig_info(SIGSEGV, &si, current); 235 return; 236 } 237 238 /* 239 * Set up a signal frame. 240 */ 241 242 static inline void __user * 243 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 244 { 245 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we 246 don't use the parameter it doesn't matter */ 247 248 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n", 249 (unsigned long)ka, sp, frame_size); 250 251 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp)) 252 sp = current->sas_ss_sp; /* Stacks grow up! */ 253 254 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp); 255 return (void __user *) sp; /* Stacks grow up. Fun. */ 256 } 257 258 static long 259 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall) 260 261 { 262 unsigned long flags = 0; 263 long err = 0; 264 265 if (on_sig_stack((unsigned long) sc)) 266 flags |= PARISC_SC_FLAG_ONSTACK; 267 if (in_syscall) { 268 flags |= PARISC_SC_FLAG_IN_SYSCALL; 269 /* regs->iaoq is undefined in the syscall return path */ 270 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]); 271 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]); 272 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]); 273 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]); 274 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n", 275 regs->gr[31], regs->gr[31]+4); 276 } else { 277 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq)); 278 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq)); 279 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 280 regs->iaoq[0], regs->iaoq[1]); 281 } 282 283 err |= __put_user(flags, &sc->sc_flags); 284 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr)); 285 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); 286 err |= __put_user(regs->sar, &sc->sc_sar); 287 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]); 288 289 return err; 290 } 291 292 static long 293 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 294 sigset_t *set, struct pt_regs *regs, int in_syscall) 295 { 296 struct rt_sigframe __user *frame; 297 unsigned long rp, usp; 298 unsigned long haddr, sigframe_size; 299 struct siginfo si; 300 int err = 0; 301 #ifdef __LP64__ 302 compat_int_t compat_val; 303 struct compat_rt_sigframe __user * compat_frame; 304 compat_sigset_t compat_set; 305 #endif 306 307 usp = (regs->gr[30] & ~(0x01UL)); 308 /*FIXME: frame_size parameter is unused, remove it. */ 309 frame = get_sigframe(ka, usp, sizeof(*frame)); 310 311 DBG(1,"SETUP_RT_FRAME: START\n"); 312 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info); 313 314 315 #ifdef __LP64__ 316 317 compat_frame = (struct compat_rt_sigframe __user *)frame; 318 319 if(personality(current->personality) == PER_LINUX32) { 320 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info); 321 err |= compat_copy_siginfo_to_user(&compat_frame->info, info); 322 DBG(1,"SETUP_RT_FRAME: 1\n"); 323 compat_val = (compat_int_t)current->sas_ss_sp; 324 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp); 325 DBG(1,"SETUP_RT_FRAME: 2\n"); 326 compat_val = (compat_int_t)current->sas_ss_size; 327 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size); 328 DBG(1,"SETUP_RT_FRAME: 3\n"); 329 compat_val = sas_ss_flags(regs->gr[30]); 330 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags); 331 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc); 332 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext); 333 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 334 &compat_frame->regs, regs, in_syscall); 335 sigset_64to32(&compat_set,set); 336 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set)); 337 } else 338 #endif 339 { 340 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info); 341 err |= copy_siginfo_to_user(&frame->info, info); 342 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 343 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 344 err |= __put_user(sas_ss_flags(regs->gr[30]), 345 &frame->uc.uc_stack.ss_flags); 346 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc); 347 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext); 348 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall); 349 /* FIXME: Should probably be converted aswell for the compat case */ 350 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 351 } 352 353 if (err) 354 goto give_sigsegv; 355 356 /* Set up to return from userspace. If provided, use a stub 357 already in userspace. The first words of tramp are used to 358 save the previous sigrestartblock trampoline that might be 359 on the stack. We start the sigreturn trampoline at 360 SIGRESTARTBLOCK_TRAMP+X. */ 361 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0, 362 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]); 363 err |= __put_user(INSN_LDI_R20, 364 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]); 365 err |= __put_user(INSN_BLE_SR2_R0, 366 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]); 367 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]); 368 369 #if DEBUG_SIG 370 /* Assert that we're flushing in the correct space... */ 371 { 372 int sid; 373 asm ("mfsp %%sr3,%0" : "=r" (sid)); 374 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n", 375 sid, frame->tramp); 376 } 377 #endif 378 379 flush_user_dcache_range((unsigned long) &frame->tramp[0], 380 (unsigned long) &frame->tramp[TRAMP_SIZE]); 381 flush_user_icache_range((unsigned long) &frame->tramp[0], 382 (unsigned long) &frame->tramp[TRAMP_SIZE]); 383 384 /* TRAMP Words 0-4, Lenght 5 = SIGRESTARTBLOCK_TRAMP 385 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP 386 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP 387 */ 388 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP]; 389 390 if (err) 391 goto give_sigsegv; 392 393 haddr = A(ka->sa.sa_handler); 394 /* The sa_handler may be a pointer to a function descriptor */ 395 #ifdef __LP64__ 396 if(personality(current->personality) == PER_LINUX32) { 397 #endif 398 if (haddr & PA_PLABEL_FDESC) { 399 Elf32_Fdesc fdesc; 400 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3); 401 402 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 403 404 if (err) 405 goto give_sigsegv; 406 407 haddr = fdesc.addr; 408 regs->gr[19] = fdesc.gp; 409 } 410 #ifdef __LP64__ 411 } else { 412 Elf64_Fdesc fdesc; 413 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3); 414 415 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 416 417 if (err) 418 goto give_sigsegv; 419 420 haddr = fdesc.addr; 421 regs->gr[19] = fdesc.gp; 422 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n", 423 haddr, regs->gr[19], in_syscall); 424 } 425 #endif 426 427 /* The syscall return path will create IAOQ values from r31. 428 */ 429 sigframe_size = PARISC_RT_SIGFRAME_SIZE; 430 #ifdef __LP64__ 431 if(personality(current->personality) == PER_LINUX32) 432 sigframe_size = PARISC_RT_SIGFRAME_SIZE32; 433 #endif 434 if (in_syscall) { 435 regs->gr[31] = haddr; 436 #ifdef __LP64__ 437 if(personality(current->personality) == PER_LINUX) 438 sigframe_size |= 1; 439 #endif 440 } else { 441 unsigned long psw = USER_PSW; 442 #ifdef __LP64__ 443 if(personality(current->personality) == PER_LINUX) 444 psw |= PSW_W; 445 #endif 446 447 /* If we are singlestepping, arrange a trap to be delivered 448 when we return to userspace. Note the semantics -- we 449 should trap before the first insn in the handler is 450 executed. Ref: 451 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html 452 */ 453 if (pa_psw(current)->r) { 454 pa_psw(current)->r = 0; 455 psw |= PSW_R; 456 mtctl(-1, 0); 457 } 458 459 regs->gr[0] = psw; 460 regs->iaoq[0] = haddr | 3; 461 regs->iaoq[1] = regs->iaoq[0] + 4; 462 } 463 464 regs->gr[2] = rp; /* userland return pointer */ 465 regs->gr[26] = sig; /* signal number */ 466 467 #ifdef __LP64__ 468 if(personality(current->personality) == PER_LINUX32){ 469 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */ 470 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */ 471 } else 472 #endif 473 { 474 regs->gr[25] = A(&frame->info); /* siginfo pointer */ 475 regs->gr[24] = A(&frame->uc); /* ucontext pointer */ 476 } 477 478 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n", 479 regs->gr[30], sigframe_size, 480 regs->gr[30] + sigframe_size); 481 /* Raise the user stack pointer to make a proper call frame. */ 482 regs->gr[30] = (A(frame) + sigframe_size); 483 484 485 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n", 486 current->comm, current->pid, frame, regs->gr[30], 487 regs->iaoq[0], regs->iaoq[1], rp); 488 489 return 1; 490 491 give_sigsegv: 492 DBG(1,"setup_rt_frame: sending SIGSEGV\n"); 493 if (sig == SIGSEGV) 494 ka->sa.sa_handler = SIG_DFL; 495 si.si_signo = SIGSEGV; 496 si.si_errno = 0; 497 si.si_code = SI_KERNEL; 498 si.si_pid = current->pid; 499 si.si_uid = current->uid; 500 si.si_addr = frame; 501 force_sig_info(SIGSEGV, &si, current); 502 return 0; 503 } 504 505 /* 506 * OK, we're invoking a handler. 507 */ 508 509 static long 510 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 511 sigset_t *oldset, struct pt_regs *regs, int in_syscall) 512 { 513 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n", 514 sig, ka, info, oldset, regs); 515 516 /* Set up the stack frame */ 517 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall)) 518 return 0; 519 520 if (!(ka->sa.sa_flags & SA_NODEFER)) { 521 spin_lock_irq(¤t->sighand->siglock); 522 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 523 sigaddset(¤t->blocked,sig); 524 recalc_sigpending(); 525 spin_unlock_irq(¤t->sighand->siglock); 526 } 527 return 1; 528 } 529 530 /* 531 * Note that 'init' is a special process: it doesn't get signals it doesn't 532 * want to handle. Thus you cannot kill init even with a SIGKILL even by 533 * mistake. 534 * 535 * We need to be able to restore the syscall arguments (r21-r26) to 536 * restart syscalls. Thus, the syscall path should save them in the 537 * pt_regs structure (it's okay to do so since they are caller-save 538 * registers). As noted below, the syscall number gets restored for 539 * us due to the magic of delayed branching. 540 */ 541 542 asmlinkage int 543 do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall) 544 { 545 siginfo_t info; 546 struct k_sigaction ka; 547 int signr; 548 549 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n", 550 oldset, regs, regs->sr[7], in_syscall); 551 552 /* Everyone else checks to see if they are in kernel mode at 553 this point and exits if that's the case. I'm not sure why 554 we would be called in that case, but for some reason we 555 are. */ 556 557 if (!oldset) 558 oldset = ¤t->blocked; 559 560 DBG(1,"do_signal: oldset %08lx / %08lx\n", 561 oldset->sig[0], oldset->sig[1]); 562 563 564 /* May need to force signal if handle_signal failed to deliver */ 565 while (1) { 566 567 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 568 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 569 570 if (signr <= 0) 571 break; 572 573 /* Restart a system call if necessary. */ 574 if (in_syscall) { 575 /* Check the return code */ 576 switch (regs->gr[28]) { 577 case -ERESTART_RESTARTBLOCK: 578 current_thread_info()->restart_block.fn = do_no_restart_syscall; 579 case -ERESTARTNOHAND: 580 DBG(1,"ERESTARTNOHAND: returning -EINTR\n"); 581 regs->gr[28] = -EINTR; 582 break; 583 584 case -ERESTARTSYS: 585 if (!(ka.sa.sa_flags & SA_RESTART)) { 586 DBG(1,"ERESTARTSYS: putting -EINTR\n"); 587 regs->gr[28] = -EINTR; 588 break; 589 } 590 /* fallthrough */ 591 case -ERESTARTNOINTR: 592 /* A syscall is just a branch, so all 593 we have to do is fiddle the return pointer. */ 594 regs->gr[31] -= 8; /* delayed branching */ 595 /* Preserve original r28. */ 596 regs->gr[28] = regs->orig_r28; 597 break; 598 } 599 } 600 /* Whee! Actually deliver the signal. If the 601 delivery failed, we need to continue to iterate in 602 this loop so we can deliver the SIGSEGV... */ 603 if (handle_signal(signr, &info, &ka, oldset, regs, in_syscall)) { 604 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n", 605 regs->gr[28]); 606 return 1; 607 } 608 } 609 /* end of while(1) looping forever if we can't force a signal */ 610 611 /* Did we come from a system call? */ 612 if (in_syscall) { 613 /* Restart the system call - no handlers present */ 614 if (regs->gr[28] == -ERESTART_RESTARTBLOCK) { 615 unsigned int *usp = (unsigned int *)regs->gr[30]; 616 617 /* Setup a trampoline to restart the syscall 618 * with __NR_restart_syscall 619 * 620 * 0: <return address (orig r31)> 621 * 4: <2nd half for 64-bit> 622 * 8: ldw 0(%sp), %r31 623 * 12: be 0x100(%sr2, %r0) 624 * 16: ldi __NR_restart_syscall, %r20 625 */ 626 #ifndef __LP64__ 627 put_user(regs->gr[31], &usp[0]); 628 put_user(0x0fc0109f, &usp[2]); 629 #else 630 put_user(regs->gr[31] >> 32, &usp[0]); 631 put_user(regs->gr[31] & 0xffffffff, &usp[1]); 632 put_user(0x0fc010df, &usp[2]); 633 #endif 634 put_user(0xe0008200, &usp[3]); 635 put_user(0x34140000, &usp[4]); 636 637 /* Stack is 64-byte aligned, and we only 638 * need to flush 1 cache line */ 639 asm("fdc 0(%%sr3, %0)\n" 640 "fic 0(%%sr3, %0)\n" 641 "sync\n" 642 : : "r"(regs->gr[30])); 643 644 regs->gr[31] = regs->gr[30] + 8; 645 /* Preserve original r28. */ 646 regs->gr[28] = regs->orig_r28; 647 } else if (regs->gr[28] == -ERESTARTNOHAND || 648 regs->gr[28] == -ERESTARTSYS || 649 regs->gr[28] == -ERESTARTNOINTR) { 650 /* Hooray for delayed branching. We don't 651 have to restore %r20 (the system call 652 number) because it gets loaded in the delay 653 slot of the branch external instruction. */ 654 regs->gr[31] -= 8; 655 /* Preserve original r28. */ 656 regs->gr[28] = regs->orig_r28; 657 } 658 } 659 660 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 661 regs->gr[28]); 662 663 return 0; 664 } 665