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