arch/parisc/kernel/signal.c

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