arch/arm/kernel/signal.c

   1 /*
   2  *  linux/arch/arm/kernel/signal.c
   3  *
   4  *  Copyright (C) 1995-2002 Russell King
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10 #include <linux/config.h>
  11 #include <linux/errno.h>
  12 #include <linux/signal.h>
  13 #include <linux/ptrace.h>
  14 #include <linux/personality.h>
  15 #include <linux/suspend.h>
  16
  17 #include <asm/cacheflush.h>
  18 #include <asm/ucontext.h>
  19 #include <asm/uaccess.h>
  20 #include <asm/unistd.h>
  21
  22 #include "ptrace.h"
  23
  24 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  25
  26 /*
  27  * For ARM syscalls, we encode the syscall number into the instruction.
  28  */
  29 #define SWI_SYS_SIGRETURN       (0xef000000|(__NR_sigreturn))
  30 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(__NR_rt_sigreturn))
  31
  32 /*
  33  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
  34  * need two 16-bit instructions.
  35  */
  36 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
  37 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
  38
  39 static const unsigned long retcodes[4] = {
  40         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
  41         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
  42 };
  43
  44 static int do_signal(sigset_t *oldset, struct pt_regs * regs, int syscall);
  45
  46 /*
  47  * atomically swap in the new signal mask, and wait for a signal.
  48  */
  49 asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask, struct pt_regs *regs)
  50 {
  51         sigset_t saveset;
  52
  53         mask &= _BLOCKABLE;
  54         spin_lock_irq(&current->sighand->siglock);
  55         saveset = current->blocked;
  56         siginitset(&current->blocked, mask);
  57         recalc_sigpending();
  58         spin_unlock_irq(&current->sighand->siglock);
  59         regs->ARM_r0 = -EINTR;
  60
  61         while (1) {
  62                 current->state = TASK_INTERRUPTIBLE;
  63                 schedule();
  64                 if (do_signal(&saveset, regs, 0))
  65                         return regs->ARM_r0;
  66         }
  67 }
  68
  69 asmlinkage int
  70 sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, struct pt_regs *regs)
  71 {
  72         sigset_t saveset, newset;
  73
  74         /* XXX: Don't preclude handling different sized sigset_t's. */
  75         if (sigsetsize != sizeof(sigset_t))
  76                 return -EINVAL;
  77
  78         if (copy_from_user(&newset, unewset, sizeof(newset)))
  79                 return -EFAULT;
  80         sigdelsetmask(&newset, ~_BLOCKABLE);
  81
  82         spin_lock_irq(&current->sighand->siglock);
  83         saveset = current->blocked;
  84         current->blocked = newset;
  85         recalc_sigpending();
  86         spin_unlock_irq(&current->sighand->siglock);
  87         regs->ARM_r0 = -EINTR;
  88
  89         while (1) {
  90                 current->state = TASK_INTERRUPTIBLE;
  91                 schedule();
  92                 if (do_signal(&saveset, regs, 0))
  93                         return regs->ARM_r0;
  94         }
  95 }
  96
  97 asmlinkage int
  98 sys_sigaction(int sig, const struct old_sigaction __user *act,
  99               struct old_sigaction __user *oact)
 100 {
 101         struct k_sigaction new_ka, old_ka;
 102         int ret;
 103
 104         if (act) {
 105                 old_sigset_t mask;
 106                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 107                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 108                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 109                         return -EFAULT;
 110                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 111                 __get_user(mask, &act->sa_mask);
 112                 siginitset(&new_ka.sa.sa_mask, mask);
 113         }
 114
 115         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 116
 117         if (!ret && oact) {
 118                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 119                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 120                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 121                         return -EFAULT;
 122                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 123                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 124         }
 125
 126         return ret;
 127 }
 128
 129 #ifdef CONFIG_IWMMXT
 130
 131 /* iwmmxt_area is 0x98 bytes long, preceeded by 8 bytes of signature */
 132 #define IWMMXT_STORAGE_SIZE     (0x98 + 8)
 133 #define IWMMXT_MAGIC0           0x12ef842a
 134 #define IWMMXT_MAGIC1           0x1c07ca71
 135
 136 struct iwmmxt_sigframe {
 137         unsigned long   magic0;
 138         unsigned long   magic1;
 139         unsigned long   storage[0x98/4];
 140 };
 141
 142 static int page_present(struct mm_struct *mm, void __user *uptr, int wr)
 143 {
 144         unsigned long addr = (unsigned long)uptr;
 145         pgd_t *pgd = pgd_offset(mm, addr);
 146         if (pgd_present(*pgd)) {
 147                 pmd_t *pmd = pmd_offset(pgd, addr);
 148                 if (pmd_present(*pmd)) {
 149                         pte_t *pte = pte_offset_map(pmd, addr);
 150                         return (pte_present(*pte) && (!wr || pte_write(*pte)));
 151                 }
 152         }
 153         return 0;
 154 }
 155
 156 static int copy_locked(void __user *uptr, void *kptr, size_t size, int write,
 157                        void (*copyfn)(void *, void __user *))
 158 {
 159         unsigned char v, __user *userptr = uptr;
 160         int err = 0;
 161
 162         do {
 163                 struct mm_struct *mm;
 164
 165                 if (write) {
 166                         __put_user_error(0, userptr, err);
 167                         __put_user_error(0, userptr + size - 1, err);
 168                 } else {
 169                         __get_user_error(v, userptr, err);
 170                         __get_user_error(v, userptr + size - 1, err);
 171                 }
 172
 173                 if (err)
 174                         break;
 175
 176                 mm = current->mm;
 177                 spin_lock(&mm->page_table_lock);
 178                 if (page_present(mm, userptr, write) &&
 179                     page_present(mm, userptr + size - 1, write)) {
 180                         copyfn(kptr, uptr);
 181                 } else
 182                         err = 1;
 183                 spin_unlock(&mm->page_table_lock);
 184         } while (err);
 185
 186         return err;
 187 }
 188
 189 static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
 190 {
 191         int err = 0;
 192
 193         /* the iWMMXt context must be 64 bit aligned */
 194         WARN_ON((unsigned long)frame & 7);
 195
 196         __put_user_error(IWMMXT_MAGIC0, &frame->magic0, err);
 197         __put_user_error(IWMMXT_MAGIC1, &frame->magic1, err);
 198
 199         /*
 200          * iwmmxt_task_copy() doesn't check user permissions.
 201          * Let's do a dummy write on the upper boundary to ensure
 202          * access to user mem is OK all way up.
 203          */
 204         err |= copy_locked(&frame->storage, current_thread_info(),
 205                            sizeof(frame->storage), 1, iwmmxt_task_copy);
 206         return err;
 207 }
 208
 209 static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
 210 {
 211         unsigned long magic0, magic1;
 212         int err = 0;
 213
 214         /* the iWMMXt context is 64 bit aligned */
 215         WARN_ON((unsigned long)frame & 7);
 216
 217         /*
 218          * Validate iWMMXt context signature.
 219          * Also, iwmmxt_task_restore() doesn't check user permissions.
 220          * Let's do a dummy write on the upper boundary to ensure
 221          * access to user mem is OK all way up.
 222          */
 223         __get_user_error(magic0, &frame->magic0, err);
 224         __get_user_error(magic1, &frame->magic1, err);
 225         if (!err && magic0 == IWMMXT_MAGIC0 && magic1 == IWMMXT_MAGIC1)
 226                 err = copy_locked(&frame->storage, current_thread_info(),
 227                                   sizeof(frame->storage), 0, iwmmxt_task_restore);
 228         return err;
 229 }
 230
 231 #endif
 232
 233 /*
 234  * Auxiliary signal frame.  This saves stuff like FP state.
 235  * The layout of this structure is not part of the user ABI.
 236  */
 237 struct aux_sigframe {
 238 #ifdef CONFIG_IWMMXT
 239         struct iwmmxt_sigframe  iwmmxt;
 240 #endif
 241 #ifdef CONFIG_VFP
 242         union vfp_state         vfp;
 243 #endif
 244 };
 245
 246 /*
 247  * Do a signal return; undo the signal stack.  These are aligned to 64-bit.
 248  */
 249 struct sigframe {
 250         struct sigcontext sc;
 251         unsigned long extramask[_NSIG_WORDS-1];
 252         unsigned long retcode;
 253         struct aux_sigframe aux __attribute__((aligned(8)));
 254 };
 255
 256 struct rt_sigframe {
 257         struct siginfo __user *pinfo;
 258         void __user *puc;
 259         struct siginfo info;
 260         struct ucontext uc;
 261         unsigned long retcode;
 262         struct aux_sigframe aux __attribute__((aligned(8)));
 263 };
 264
 265 static int
 266 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
 267                    struct aux_sigframe __user *aux)
 268 {
 269         int err = 0;
 270
 271         __get_user_error(regs->ARM_r0, &sc->arm_r0, err);
 272         __get_user_error(regs->ARM_r1, &sc->arm_r1, err);
 273         __get_user_error(regs->ARM_r2, &sc->arm_r2, err);
 274         __get_user_error(regs->ARM_r3, &sc->arm_r3, err);
 275         __get_user_error(regs->ARM_r4, &sc->arm_r4, err);
 276         __get_user_error(regs->ARM_r5, &sc->arm_r5, err);
 277         __get_user_error(regs->ARM_r6, &sc->arm_r6, err);
 278         __get_user_error(regs->ARM_r7, &sc->arm_r7, err);
 279         __get_user_error(regs->ARM_r8, &sc->arm_r8, err);
 280         __get_user_error(regs->ARM_r9, &sc->arm_r9, err);
 281         __get_user_error(regs->ARM_r10, &sc->arm_r10, err);
 282         __get_user_error(regs->ARM_fp, &sc->arm_fp, err);
 283         __get_user_error(regs->ARM_ip, &sc->arm_ip, err);
 284         __get_user_error(regs->ARM_sp, &sc->arm_sp, err);
 285         __get_user_error(regs->ARM_lr, &sc->arm_lr, err);
 286         __get_user_error(regs->ARM_pc, &sc->arm_pc, err);
 287         __get_user_error(regs->ARM_cpsr, &sc->arm_cpsr, err);
 288
 289         err |= !valid_user_regs(regs);
 290
 291 #ifdef CONFIG_IWMMXT
 292         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
 293                 err |= restore_iwmmxt_context(&aux->iwmmxt);
 294 #endif
 295 #ifdef CONFIG_VFP
 296 //      if (err == 0)
 297 //              err |= vfp_restore_state(&aux->vfp);
 298 #endif
 299
 300         return err;
 301 }
 302
 303 asmlinkage int sys_sigreturn(struct pt_regs *regs)
 304 {
 305         struct sigframe __user *frame;
 306         sigset_t set;
 307
 308         /* Always make any pending restarted system calls return -EINTR */
 309         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 310
 311         /*
 312          * Since we stacked the signal on a 64-bit boundary,
 313          * then 'sp' should be word aligned here.  If it's
 314          * not, then the user is trying to mess with us.
 315          */
 316         if (regs->ARM_sp & 7)
 317                 goto badframe;
 318
 319         frame = (struct sigframe __user *)regs->ARM_sp;
 320
 321         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
 322                 goto badframe;
 323         if (__get_user(set.sig[0], &frame->sc.oldmask)
 324             || (_NSIG_WORDS > 1
 325                 && __copy_from_user(&set.sig[1], &frame->extramask,
 326                                     sizeof(frame->extramask))))
 327                 goto badframe;
 328
 329         sigdelsetmask(&set, ~_BLOCKABLE);
 330         spin_lock_irq(&current->sighand->siglock);
 331         current->blocked = set;
 332         recalc_sigpending();
 333         spin_unlock_irq(&current->sighand->siglock);
 334
 335         if (restore_sigcontext(regs, &frame->sc, &frame->aux))
 336                 goto badframe;
 337
 338         /* Send SIGTRAP if we're single-stepping */
 339         if (current->ptrace & PT_SINGLESTEP) {
 340                 ptrace_cancel_bpt(current);
 341                 send_sig(SIGTRAP, current, 1);
 342         }
 343
 344         return regs->ARM_r0;
 345
 346 badframe:
 347         force_sig(SIGSEGV, current);
 348         return 0;
 349 }
 350
 351 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
 352 {
 353         struct rt_sigframe __user *frame;
 354         sigset_t set;
 355
 356         /* Always make any pending restarted system calls return -EINTR */
 357         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 358
 359         /*
 360          * Since we stacked the signal on a 64-bit boundary,
 361          * then 'sp' should be word aligned here.  If it's
 362          * not, then the user is trying to mess with us.
 363          */
 364         if (regs->ARM_sp & 7)
 365                 goto badframe;
 366
 367         frame = (struct rt_sigframe __user *)regs->ARM_sp;
 368
 369         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
 370                 goto badframe;
 371         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 372                 goto badframe;
 373
 374         sigdelsetmask(&set, ~_BLOCKABLE);
 375         spin_lock_irq(&current->sighand->siglock);
 376         current->blocked = set;
 377         recalc_sigpending();
 378         spin_unlock_irq(&current->sighand->siglock);
 379
 380         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &frame->aux))
 381                 goto badframe;
 382
 383         if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->ARM_sp) == -EFAULT)
 384                 goto badframe;
 385
 386         /* Send SIGTRAP if we're single-stepping */
 387         if (current->ptrace & PT_SINGLESTEP) {
 388                 ptrace_cancel_bpt(current);
 389                 send_sig(SIGTRAP, current, 1);
 390         }
 391
 392         return regs->ARM_r0;
 393
 394 badframe:
 395         force_sig(SIGSEGV, current);
 396         return 0;
 397 }
 398
 399 static int
 400 setup_sigcontext(struct sigcontext __user *sc, struct aux_sigframe __user *aux,
 401                  struct pt_regs *regs, unsigned long mask)
 402 {
 403         int err = 0;
 404
 405         __put_user_error(regs->ARM_r0, &sc->arm_r0, err);
 406         __put_user_error(regs->ARM_r1, &sc->arm_r1, err);
 407         __put_user_error(regs->ARM_r2, &sc->arm_r2, err);
 408         __put_user_error(regs->ARM_r3, &sc->arm_r3, err);
 409         __put_user_error(regs->ARM_r4, &sc->arm_r4, err);
 410         __put_user_error(regs->ARM_r5, &sc->arm_r5, err);
 411         __put_user_error(regs->ARM_r6, &sc->arm_r6, err);
 412         __put_user_error(regs->ARM_r7, &sc->arm_r7, err);
 413         __put_user_error(regs->ARM_r8, &sc->arm_r8, err);
 414         __put_user_error(regs->ARM_r9, &sc->arm_r9, err);
 415         __put_user_error(regs->ARM_r10, &sc->arm_r10, err);
 416         __put_user_error(regs->ARM_fp, &sc->arm_fp, err);
 417         __put_user_error(regs->ARM_ip, &sc->arm_ip, err);
 418         __put_user_error(regs->ARM_sp, &sc->arm_sp, err);
 419         __put_user_error(regs->ARM_lr, &sc->arm_lr, err);
 420         __put_user_error(regs->ARM_pc, &sc->arm_pc, err);
 421         __put_user_error(regs->ARM_cpsr, &sc->arm_cpsr, err);
 422
 423         __put_user_error(current->thread.trap_no, &sc->trap_no, err);
 424         __put_user_error(current->thread.error_code, &sc->error_code, err);
 425         __put_user_error(current->thread.address, &sc->fault_address, err);
 426         __put_user_error(mask, &sc->oldmask, err);
 427
 428 #ifdef CONFIG_IWMMXT
 429         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
 430                 err |= preserve_iwmmxt_context(&aux->iwmmxt);
 431 #endif
 432 #ifdef CONFIG_VFP
 433 //      if (err == 0)
 434 //              err |= vfp_save_state(&aux->vfp);
 435 #endif
 436
 437         return err;
 438 }
 439
 440 static inline void __user *
 441 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
 442 {
 443         unsigned long sp = regs->ARM_sp;
 444         void __user *frame;
 445
 446         /*
 447          * This is the X/Open sanctioned signal stack switching.
 448          */
 449         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
 450                 sp = current->sas_ss_sp + current->sas_ss_size;
 451
 452         /*
 453          * ATPCS B01 mandates 8-byte alignment
 454          */
 455         frame = (void __user *)((sp - framesize) & ~7);
 456
 457         /*
 458          * Check that we can actually write to the signal frame.
 459          */
 460         if (!access_ok(VERIFY_WRITE, frame, framesize))
 461                 frame = NULL;
 462
 463         return frame;
 464 }
 465
 466 static int
 467 setup_return(struct pt_regs *regs, struct k_sigaction *ka,
 468              unsigned long __user *rc, void __user *frame, int usig)
 469 {
 470         unsigned long handler = (unsigned long)ka->sa.sa_handler;
 471         unsigned long retcode;
 472         int thumb = 0;
 473         unsigned long cpsr = regs->ARM_cpsr & ~PSR_f;
 474
 475         /*
 476          * Maybe we need to deliver a 32-bit signal to a 26-bit task.
 477          */
 478         if (ka->sa.sa_flags & SA_THIRTYTWO)
 479                 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
 480
 481 #ifdef CONFIG_ARM_THUMB
 482         if (elf_hwcap & HWCAP_THUMB) {
 483                 /*
 484                  * The LSB of the handler determines if we're going to
 485                  * be using THUMB or ARM mode for this signal handler.
 486                  */
 487                 thumb = handler & 1;
 488
 489                 if (thumb)
 490                         cpsr |= PSR_T_BIT;
 491                 else
 492                         cpsr &= ~PSR_T_BIT;
 493         }
 494 #endif
 495
 496         if (ka->sa.sa_flags & SA_RESTORER) {
 497                 retcode = (unsigned long)ka->sa.sa_restorer;
 498         } else {
 499                 unsigned int idx = thumb;
 500
 501                 if (ka->sa.sa_flags & SA_SIGINFO)
 502                         idx += 2;
 503
 504                 if (__put_user(retcodes[idx], rc))
 505                         return 1;
 506
 507                 /*
 508                  * Ensure that the instruction cache sees
 509                  * the return code written onto the stack.
 510                  */
 511                 flush_icache_range((unsigned long)rc,
 512                                    (unsigned long)(rc + 1));
 513
 514                 retcode = ((unsigned long)rc) + thumb;
 515         }
 516
 517         regs->ARM_r0 = usig;
 518         regs->ARM_sp = (unsigned long)frame;
 519         regs->ARM_lr = retcode;
 520         regs->ARM_pc = handler;
 521         regs->ARM_cpsr = cpsr;
 522
 523         return 0;
 524 }
 525
 526 static int
 527 setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
 528 {
 529         struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
 530         int err = 0;
 531
 532         if (!frame)
 533                 return 1;
 534
 535         err |= setup_sigcontext(&frame->sc, &frame->aux, regs, set->sig[0]);
 536
 537         if (_NSIG_WORDS > 1) {
 538                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 539                                       sizeof(frame->extramask));
 540         }
 541
 542         if (err == 0)
 543                 err = setup_return(regs, ka, &frame->retcode, frame, usig);
 544
 545         return err;
 546 }
 547
 548 static int
 549 setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
 550                sigset_t *set, struct pt_regs *regs)
 551 {
 552         struct rt_sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
 553         stack_t stack;
 554         int err = 0;
 555
 556         if (!frame)
 557                 return 1;
 558
 559         __put_user_error(&frame->info, &frame->pinfo, err);
 560         __put_user_error(&frame->uc, &frame->puc, err);
 561         err |= copy_siginfo_to_user(&frame->info, info);
 562
 563         __put_user_error(0, &frame->uc.uc_flags, err);
 564         __put_user_error(NULL, &frame->uc.uc_link, err);
 565
 566         memset(&stack, 0, sizeof(stack));
 567         stack.ss_sp = (void __user *)current->sas_ss_sp;
 568         stack.ss_flags = sas_ss_flags(regs->ARM_sp);
 569         stack.ss_size = current->sas_ss_size;
 570         err |= __copy_to_user(&frame->uc.uc_stack, &stack, sizeof(stack));
 571
 572         err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->aux,
 573                                 regs, set->sig[0]);
 574         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 575
 576         if (err == 0)
 577                 err = setup_return(regs, ka, &frame->retcode, frame, usig);
 578
 579         if (err == 0) {
 580                 /*
 581                  * For realtime signals we must also set the second and third
 582                  * arguments for the signal handler.
 583                  *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
 584                  */
 585                 regs->ARM_r1 = (unsigned long)&frame->info;
 586                 regs->ARM_r2 = (unsigned long)&frame->uc;
 587         }
 588
 589         return err;
 590 }
 591
 592 static inline void restart_syscall(struct pt_regs *regs)
 593 {
 594         regs->ARM_r0 = regs->ARM_ORIG_r0;
 595         regs->ARM_pc -= thumb_mode(regs) ? 2 : 4;
 596 }
 597
 598 /*
 599  * OK, we're invoking a handler
 600  */
 601 static void
 602 handle_signal(unsigned long sig, struct k_sigaction *ka,
 603               siginfo_t *info, sigset_t *oldset,
 604               struct pt_regs * regs, int syscall)
 605 {
 606         struct thread_info *thread = current_thread_info();
 607         struct task_struct *tsk = current;
 608         int usig = sig;
 609         int ret;
 610
 611         /*
 612          * If we were from a system call, check for system call restarting...
 613          */
 614         if (syscall) {
 615                 switch (regs->ARM_r0) {
 616                 case -ERESTART_RESTARTBLOCK:
 617                 case -ERESTARTNOHAND:
 618                         regs->ARM_r0 = -EINTR;
 619                         break;
 620                 case -ERESTARTSYS:
 621                         if (!(ka->sa.sa_flags & SA_RESTART)) {
 622                                 regs->ARM_r0 = -EINTR;
 623                                 break;
 624                         }
 625                         /* fallthrough */
 626                 case -ERESTARTNOINTR:
 627                         restart_syscall(regs);
 628                 }
 629         }
 630
 631         /*
 632          * translate the signal
 633          */
 634         if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
 635                 usig = thread->exec_domain->signal_invmap[usig];
 636
 637         /*
 638          * Set up the stack frame
 639          */
 640         if (ka->sa.sa_flags & SA_SIGINFO)
 641                 ret = setup_rt_frame(usig, ka, info, oldset, regs);
 642         else
 643                 ret = setup_frame(usig, ka, oldset, regs);
 644
 645         /*
 646          * Check that the resulting registers are actually sane.
 647          */
 648         ret |= !valid_user_regs(regs);
 649
 650         /*
 651          * Block the signal if we were unsuccessful.
 652          */
 653         if (ret != 0 || !(ka->sa.sa_flags & SA_NODEFER)) {
 654                 spin_lock_irq(&tsk->sighand->siglock);
 655                 sigorsets(&tsk->blocked, &tsk->blocked,
 656                           &ka->sa.sa_mask);
 657                 sigaddset(&tsk->blocked, sig);
 658                 recalc_sigpending();
 659                 spin_unlock_irq(&tsk->sighand->siglock);
 660         }
 661
 662         if (ret == 0)
 663                 return;
 664
 665         force_sigsegv(sig, tsk);
 666 }
 667
 668 /*
 669  * Note that 'init' is a special process: it doesn't get signals it doesn't
 670  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 671  * mistake.
 672  *
 673  * Note that we go through the signals twice: once to check the signals that
 674  * the kernel can handle, and then we build all the user-level signal handling
 675  * stack-frames in one go after that.
 676  */
 677 static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
 678 {
 679         struct k_sigaction ka;
 680         siginfo_t info;
 681         int signr;
 682
 683         /*
 684          * We want the common case to go fast, which
 685          * is why we may in certain cases get here from
 686          * kernel mode. Just return without doing anything
 687          * if so.
 688          */
 689         if (!user_mode(regs))
 690                 return 0;
 691
 692         if (current->flags & PF_FREEZE) {
 693                 refrigerator(0);
 694                 goto no_signal;
 695         }
 696
 697         if (current->ptrace & PT_SINGLESTEP)
 698                 ptrace_cancel_bpt(current);
 699
 700         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 701         if (signr > 0) {
 702                 handle_signal(signr, &ka, &info, oldset, regs, syscall);
 703                 if (current->ptrace & PT_SINGLESTEP)
 704                         ptrace_set_bpt(current);
 705                 return 1;
 706         }
 707
 708  no_signal:
 709         /*
 710          * No signal to deliver to the process - restart the syscall.
 711          */
 712         if (syscall) {
 713                 if (regs->ARM_r0 == -ERESTART_RESTARTBLOCK) {
 714                         if (thumb_mode(regs)) {
 715                                 regs->ARM_r7 = __NR_restart_syscall;
 716                                 regs->ARM_pc -= 2;
 717                         } else {
 718                                 u32 __user *usp;
 719
 720                                 regs->ARM_sp -= 12;
 721                                 usp = (u32 __user *)regs->ARM_sp;
 722
 723                                 put_user(regs->ARM_pc, &usp[0]);
 724                                 /* swi __NR_restart_syscall */
 725                                 put_user(0xef000000 | __NR_restart_syscall, &usp[1]);
 726                                 /* ldr  pc, [sp], #12 */
 727                                 put_user(0xe49df00c, &usp[2]);
 728
 729                                 flush_icache_range((unsigned long)usp,
 730                                                    (unsigned long)(usp + 3));
 731
 732                                 regs->ARM_pc = regs->ARM_sp + 4;
 733                         }
 734                 }
 735                 if (regs->ARM_r0 == -ERESTARTNOHAND ||
 736                     regs->ARM_r0 == -ERESTARTSYS ||
 737                     regs->ARM_r0 == -ERESTARTNOINTR) {
 738                         restart_syscall(regs);
 739                 }
 740         }
 741         if (current->ptrace & PT_SINGLESTEP)
 742                 ptrace_set_bpt(current);
 743         return 0;
 744 }
 745
 746 asmlinkage void
 747 do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
 748 {
 749         if (thread_flags & _TIF_SIGPENDING)
 750                 do_signal(&current->blocked, regs, syscall);
 751 }