arch/arm/kernel/signal.c

   1 /*
   2  *  linux/arch/arm/kernel/signal.c
   3  *
   4  *  Copyright (C) 1995, 1996 Russell King
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/sched.h>
   9 #include <linux/mm.h>
  10 #include <linux/smp.h>
  11 #include <linux/smp_lock.h>
  12 #include <linux/kernel.h>
  13 #include <linux/errno.h>
  14 #include <linux/signal.h>
  15 #include <linux/wait.h>
  16 #include <linux/ptrace.h>
  17 #include <linux/stddef.h>
  18 #include <linux/unistd.h>
  19 #include <linux/tty.h>
  20
  21 #include <asm/pgalloc.h>
  22 #include <asm/ucontext.h>
  23 #include <asm/uaccess.h>
  24
  25 #include "ptrace.h"
  26
  27 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  28
  29 #define SWI_SYS_SIGRETURN (0xef000000|(__NR_sigreturn))
  30 #define SWI_SYS_RT_SIGRETURN (0xef000000|(__NR_rt_sigreturn))
  31
  32 asmlinkage int sys_wait4(pid_t pid, unsigned long * stat_addr,
  33                          int options, unsigned long *ru);
  34 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs, int syscall);
  35
  36 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  37 {
  38         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  39                 return -EFAULT;
  40         if (from->si_code < 0)
  41                 return __copy_to_user(to, from, sizeof(siginfo_t));
  42         else {
  43                 int err;
  44
  45                 /* If you change siginfo_t structure, please be sure
  46                    this code is fixed accordingly.
  47                    It should never copy any pad contained in the structure
  48                    to avoid security leaks, but must copy the generic
  49                    3 ints plus the relevant union member.  */
  50                 err = __put_user(from->si_signo, &to->si_signo);
  51                 err |= __put_user(from->si_errno, &to->si_errno);
  52                 err |= __put_user((short)from->si_code, &to->si_code);
  53                 /* First 32bits of unions are always present.  */
  54                 err |= __put_user(from->si_pid, &to->si_pid);
  55                 switch (from->si_code >> 16) {
  56                 case __SI_FAULT >> 16:
  57                         break;
  58                 case __SI_CHLD >> 16:
  59                         err |= __put_user(from->si_utime, &to->si_utime);
  60                         err |= __put_user(from->si_stime, &to->si_stime);
  61                         err |= __put_user(from->si_status, &to->si_status);
  62                 default:
  63                         err |= __put_user(from->si_uid, &to->si_uid);
  64                         break;
  65                 /* case __SI_RT: This is not generated by the kernel as of now.  */
  66                 }
  67                 return err;
  68         }
  69 }
  70
  71 /*
  72  * atomically swap in the new signal mask, and wait for a signal.
  73  */
  74 asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask, struct pt_regs *regs)
  75 {
  76         sigset_t saveset;
  77
  78         mask &= _BLOCKABLE;
  79         spin_lock_irq(&current->sigmask_lock);
  80         saveset = current->blocked;
  81         siginitset(&current->blocked, mask);
  82         recalc_sigpending(current);
  83         spin_unlock_irq(&current->sigmask_lock);
  84         regs->ARM_r0 = -EINTR;
  85
  86         while (1) {
  87                 current->state = TASK_INTERRUPTIBLE;
  88                 schedule();
  89                 if (do_signal(&saveset, regs, 0))
  90                         return regs->ARM_r0;
  91         }
  92 }
  93
  94 asmlinkage int
  95 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs)
  96 {
  97         sigset_t saveset, newset;
  98
  99         /* XXX: Don't preclude handling different sized sigset_t's. */
 100         if (sigsetsize != sizeof(sigset_t))
 101                 return -EINVAL;
 102
 103         if (copy_from_user(&newset, unewset, sizeof(newset)))
 104                 return -EFAULT;
 105         sigdelsetmask(&newset, ~_BLOCKABLE);
 106
 107         spin_lock_irq(&current->sigmask_lock);
 108         saveset = current->blocked;
 109         current->blocked = newset;
 110         recalc_sigpending(current);
 111         spin_unlock_irq(&current->sigmask_lock);
 112         regs->ARM_r0 = -EINTR;
 113
 114         while (1) {
 115                 current->state = TASK_INTERRUPTIBLE;
 116                 schedule();
 117                 if (do_signal(&saveset, regs, 0))
 118                         return regs->ARM_r0;
 119         }
 120 }
 121
 122 asmlinkage int
 123 sys_sigaction(int sig, const struct old_sigaction *act,
 124               struct old_sigaction *oact)
 125 {
 126         struct k_sigaction new_ka, old_ka;
 127         int ret;
 128
 129         if (act) {
 130                 old_sigset_t mask;
 131                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 132                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 133                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 134                         return -EFAULT;
 135                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 136                 __get_user(mask, &act->sa_mask);
 137                 siginitset(&new_ka.sa.sa_mask, mask);
 138         }
 139
 140         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 141
 142         if (!ret && oact) {
 143                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 144                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 145                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 146                         return -EFAULT;
 147                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 148                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 149         }
 150
 151         return ret;
 152 }
 153
 154 /*
 155  * Do a signal return; undo the signal stack.
 156  */
 157 struct sigframe
 158 {
 159         struct sigcontext sc;
 160         unsigned long extramask[_NSIG_WORDS-1];
 161         unsigned long retcode;
 162 };
 163
 164 struct rt_sigframe
 165 {
 166         struct siginfo *pinfo;
 167         void *puc;
 168         struct siginfo info;
 169         struct ucontext uc;
 170         unsigned long retcode;
 171 };
 172
 173 static int
 174 restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
 175 {
 176         int err = 0;
 177
 178         err |= __get_user(regs->ARM_r0, &sc->arm_r0);
 179         err |= __get_user(regs->ARM_r1, &sc->arm_r1);
 180         err |= __get_user(regs->ARM_r2, &sc->arm_r2);
 181         err |= __get_user(regs->ARM_r3, &sc->arm_r3);
 182         err |= __get_user(regs->ARM_r4, &sc->arm_r4);
 183         err |= __get_user(regs->ARM_r5, &sc->arm_r5);
 184         err |= __get_user(regs->ARM_r6, &sc->arm_r6);
 185         err |= __get_user(regs->ARM_r7, &sc->arm_r7);
 186         err |= __get_user(regs->ARM_r8, &sc->arm_r8);
 187         err |= __get_user(regs->ARM_r9, &sc->arm_r9);
 188         err |= __get_user(regs->ARM_r10, &sc->arm_r10);
 189         err |= __get_user(regs->ARM_fp, &sc->arm_fp);
 190         err |= __get_user(regs->ARM_ip, &sc->arm_ip);
 191         err |= __get_user(regs->ARM_sp, &sc->arm_sp);
 192         err |= __get_user(regs->ARM_lr, &sc->arm_lr);
 193         err |= __get_user(regs->ARM_pc, &sc->arm_pc);
 194 #ifdef CONFIG_CPU_32
 195         err |= __get_user(regs->ARM_cpsr, &sc->arm_cpsr);
 196 #endif
 197
 198         err |= !valid_user_regs(regs);
 199
 200         return err;
 201 }
 202
 203 asmlinkage int sys_sigreturn(struct pt_regs *regs)
 204 {
 205         struct sigframe *frame;
 206         sigset_t set;
 207
 208         /*
 209          * Since we stacked the signal on a word boundary,
 210          * then 'sp' should be word aligned here.  If it's
 211          * not, then the user is trying to mess with us.
 212          */
 213         if (regs->ARM_sp & 3)
 214                 goto badframe;
 215
 216         frame = (struct sigframe *)regs->ARM_sp;
 217
 218         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
 219                 goto badframe;
 220         if (__get_user(set.sig[0], &frame->sc.oldmask)
 221             || (_NSIG_WORDS > 1
 222                 && __copy_from_user(&set.sig[1], &frame->extramask,
 223                                     sizeof(frame->extramask))))
 224                 goto badframe;
 225
 226         sigdelsetmask(&set, ~_BLOCKABLE);
 227         spin_lock_irq(&current->sigmask_lock);
 228         current->blocked = set;
 229         recalc_sigpending(current);
 230         spin_unlock_irq(&current->sigmask_lock);
 231
 232         if (restore_sigcontext(regs, &frame->sc))
 233                 goto badframe;
 234
 235         /* Send SIGTRAP if we're single-stepping */
 236         if (ptrace_cancel_bpt(current))
 237                 send_sig(SIGTRAP, current, 1);
 238
 239         return regs->ARM_r0;
 240
 241 badframe:
 242         force_sig(SIGSEGV, current);
 243         return 0;
 244 }
 245
 246 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
 247 {
 248         struct rt_sigframe *frame;
 249         sigset_t set;
 250
 251         /*
 252          * Since we stacked the signal on a word boundary,
 253          * then 'sp' should be word aligned here.  If it's
 254          * not, then the user is trying to mess with us.
 255          */
 256         if (regs->ARM_sp & 3)
 257                 goto badframe;
 258
 259         frame = (struct rt_sigframe *)regs->ARM_sp;
 260
 261         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
 262                 goto badframe;
 263         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 264                 goto badframe;
 265
 266         sigdelsetmask(&set, ~_BLOCKABLE);
 267         spin_lock_irq(&current->sigmask_lock);
 268         current->blocked = set;
 269         recalc_sigpending(current);
 270         spin_unlock_irq(&current->sigmask_lock);
 271
 272         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 273                 goto badframe;
 274
 275         /* Send SIGTRAP if we're single-stepping */
 276         if (ptrace_cancel_bpt(current))
 277                 send_sig(SIGTRAP, current, 1);
 278
 279         return regs->ARM_r0;
 280
 281 badframe:
 282         force_sig(SIGSEGV, current);
 283         return 0;
 284 }
 285
 286 static int
 287 setup_sigcontext(struct sigcontext *sc, /*struct _fpstate *fpstate,*/
 288                  struct pt_regs *regs, unsigned long mask)
 289 {
 290         int err = 0;
 291
 292         err |= __put_user (regs->ARM_r0, &sc->arm_r0);
 293         err |= __put_user (regs->ARM_r1, &sc->arm_r1);
 294         err |= __put_user (regs->ARM_r2, &sc->arm_r2);
 295         err |= __put_user (regs->ARM_r3, &sc->arm_r3);
 296         err |= __put_user (regs->ARM_r4, &sc->arm_r4);
 297         err |= __put_user (regs->ARM_r5, &sc->arm_r5);
 298         err |= __put_user (regs->ARM_r6, &sc->arm_r6);
 299         err |= __put_user (regs->ARM_r7, &sc->arm_r7);
 300         err |= __put_user (regs->ARM_r8, &sc->arm_r8);
 301         err |= __put_user (regs->ARM_r9, &sc->arm_r9);
 302         err |= __put_user (regs->ARM_r10, &sc->arm_r10);
 303         err |= __put_user (regs->ARM_fp, &sc->arm_fp);
 304         err |= __put_user (regs->ARM_ip, &sc->arm_ip);
 305         err |= __put_user (regs->ARM_sp, &sc->arm_sp);
 306         err |= __put_user (regs->ARM_lr, &sc->arm_lr);
 307         err |= __put_user (regs->ARM_pc, &sc->arm_pc);
 308 #ifdef CONFIG_CPU_32
 309         err |= __put_user (regs->ARM_cpsr, &sc->arm_cpsr);
 310 #endif
 311
 312         err |= __put_user (current->thread.trap_no, &sc->trap_no);
 313         err |= __put_user (current->thread.error_code, &sc->error_code);
 314         err |= __put_user (current->thread.address, &sc->fault_address);
 315         err |= __put_user (mask, &sc->oldmask);
 316
 317         return err;
 318 }
 319
 320 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 321                                  unsigned long framesize)
 322 {
 323         unsigned long sp = regs->ARM_sp;
 324
 325         /*
 326          * This is the X/Open sanctioned signal stack switching.
 327          */
 328         if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
 329                 sp = current->sas_ss_sp + current->sas_ss_size;
 330
 331         /*
 332          * No matter what happens, 'sp' must be word
 333          * aligned otherwise nasty things could happen
 334          */
 335         sp &= ~3;
 336
 337         return (void *)(sp - framesize);
 338 }
 339
 340 static void setup_frame(int sig, struct k_sigaction *ka,
 341                         sigset_t *set, struct pt_regs *regs)
 342 {
 343         struct sigframe *frame;
 344         unsigned long retcode;
 345         int err = 0;
 346
 347         frame = get_sigframe(ka, regs, sizeof(*frame));
 348
 349         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 350                 goto segv_and_exit;
 351
 352         err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
 353
 354         if (_NSIG_WORDS > 1) {
 355                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 356                                       sizeof(frame->extramask));
 357         }
 358
 359         /* Set up to return from userspace.  If provided, use a stub
 360            already in userspace.  */
 361         if (ka->sa.sa_flags & SA_RESTORER) {
 362                 retcode = (unsigned long)ka->sa.sa_restorer;
 363         } else {
 364                 retcode = (unsigned long)&frame->retcode;
 365                 err |= __put_user(SWI_SYS_SIGRETURN, &frame->retcode);
 366                 flush_icache_range(retcode, retcode + 4);
 367         }
 368
 369         if (err)
 370                 goto segv_and_exit;
 371
 372         if (current->exec_domain && current->exec_domain->signal_invmap && sig < 32)
 373                 regs->ARM_r0 = current->exec_domain->signal_invmap[sig];
 374         else
 375                 regs->ARM_r0 = sig;
 376         regs->ARM_sp = (unsigned long)frame;
 377         regs->ARM_lr = retcode;
 378         regs->ARM_pc = (unsigned long)ka->sa.sa_handler;
 379 #if defined(CONFIG_CPU_32)
 380         /* Maybe we need to deliver a 32-bit signal to a 26-bit task. */
 381         if (ka->sa.sa_flags & SA_THIRTYTWO)
 382                 regs->ARM_cpsr = USR_MODE;
 383 #endif
 384         if (valid_user_regs(regs))
 385                 return;
 386
 387 segv_and_exit:
 388         if (sig == SIGSEGV)
 389                 ka->sa.sa_handler = SIG_DFL;
 390         force_sig(SIGSEGV, current);
 391 }
 392
 393 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 394                            sigset_t *set, struct pt_regs *regs)
 395 {
 396         struct rt_sigframe *frame;
 397         unsigned long retcode;
 398         int err = 0;
 399
 400         frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
 401
 402         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 403                 goto segv_and_exit;
 404
 405         err |= __put_user(&frame->info, &frame->pinfo);
 406         err |= __put_user(&frame->uc, &frame->puc);
 407         err |= copy_siginfo_to_user(&frame->info, info);
 408
 409         /* Clear all the bits of the ucontext we don't use.  */
 410         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 411
 412         err |= setup_sigcontext(&frame->uc.uc_mcontext, /*&frame->fpstate,*/
 413                                 regs, set->sig[0]);
 414         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 415
 416         /* Set up to return from userspace.  If provided, use a stub
 417            already in userspace.  */
 418         if (ka->sa.sa_flags & SA_RESTORER) {
 419                 retcode = (unsigned long)ka->sa.sa_restorer;
 420         } else {
 421                 retcode = (unsigned long)&frame->retcode;
 422                 err |= __put_user(SWI_SYS_RT_SIGRETURN, &frame->retcode);
 423                 flush_icache_range(retcode, retcode + 4);
 424         }
 425
 426         if (err)
 427                 goto segv_and_exit;
 428
 429         if (current->exec_domain && current->exec_domain->signal_invmap && sig < 32)
 430                 regs->ARM_r0 = current->exec_domain->signal_invmap[sig];
 431         else
 432                 regs->ARM_r0 = sig;
 433         regs->ARM_sp = (unsigned long)frame;
 434         regs->ARM_lr = retcode;
 435         regs->ARM_pc = (unsigned long)ka->sa.sa_handler;
 436 #if defined(CONFIG_CPU_32)
 437         /* Maybe we need to deliver a 32-bit signal to a 26-bit task. */
 438         if (ka->sa.sa_flags & SA_THIRTYTWO)
 439                 regs->ARM_cpsr = USR_MODE;
 440 #endif
 441         if (valid_user_regs(regs))
 442                 return;
 443
 444 segv_and_exit:
 445         if (sig == SIGSEGV)
 446                 ka->sa.sa_handler = SIG_DFL;
 447         force_sig(SIGSEGV, current);
 448 }
 449
 450 /*
 451  * OK, we're invoking a handler
 452  */
 453 static void
 454 handle_signal(unsigned long sig, struct k_sigaction *ka,
 455               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 456 {
 457         /* Set up the stack frame */
 458         if (ka->sa.sa_flags & SA_SIGINFO)
 459                 setup_rt_frame(sig, ka, info, oldset, regs);
 460         else
 461                 setup_frame(sig, ka, oldset, regs);
 462
 463         if (ka->sa.sa_flags & SA_ONESHOT)
 464                 ka->sa.sa_handler = SIG_DFL;
 465
 466         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 467                 spin_lock_irq(&current->sigmask_lock);
 468                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 469                 sigaddset(&current->blocked,sig);
 470                 recalc_sigpending(current);
 471                 spin_unlock_irq(&current->sigmask_lock);
 472         }
 473 }
 474
 475 /*
 476  * Note that 'init' is a special process: it doesn't get signals it doesn't
 477  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 478  * mistake.
 479  *
 480  * Note that we go through the signals twice: once to check the signals that
 481  * the kernel can handle, and then we build all the user-level signal handling
 482  * stack-frames in one go after that.
 483  */
 484 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
 485 {
 486         struct k_sigaction *ka;
 487         siginfo_t info;
 488         int single_stepping;
 489
 490         /*
 491          * We want the common case to go fast, which
 492          * is why we may in certain cases get here from
 493          * kernel mode. Just return without doing anything
 494          * if so.
 495          */
 496         if (!user_mode(regs))
 497                 return 0;
 498
 499         if (!oldset)
 500                 oldset = &current->blocked;
 501
 502         single_stepping = ptrace_cancel_bpt(current);
 503
 504         for (;;) {
 505                 unsigned long signr;
 506
 507                 spin_lock_irq (&current->sigmask_lock);
 508                 signr = dequeue_signal(&current->blocked, &info);
 509                 spin_unlock_irq (&current->sigmask_lock);
 510
 511                 if (!signr)
 512                         break;
 513
 514                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
 515                         /* Let the debugger run.  */
 516                         current->exit_code = signr;
 517                         current->state = TASK_STOPPED;
 518                         notify_parent(current, SIGCHLD);
 519                         schedule();
 520                         single_stepping |= ptrace_cancel_bpt(current);
 521
 522                         /* We're back.  Did the debugger cancel the sig?  */
 523                         if (!(signr = current->exit_code))
 524                                 continue;
 525                         current->exit_code = 0;
 526
 527                         /* The debugger continued.  Ignore SIGSTOP.  */
 528                         if (signr == SIGSTOP)
 529                                 continue;
 530
 531                         /* Update the siginfo structure.  Is this good? */
 532                         if (signr != info.si_signo) {
 533                                 info.si_signo = signr;
 534                                 info.si_errno = 0;
 535                                 info.si_code = SI_USER;
 536                                 info.si_pid = current->p_pptr->pid;
 537                                 info.si_uid = current->p_pptr->uid;
 538                         }
 539
 540                         /* If the (new) signal is now blocked, requeue it.  */
 541                         if (sigismember(&current->blocked, signr)) {
 542                                 send_sig_info(signr, &info, current);
 543                                 continue;
 544                         }
 545                 }
 546
 547                 ka = &current->sig->action[signr-1];
 548                 if (ka->sa.sa_handler == SIG_IGN) {
 549                         if (signr != SIGCHLD)
 550                                 continue;
 551                         /* Check for SIGCHLD: it's special.  */
 552                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
 553                                 /* nothing */;
 554                         continue;
 555                 }
 556
 557                 if (ka->sa.sa_handler == SIG_DFL) {
 558                         int exit_code = signr;
 559
 560                         /* Init gets no signals it doesn't want.  */
 561                         if (current->pid == 1)
 562                                 continue;
 563
 564                         switch (signr) {
 565                         case SIGCONT: case SIGCHLD: case SIGWINCH:
 566                                 continue;
 567
 568                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
 569                                 if (is_orphaned_pgrp(current->pgrp))
 570                                         continue;
 571                                 /* FALLTHRU */
 572
 573                         case SIGSTOP:
 574                                 current->state = TASK_STOPPED;
 575                                 current->exit_code = signr;
 576                                 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
 577                                         notify_parent(current, SIGCHLD);
 578                                 schedule();
 579                                 continue;
 580
 581                         case SIGQUIT: case SIGILL: case SIGTRAP:
 582                         case SIGABRT: case SIGFPE: case SIGSEGV:
 583                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
 584                                 if (do_coredump(signr, regs))
 585                                         exit_code |= 0x80;
 586                                 /* FALLTHRU */
 587
 588                         default:
 589                                 sigaddset(&current->signal, signr);
 590                                 recalc_sigpending(current);
 591                                 current->flags |= PF_SIGNALED;
 592                                 do_exit(exit_code);
 593                                 /* NOTREACHED */
 594                         }
 595                 }
 596
 597                 /* Are we from a system call? */
 598                 if (syscall) {
 599                         switch (regs->ARM_r0) {
 600                         case -ERESTARTNOHAND:
 601                                 regs->ARM_r0 = -EINTR;
 602                                 break;
 603
 604                         case -ERESTARTSYS:
 605                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 606                                         regs->ARM_r0 = -EINTR;
 607                                         break;
 608                                 }
 609                                 /* fallthrough */
 610                         case -ERESTARTNOINTR:
 611                                 regs->ARM_r0 = regs->ARM_ORIG_r0;
 612                                 regs->ARM_pc -= 4;
 613                         }
 614                 }
 615                 /* Whee!  Actually deliver the signal.  */
 616                 handle_signal(signr, ka, &info, oldset, regs);
 617                 if (single_stepping)
 618                         ptrace_set_bpt(current);
 619                 return 1;
 620         }
 621
 622         if (syscall &&
 623             (regs->ARM_r0 == -ERESTARTNOHAND ||
 624              regs->ARM_r0 == -ERESTARTSYS ||
 625              regs->ARM_r0 == -ERESTARTNOINTR)) {
 626                 regs->ARM_r0 = regs->ARM_ORIG_r0;
 627                 regs->ARM_pc -= 4;
 628         }
 629         if (single_stepping)
 630                 ptrace_set_bpt(current);
 631         return 0;
 632 }