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         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 194                 sp = current->sas_ss_sp; /* Stacks grow up! */
 195
 196         DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
 197         return (void __user *) sp; /* Stacks grow up.  Fun. */
 198 }
 199
 200 static long
 201 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
 202
 203 {
 204         unsigned long flags = 0;
 205         long err = 0;
 206
 207         if (on_sig_stack((unsigned long) sc))
 208                 flags |= PARISC_SC_FLAG_ONSTACK;
 209         if (in_syscall) {
 210                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
 211                 /* regs->iaoq is undefined in the syscall return path */
 212                 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
 213                 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
 214                 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
 215                 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
 216                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
 217                         regs->gr[31], regs->gr[31]+4);
 218         } else {
 219                 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
 220                 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
 221                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
 222                         regs->iaoq[0], regs->iaoq[1]);
 223         }
 224
 225         err |= __put_user(flags, &sc->sc_flags);
 226         err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
 227         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
 228         err |= __put_user(regs->sar, &sc->sc_sar);
 229         DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
 230
 231         return err;
 232 }
 233
 234 static long
 235 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 236                sigset_t *set, struct pt_regs *regs, int in_syscall)
 237 {
 238         struct rt_sigframe __user *frame;
 239         unsigned long rp, usp;
 240         unsigned long haddr, sigframe_size;
 241         int err = 0;
 242 #ifdef CONFIG_64BIT
 243         compat_int_t compat_val;
 244         struct compat_rt_sigframe __user * compat_frame;
 245         compat_sigset_t compat_set;
 246 #endif
 247
 248         usp = (regs->gr[30] & ~(0x01UL));
 249         /*FIXME: frame_size parameter is unused, remove it. */
 250         frame = get_sigframe(ka, usp, sizeof(*frame));
 251
 252         DBG(1,"SETUP_RT_FRAME: START\n");
 253         DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
 254
 255
 256 #ifdef CONFIG_64BIT
 257
 258         compat_frame = (struct compat_rt_sigframe __user *)frame;
 259
 260         if (is_compat_task()) {
 261                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
 262                 err |= copy_siginfo_to_user32(&compat_frame->info, info);
 263                 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
 264                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
 265                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
 266                 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
 267                                         &compat_frame->regs, regs, in_syscall);
 268                 sigset_64to32(&compat_set,set);
 269                 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
 270         } else
 271 #endif
 272         {
 273                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
 274                 err |= copy_siginfo_to_user(&frame->info, info);
 275                 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
 276                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
 277                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
 278                 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
 279                 /* FIXME: Should probably be converted as well for the compat case */
 280                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 281         }
 282
 283         if (err)
 284                 goto give_sigsegv;
 285
 286         /* Set up to return from userspace.  If provided, use a stub
 287            already in userspace. The first words of tramp are used to
 288            save the previous sigrestartblock trampoline that might be
 289            on the stack. We start the sigreturn trampoline at
 290            SIGRESTARTBLOCK_TRAMP+X. */
 291         err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
 292                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
 293         err |= __put_user(INSN_LDI_R20,
 294                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
 295         err |= __put_user(INSN_BLE_SR2_R0,
 296                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
 297         err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
 298
 299 #if DEBUG_SIG
 300         /* Assert that we're flushing in the correct space... */
 301         {
 302                 int sid;
 303                 asm ("mfsp %%sr3,%0" : "=r" (sid));
 304                 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
 305                        sid, frame->tramp);
 306         }
 307 #endif
 308
 309         flush_user_dcache_range((unsigned long) &frame->tramp[0],
 310                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
 311         flush_user_icache_range((unsigned long) &frame->tramp[0],
 312                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
 313
 314         /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
 315          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
 316          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
 317          */
 318         rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
 319
 320         if (err)
 321                 goto give_sigsegv;
 322
 323         haddr = A(ka->sa.sa_handler);
 324         /* The sa_handler may be a pointer to a function descriptor */
 325 #ifdef CONFIG_64BIT
 326         if (is_compat_task()) {
 327 #endif
 328                 if (haddr & PA_PLABEL_FDESC) {
 329                         Elf32_Fdesc fdesc;
 330                         Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
 331
 332                         err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 333
 334                         if (err)
 335                                 goto give_sigsegv;
 336
 337                         haddr = fdesc.addr;
 338                         regs->gr[19] = fdesc.gp;
 339                 }
 340 #ifdef CONFIG_64BIT
 341         } else {
 342                 Elf64_Fdesc fdesc;
 343                 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
 344
 345                 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 346
 347                 if (err)
 348                         goto give_sigsegv;
 349
 350                 haddr = fdesc.addr;
 351                 regs->gr[19] = fdesc.gp;
 352                 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
 353                      haddr, regs->gr[19], in_syscall);
 354         }
 355 #endif
 356
 357         /* The syscall return path will create IAOQ values from r31.
 358          */
 359         sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 360 #ifdef CONFIG_64BIT
 361         if (is_compat_task())
 362                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 363 #endif
 364         if (in_syscall) {
 365                 regs->gr[31] = haddr;
 366 #ifdef CONFIG_64BIT
 367                 if (!test_thread_flag(TIF_32BIT))
 368                         sigframe_size |= 1;
 369 #endif
 370         } else {
 371                 unsigned long psw = USER_PSW;
 372 #ifdef CONFIG_64BIT
 373                 if (!test_thread_flag(TIF_32BIT))
 374                         psw |= PSW_W;
 375 #endif
 376
 377                 /* If we are singlestepping, arrange a trap to be delivered
 378                    when we return to userspace. Note the semantics -- we
 379                    should trap before the first insn in the handler is
 380                    executed. Ref:
 381                         http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
 382                  */
 383                 if (pa_psw(current)->r) {
 384                         pa_psw(current)->r = 0;
 385                         psw |= PSW_R;
 386                         mtctl(-1, 0);
 387                 }
 388
 389                 regs->gr[0] = psw;
 390                 regs->iaoq[0] = haddr | 3;
 391                 regs->iaoq[1] = regs->iaoq[0] + 4;
 392         }
 393
 394         regs->gr[2]  = rp;                /* userland return pointer */
 395         regs->gr[26] = sig;               /* signal number */
 396
 397 #ifdef CONFIG_64BIT
 398         if (is_compat_task()) {
 399                 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
 400                 regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
 401         } else
 402 #endif
 403         {
 404                 regs->gr[25] = A(&frame->info); /* siginfo pointer */
 405                 regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
 406         }
 407
 408         DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
 409                regs->gr[30], sigframe_size,
 410                regs->gr[30] + sigframe_size);
 411         /* Raise the user stack pointer to make a proper call frame. */
 412         regs->gr[30] = (A(frame) + sigframe_size);
 413
 414
 415         DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
 416                current->comm, current->pid, frame, regs->gr[30],
 417                regs->iaoq[0], regs->iaoq[1], rp);
 418
 419         return 1;
 420
 421 give_sigsegv:
 422         DBG(1,"setup_rt_frame: sending SIGSEGV\n");
 423         force_sigsegv(sig, current);
 424         return 0;
 425 }
 426
 427 /*
 428  * OK, we're invoking a handler.
 429  */
 430
 431 static void
 432 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 433                 struct pt_regs *regs, int in_syscall)
 434 {
 435         sigset_t *oldset = sigmask_to_save();
 436         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
 437                sig, ka, info, oldset, regs);
 438
 439         /* Set up the stack frame */
 440         if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
 441                 return;
 442
 443         signal_delivered(sig, info, ka, regs,
 444                 test_thread_flag(TIF_SINGLESTEP) ||
 445                 test_thread_flag(TIF_BLOCKSTEP));
 446
 447         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
 448                 regs->gr[28]);
 449 }
 450
 451 static inline void
 452 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 453 {
 454         if (regs->orig_r28)
 455                 return;
 456         regs->orig_r28 = 1; /* no more restarts */
 457         /* Check the return code */
 458         switch (regs->gr[28]) {
 459         case -ERESTART_RESTARTBLOCK:
 460         case -ERESTARTNOHAND:
 461                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
 462                 regs->gr[28] = -EINTR;
 463                 break;
 464
 465         case -ERESTARTSYS:
 466                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 467                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
 468                         regs->gr[28] = -EINTR;
 469                         break;
 470                 }
 471                 /* fallthrough */
 472         case -ERESTARTNOINTR:
 473                 /* A syscall is just a branch, so all
 474                  * we have to do is fiddle the return pointer.
 475                  */
 476                 regs->gr[31] -= 8; /* delayed branching */
 477                 break;
 478         }
 479 }
 480
 481 static inline void
 482 insert_restart_trampoline(struct pt_regs *regs)
 483 {
 484         if (regs->orig_r28)
 485                 return;
 486         regs->orig_r28 = 1; /* no more restarts */
 487         switch(regs->gr[28]) {
 488         case -ERESTART_RESTARTBLOCK: {
 489                 /* Restart the system call - no handlers present */
 490                 unsigned int *usp = (unsigned int *)regs->gr[30];
 491
 492                 /* Setup a trampoline to restart the syscall
 493                  * with __NR_restart_syscall
 494                  *
 495                  *  0: <return address (orig r31)>
 496                  *  4: <2nd half for 64-bit>
 497                  *  8: ldw 0(%sp), %r31
 498                  * 12: be 0x100(%sr2, %r0)
 499                  * 16: ldi __NR_restart_syscall, %r20
 500                  */
 501 #ifdef CONFIG_64BIT
 502                 put_user(regs->gr[31] >> 32, &usp[0]);
 503                 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
 504                 put_user(0x0fc010df, &usp[2]);
 505 #else
 506                 put_user(regs->gr[31], &usp[0]);
 507                 put_user(0x0fc0109f, &usp[2]);
 508 #endif
 509                 put_user(0xe0008200, &usp[3]);
 510                 put_user(0x34140000, &usp[4]);
 511
 512                 /* Stack is 64-byte aligned, and we only need
 513                  * to flush 1 cache line.
 514                  * Flushing one cacheline is cheap.
 515                  * "sync" on bigger (> 4 way) boxes is not.
 516                  */
 517                 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
 518                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
 519
 520                 regs->gr[31] = regs->gr[30] + 8;
 521                 return;
 522         }
 523         case -ERESTARTNOHAND:
 524         case -ERESTARTSYS:
 525         case -ERESTARTNOINTR: {
 526                 /* Hooray for delayed branching.  We don't
 527                  * have to restore %r20 (the system call
 528                  * number) because it gets loaded in the delay
 529                  * slot of the branch external instruction.
 530                  */
 531                 regs->gr[31] -= 8;
 532                 return;
 533         }
 534         default:
 535                 break;
 536         }
 537 }
 538
 539 /*
 540  * Note that 'init' is a special process: it doesn't get signals it doesn't
 541  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 542  * mistake.
 543  *
 544  * We need to be able to restore the syscall arguments (r21-r26) to
 545  * restart syscalls.  Thus, the syscall path should save them in the
 546  * pt_regs structure (it's okay to do so since they are caller-save
 547  * registers).  As noted below, the syscall number gets restored for
 548  * us due to the magic of delayed branching.
 549  */
 550 asmlinkage void
 551 do_signal(struct pt_regs *regs, long in_syscall)
 552 {
 553         siginfo_t info;
 554         struct k_sigaction ka;
 555         int signr;
 556
 557         DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
 558                regs, regs->sr[7], in_syscall);
 559
 560         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 561         DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
 562
 563         if (signr > 0) {
 564                 /* Restart a system call if necessary. */
 565                 if (in_syscall)
 566                         syscall_restart(regs, &ka);
 567
 568                 handle_signal(signr, &info, &ka, regs, in_syscall);
 569                 return;
 570         }
 571
 572         /* Did we come from a system call? */
 573         if (in_syscall)
 574                 insert_restart_trampoline(regs);
 575
 576         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
 577                 regs->gr[28]);
 578
 579         restore_saved_sigmask();
 580 }
 581
 582 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 583 {
 584         if (test_thread_flag(TIF_SIGPENDING))
 585                 do_signal(regs, in_syscall);
 586
 587         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
 588                 clear_thread_flag(TIF_NOTIFY_RESUME);
 589                 tracehook_notify_resume(regs);
 590         }
 591 }