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