arch/parisc/kernel/signal.c

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