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/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 force_sigsegv(sig, current); 494 return 0; 495 } 496 497 /* 498 * OK, we're invoking a handler. 499 */ 500 501 static long 502 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 503 sigset_t *oldset, struct pt_regs *regs, int in_syscall) 504 { 505 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n", 506 sig, ka, info, oldset, regs); 507 508 /* Set up the stack frame */ 509 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall)) 510 return 0; 511 512 spin_lock_irq(¤t->sighand->siglock); 513 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 514 if (!(ka->sa.sa_flags & SA_NODEFER)) 515 sigaddset(¤t->blocked,sig); 516 recalc_sigpending(); 517 spin_unlock_irq(¤t->sighand->siglock); 518 return 1; 519 } 520 521 /* 522 * Note that 'init' is a special process: it doesn't get signals it doesn't 523 * want to handle. Thus you cannot kill init even with a SIGKILL even by 524 * mistake. 525 * 526 * We need to be able to restore the syscall arguments (r21-r26) to 527 * restart syscalls. Thus, the syscall path should save them in the 528 * pt_regs structure (it's okay to do so since they are caller-save 529 * registers). As noted below, the syscall number gets restored for 530 * us due to the magic of delayed branching. 531 */ 532 533 asmlinkage int 534 do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall) 535 { 536 siginfo_t info; 537 struct k_sigaction ka; 538 int signr; 539 540 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n", 541 oldset, regs, regs->sr[7], in_syscall); 542 543 /* Everyone else checks to see if they are in kernel mode at 544 this point and exits if that's the case. I'm not sure why 545 we would be called in that case, but for some reason we 546 are. */ 547 548 if (!oldset) 549 oldset = ¤t->blocked; 550 551 DBG(1,"do_signal: oldset %08lx / %08lx\n", 552 oldset->sig[0], oldset->sig[1]); 553 554 555 /* May need to force signal if handle_signal failed to deliver */ 556 while (1) { 557 558 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 559 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 560 561 if (signr <= 0) 562 break; 563 564 /* Restart a system call if necessary. */ 565 if (in_syscall) { 566 /* Check the return code */ 567 switch (regs->gr[28]) { 568 case -ERESTART_RESTARTBLOCK: 569 current_thread_info()->restart_block.fn = do_no_restart_syscall; 570 case -ERESTARTNOHAND: 571 DBG(1,"ERESTARTNOHAND: returning -EINTR\n"); 572 regs->gr[28] = -EINTR; 573 break; 574 575 case -ERESTARTSYS: 576 if (!(ka.sa.sa_flags & SA_RESTART)) { 577 DBG(1,"ERESTARTSYS: putting -EINTR\n"); 578 regs->gr[28] = -EINTR; 579 break; 580 } 581 /* fallthrough */ 582 case -ERESTARTNOINTR: 583 /* A syscall is just a branch, so all 584 we have to do is fiddle the return pointer. */ 585 regs->gr[31] -= 8; /* delayed branching */ 586 /* Preserve original r28. */ 587 regs->gr[28] = regs->orig_r28; 588 break; 589 } 590 } 591 /* Whee! Actually deliver the signal. If the 592 delivery failed, we need to continue to iterate in 593 this loop so we can deliver the SIGSEGV... */ 594 if (handle_signal(signr, &info, &ka, oldset, regs, in_syscall)) { 595 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n", 596 regs->gr[28]); 597 return 1; 598 } 599 } 600 /* end of while(1) looping forever if we can't force a signal */ 601 602 /* Did we come from a system call? */ 603 if (in_syscall) { 604 /* Restart the system call - no handlers present */ 605 if (regs->gr[28] == -ERESTART_RESTARTBLOCK) { 606 unsigned int *usp = (unsigned int *)regs->gr[30]; 607 608 /* Setup a trampoline to restart the syscall 609 * with __NR_restart_syscall 610 * 611 * 0: <return address (orig r31)> 612 * 4: <2nd half for 64-bit> 613 * 8: ldw 0(%sp), %r31 614 * 12: be 0x100(%sr2, %r0) 615 * 16: ldi __NR_restart_syscall, %r20 616 */ 617 #ifndef __LP64__ 618 put_user(regs->gr[31], &usp[0]); 619 put_user(0x0fc0109f, &usp[2]); 620 #else 621 put_user(regs->gr[31] >> 32, &usp[0]); 622 put_user(regs->gr[31] & 0xffffffff, &usp[1]); 623 put_user(0x0fc010df, &usp[2]); 624 #endif 625 put_user(0xe0008200, &usp[3]); 626 put_user(0x34140000, &usp[4]); 627 628 /* Stack is 64-byte aligned, and we only need 629 * to flush 1 cache line. 630 * Flushing one cacheline is cheap. 631 * "sync" on bigger (> 4 way) boxes is not. 632 */ 633 asm("fdc %%r0(%%sr3, %0)\n" 634 "sync\n" 635 "fic %%r0(%%sr3, %0)\n" 636 "sync\n" 637 : : "r"(regs->gr[30])); 638 639 regs->gr[31] = regs->gr[30] + 8; 640 /* Preserve original r28. */ 641 regs->gr[28] = regs->orig_r28; 642 } else if (regs->gr[28] == -ERESTARTNOHAND || 643 regs->gr[28] == -ERESTARTSYS || 644 regs->gr[28] == -ERESTARTNOINTR) { 645 /* Hooray for delayed branching. We don't 646 have to restore %r20 (the system call 647 number) because it gets loaded in the delay 648 slot of the branch external instruction. */ 649 regs->gr[31] -= 8; 650 /* Preserve original r28. */ 651 regs->gr[28] = regs->orig_r28; 652 } 653 } 654 655 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 656 regs->gr[28]); 657 658 return 0; 659 } 660