arch/sh/kernel/signal_64.c

   1 /*
   2  * arch/sh/kernel/signal_64.c
   3  *
   4  * Copyright (C) 2000, 2001  Paolo Alberelli
   5  * Copyright (C) 2003 - 2008  Paul Mundt
   6  * Copyright (C) 2004  Richard Curnow
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/rwsem.h>
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/kernel.h>
  17 #include <linux/signal.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/personality.h>
  21 #include <linux/freezer.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/unistd.h>
  24 #include <linux/stddef.h>
  25 #include <linux/tracehook.h>
  26 #include <asm/ucontext.h>
  27 #include <asm/uaccess.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/cacheflush.h>
  30 #include <asm/fpu.h>
  31
  32 #define REG_RET 9
  33 #define REG_ARG1 2
  34 #define REG_ARG2 3
  35 #define REG_ARG3 4
  36 #define REG_SP 15
  37 #define REG_PR 18
  38 #define REF_REG_RET regs->regs[REG_RET]
  39 #define REF_REG_SP regs->regs[REG_SP]
  40 #define DEREF_REG_PR regs->regs[REG_PR]
  41
  42 #define DEBUG_SIG 0
  43
  44 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  45
  46 static int
  47 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
  48                 sigset_t *oldset, struct pt_regs * regs);
  49
  50 static inline void
  51 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
  52 {
  53         /* If we're not from a syscall, bail out */
  54         if (regs->syscall_nr < 0)
  55                 return;
  56
  57         /* check for system call restart.. */
  58         switch (regs->regs[REG_RET]) {
  59                 case -ERESTART_RESTARTBLOCK:
  60                 case -ERESTARTNOHAND:
  61                 no_system_call_restart:
  62                         regs->regs[REG_RET] = -EINTR;
  63                         break;
  64
  65                 case -ERESTARTSYS:
  66                         if (!(sa->sa_flags & SA_RESTART))
  67                                 goto no_system_call_restart;
  68                 /* fallthrough */
  69                 case -ERESTARTNOINTR:
  70                         /* Decode syscall # */
  71                         regs->regs[REG_RET] = regs->syscall_nr;
  72                         regs->pc -= 4;
  73                         break;
  74         }
  75 }
  76
  77 /*
  78  * Note that 'init' is a special process: it doesn't get signals it doesn't
  79  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  80  * mistake.
  81  *
  82  * Note that we go through the signals twice: once to check the signals that
  83  * the kernel can handle, and then we build all the user-level signal handling
  84  * stack-frames in one go after that.
  85  */
  86 static int do_signal(struct pt_regs *regs, sigset_t *oldset)
  87 {
  88         siginfo_t info;
  89         int signr;
  90         struct k_sigaction ka;
  91
  92         /*
  93          * We want the common case to go fast, which
  94          * is why we may in certain cases get here from
  95          * kernel mode. Just return without doing anything
  96          * if so.
  97          */
  98         if (!user_mode(regs))
  99                 return 1;
 100
 101         if (try_to_freeze())
 102                 goto no_signal;
 103
 104         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 105                 oldset = &current->saved_sigmask;
 106         else if (!oldset)
 107                 oldset = &current->blocked;
 108
 109         signr = get_signal_to_deliver(&info, &ka, regs, 0);
 110         if (signr > 0) {
 111                 handle_syscall_restart(regs, &ka.sa);
 112
 113                 /* Whee!  Actually deliver the signal.  */
 114                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
 115                         /*
 116                          * If a signal was successfully delivered, the
 117                          * saved sigmask is in its frame, and we can
 118                          * clear the TIF_RESTORE_SIGMASK flag.
 119                          */
 120                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 121                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 122
 123                         tracehook_signal_handler(signr, &info, &ka, regs, 0);
 124                         return 1;
 125                 }
 126         }
 127
 128 no_signal:
 129         /* Did we come from a system call? */
 130         if (regs->syscall_nr >= 0) {
 131                 /* Restart the system call - no handlers present */
 132                 switch (regs->regs[REG_RET]) {
 133                 case -ERESTARTNOHAND:
 134                 case -ERESTARTSYS:
 135                 case -ERESTARTNOINTR:
 136                         /* Decode Syscall # */
 137                         regs->regs[REG_RET] = regs->syscall_nr;
 138                         regs->pc -= 4;
 139                         break;
 140
 141                 case -ERESTART_RESTARTBLOCK:
 142                         regs->regs[REG_RET] = __NR_restart_syscall;
 143                         regs->pc -= 4;
 144                         break;
 145                 }
 146         }
 147
 148         /* No signal to deliver -- put the saved sigmask back */
 149         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 150                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 151                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 152         }
 153
 154         return 0;
 155 }
 156
 157 /*
 158  * Atomically swap in the new signal mask, and wait for a signal.
 159  */
 160 asmlinkage int
 161 sys_sigsuspend(old_sigset_t mask,
 162                unsigned long r3, unsigned long r4, unsigned long r5,
 163                unsigned long r6, unsigned long r7,
 164                struct pt_regs * regs)
 165 {
 166         sigset_t saveset;
 167
 168         mask &= _BLOCKABLE;
 169         spin_lock_irq(&current->sighand->siglock);
 170         saveset = current->blocked;
 171         siginitset(&current->blocked, mask);
 172         recalc_sigpending();
 173         spin_unlock_irq(&current->sighand->siglock);
 174
 175         REF_REG_RET = -EINTR;
 176         while (1) {
 177                 current->state = TASK_INTERRUPTIBLE;
 178                 schedule();
 179                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 180                 if (do_signal(regs, &saveset)) {
 181                         /* pc now points at signal handler. Need to decrement
 182                            it because entry.S will increment it. */
 183                         regs->pc -= 4;
 184                         return -EINTR;
 185                 }
 186         }
 187 }
 188
 189 asmlinkage int
 190 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
 191                   unsigned long r4, unsigned long r5, unsigned long r6,
 192                   unsigned long r7,
 193                   struct pt_regs * regs)
 194 {
 195         sigset_t saveset, newset;
 196
 197         /* XXX: Don't preclude handling different sized sigset_t's.  */
 198         if (sigsetsize != sizeof(sigset_t))
 199                 return -EINVAL;
 200
 201         if (copy_from_user(&newset, unewset, sizeof(newset)))
 202                 return -EFAULT;
 203         sigdelsetmask(&newset, ~_BLOCKABLE);
 204         spin_lock_irq(&current->sighand->siglock);
 205         saveset = current->blocked;
 206         current->blocked = newset;
 207         recalc_sigpending();
 208         spin_unlock_irq(&current->sighand->siglock);
 209
 210         REF_REG_RET = -EINTR;
 211         while (1) {
 212                 current->state = TASK_INTERRUPTIBLE;
 213                 schedule();
 214                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 215                 if (do_signal(regs, &saveset)) {
 216                         /* pc now points at signal handler. Need to decrement
 217                            it because entry.S will increment it. */
 218                         regs->pc -= 4;
 219                         return -EINTR;
 220                 }
 221         }
 222 }
 223
 224 asmlinkage int
 225 sys_sigaction(int sig, const struct old_sigaction __user *act,
 226               struct old_sigaction __user *oact)
 227 {
 228         struct k_sigaction new_ka, old_ka;
 229         int ret;
 230
 231         if (act) {
 232                 old_sigset_t mask;
 233                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 234                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 235                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 236                         return -EFAULT;
 237                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 238                 __get_user(mask, &act->sa_mask);
 239                 siginitset(&new_ka.sa.sa_mask, mask);
 240         }
 241
 242         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 243
 244         if (!ret && oact) {
 245                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 246                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 247                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 248                         return -EFAULT;
 249                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 250                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 251         }
 252
 253         return ret;
 254 }
 255
 256 asmlinkage int
 257 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 258                 unsigned long r4, unsigned long r5, unsigned long r6,
 259                 unsigned long r7,
 260                 struct pt_regs * regs)
 261 {
 262         return do_sigaltstack(uss, uoss, REF_REG_SP);
 263 }
 264
 265 /*
 266  * Do a signal return; undo the signal stack.
 267  */
 268 struct sigframe {
 269         struct sigcontext sc;
 270         unsigned long extramask[_NSIG_WORDS-1];
 271         long long retcode[2];
 272 };
 273
 274 struct rt_sigframe {
 275         struct siginfo __user *pinfo;
 276         void *puc;
 277         struct siginfo info;
 278         struct ucontext uc;
 279         long long retcode[2];
 280 };
 281
 282 #ifdef CONFIG_SH_FPU
 283 static inline int
 284 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 285 {
 286         int err = 0;
 287         int fpvalid;
 288
 289         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 290         conditional_used_math(fpvalid);
 291         if (! fpvalid)
 292                 return err;
 293
 294         if (current == last_task_used_math) {
 295                 last_task_used_math = NULL;
 296                 regs->sr |= SR_FD;
 297         }
 298
 299         err |= __copy_from_user(&current->thread.fpu.hard, &sc->sc_fpregs[0],
 300                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 301
 302         return err;
 303 }
 304
 305 static inline int
 306 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 307 {
 308         int err = 0;
 309         int fpvalid;
 310
 311         fpvalid = !!used_math();
 312         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 313         if (! fpvalid)
 314                 return err;
 315
 316         if (current == last_task_used_math) {
 317                 enable_fpu();
 318                 save_fpu(current, regs);
 319                 disable_fpu();
 320                 last_task_used_math = NULL;
 321                 regs->sr |= SR_FD;
 322         }
 323
 324         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.fpu.hard,
 325                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 326         clear_used_math();
 327
 328         return err;
 329 }
 330 #else
 331 static inline int
 332 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 333 {
 334         return 0;
 335 }
 336 static inline int
 337 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 338 {
 339         return 0;
 340 }
 341 #endif
 342
 343 static int
 344 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 345 {
 346         unsigned int err = 0;
 347         unsigned long long current_sr, new_sr;
 348 #define SR_MASK 0xffff8cfd
 349
 350 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 351
 352         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 353         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 354         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 355         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 356         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 357         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 358         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 359         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 360         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 361         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 362         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 363         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 364         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 365         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 366         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 367         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 368         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 369         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 370
 371         /* Prevent the signal handler manipulating SR in a way that can
 372            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 373            modified */
 374         current_sr = regs->sr;
 375         err |= __get_user(new_sr, &sc->sc_sr);
 376         regs->sr &= SR_MASK;
 377         regs->sr |= (new_sr & ~SR_MASK);
 378
 379         COPY(pc);
 380
 381 #undef COPY
 382
 383         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 384          * has been restored above.) */
 385         err |= restore_sigcontext_fpu(regs, sc);
 386
 387         regs->syscall_nr = -1;          /* disable syscall checks */
 388         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 389         return err;
 390 }
 391
 392 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 393                                    unsigned long r4, unsigned long r5,
 394                                    unsigned long r6, unsigned long r7,
 395                                    struct pt_regs * regs)
 396 {
 397         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 398         sigset_t set;
 399         long long ret;
 400
 401         /* Always make any pending restarted system calls return -EINTR */
 402         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 403
 404         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 405                 goto badframe;
 406
 407         if (__get_user(set.sig[0], &frame->sc.oldmask)
 408             || (_NSIG_WORDS > 1
 409                 && __copy_from_user(&set.sig[1], &frame->extramask,
 410                                     sizeof(frame->extramask))))
 411                 goto badframe;
 412
 413         sigdelsetmask(&set, ~_BLOCKABLE);
 414
 415         spin_lock_irq(&current->sighand->siglock);
 416         current->blocked = set;
 417         recalc_sigpending();
 418         spin_unlock_irq(&current->sighand->siglock);
 419
 420         if (restore_sigcontext(regs, &frame->sc, &ret))
 421                 goto badframe;
 422         regs->pc -= 4;
 423
 424         return (int) ret;
 425
 426 badframe:
 427         force_sig(SIGSEGV, current);
 428         return 0;
 429 }
 430
 431 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 432                                 unsigned long r4, unsigned long r5,
 433                                 unsigned long r6, unsigned long r7,
 434                                 struct pt_regs * regs)
 435 {
 436         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 437         sigset_t set;
 438         stack_t __user st;
 439         long long ret;
 440
 441         /* Always make any pending restarted system calls return -EINTR */
 442         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 443
 444         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 445                 goto badframe;
 446
 447         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 448                 goto badframe;
 449
 450         sigdelsetmask(&set, ~_BLOCKABLE);
 451         spin_lock_irq(&current->sighand->siglock);
 452         current->blocked = set;
 453         recalc_sigpending();
 454         spin_unlock_irq(&current->sighand->siglock);
 455
 456         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 457                 goto badframe;
 458         regs->pc -= 4;
 459
 460         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 461                 goto badframe;
 462         /* It is more difficult to avoid calling this function than to
 463            call it and ignore errors.  */
 464         do_sigaltstack(&st, NULL, REF_REG_SP);
 465
 466         return (int) ret;
 467
 468 badframe:
 469         force_sig(SIGSEGV, current);
 470         return 0;
 471 }
 472
 473 /*
 474  * Set up a signal frame.
 475  */
 476 static int
 477 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 478                  unsigned long mask)
 479 {
 480         int err = 0;
 481
 482         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 483         err |= setup_sigcontext_fpu(regs, sc);
 484
 485 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 486
 487         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 488         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 489         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 490         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 491         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 492         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 493         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 494         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 495         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 496         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 497         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 498         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 499         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 500         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 501         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 502         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 503         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 504         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 505         COPY(sr);       COPY(pc);
 506
 507 #undef COPY
 508
 509         err |= __put_user(mask, &sc->oldmask);
 510
 511         return err;
 512 }
 513
 514 /*
 515  * Determine which stack to use..
 516  */
 517 static inline void __user *
 518 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 519 {
 520         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 521                 sp = current->sas_ss_sp + current->sas_ss_size;
 522
 523         return (void __user *)((sp - frame_size) & -8ul);
 524 }
 525
 526 void sa_default_restorer(void);         /* See comments below */
 527 void sa_default_rt_restorer(void);      /* See comments below */
 528
 529 static int setup_frame(int sig, struct k_sigaction *ka,
 530                        sigset_t *set, struct pt_regs *regs)
 531 {
 532         struct sigframe __user *frame;
 533         int err = 0;
 534         int signal;
 535
 536         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 537
 538         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 539                 goto give_sigsegv;
 540
 541         signal = current_thread_info()->exec_domain
 542                 && current_thread_info()->exec_domain->signal_invmap
 543                 && sig < 32
 544                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 545                 : sig;
 546
 547         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 548
 549         /* Give up earlier as i386, in case */
 550         if (err)
 551                 goto give_sigsegv;
 552
 553         if (_NSIG_WORDS > 1) {
 554                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 555                                       sizeof(frame->extramask)); }
 556
 557         /* Give up earlier as i386, in case */
 558         if (err)
 559                 goto give_sigsegv;
 560
 561         /* Set up to return from userspace.  If provided, use a stub
 562            already in userspace.  */
 563         if (ka->sa.sa_flags & SA_RESTORER) {
 564                 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
 565
 566                 /*
 567                  * On SH5 all edited pointers are subject to NEFF
 568                  */
 569                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 570                         (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 571         } else {
 572                 /*
 573                  * Different approach on SH5.
 574                  * . Endianness independent asm code gets placed in entry.S .
 575                  *   This is limited to four ASM instructions corresponding
 576                  *   to two long longs in size.
 577                  * . err checking is done on the else branch only
 578                  * . flush_icache_range() is called upon __put_user() only
 579                  * . all edited pointers are subject to NEFF
 580                  * . being code, linker turns ShMedia bit on, always
 581                  *   dereference index -1.
 582                  */
 583                 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
 584                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 585                         (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 586
 587                 if (__copy_to_user(frame->retcode,
 588                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 589                         goto give_sigsegv;
 590
 591                 /* Cohere the trampoline with the I-cache. */
 592                 flush_cache_sigtramp(DEREF_REG_PR-1);
 593         }
 594
 595         /*
 596          * Set up registers for signal handler.
 597          * All edited pointers are subject to NEFF.
 598          */
 599         regs->regs[REG_SP] = (unsigned long) frame;
 600         regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
 601                  (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
 602         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 603
 604         /* FIXME:
 605            The glibc profiling support for SH-5 needs to be passed a sigcontext
 606            so it can retrieve the PC.  At some point during 2003 the glibc
 607            support was changed to receive the sigcontext through the 2nd
 608            argument, but there are still versions of libc.so in use that use
 609            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 610            through both 2nd and 3rd arguments.
 611         */
 612
 613         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 614         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 615
 616         regs->pc = (unsigned long) ka->sa.sa_handler;
 617         regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
 618
 619         set_fs(USER_DS);
 620
 621         /* Broken %016Lx */
 622         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 623                  signal, current->comm, current->pid, frame,
 624                  regs->pc >> 32, regs->pc & 0xffffffff,
 625                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 626
 627         return 0;
 628
 629 give_sigsegv:
 630         force_sigsegv(sig, current);
 631         return -EFAULT;
 632 }
 633
 634 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 635                           sigset_t *set, struct pt_regs *regs)
 636 {
 637         struct rt_sigframe __user *frame;
 638         int err = 0;
 639         int signal;
 640
 641         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 642
 643         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 644                 goto give_sigsegv;
 645
 646         signal = current_thread_info()->exec_domain
 647                 && current_thread_info()->exec_domain->signal_invmap
 648                 && sig < 32
 649                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 650                 : sig;
 651
 652         err |= __put_user(&frame->info, &frame->pinfo);
 653         err |= __put_user(&frame->uc, &frame->puc);
 654         err |= copy_siginfo_to_user(&frame->info, info);
 655
 656         /* Give up earlier as i386, in case */
 657         if (err)
 658                 goto give_sigsegv;
 659
 660         /* Create the ucontext.  */
 661         err |= __put_user(0, &frame->uc.uc_flags);
 662         err |= __put_user(0, &frame->uc.uc_link);
 663         err |= __put_user((void *)current->sas_ss_sp,
 664                           &frame->uc.uc_stack.ss_sp);
 665         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
 666                           &frame->uc.uc_stack.ss_flags);
 667         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 668         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 669                                 regs, set->sig[0]);
 670         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 671
 672         /* Give up earlier as i386, in case */
 673         if (err)
 674                 goto give_sigsegv;
 675
 676         /* Set up to return from userspace.  If provided, use a stub
 677            already in userspace.  */
 678         if (ka->sa.sa_flags & SA_RESTORER) {
 679                 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
 680
 681                 /*
 682                  * On SH5 all edited pointers are subject to NEFF
 683                  */
 684                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 685                         (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 686         } else {
 687                 /*
 688                  * Different approach on SH5.
 689                  * . Endianness independent asm code gets placed in entry.S .
 690                  *   This is limited to four ASM instructions corresponding
 691                  *   to two long longs in size.
 692                  * . err checking is done on the else branch only
 693                  * . flush_icache_range() is called upon __put_user() only
 694                  * . all edited pointers are subject to NEFF
 695                  * . being code, linker turns ShMedia bit on, always
 696                  *   dereference index -1.
 697                  */
 698
 699                 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
 700                 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
 701                         (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
 702
 703                 if (__copy_to_user(frame->retcode,
 704                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 705                         goto give_sigsegv;
 706
 707                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 708         }
 709
 710         /*
 711          * Set up registers for signal handler.
 712          * All edited pointers are subject to NEFF.
 713          */
 714         regs->regs[REG_SP] = (unsigned long) frame;
 715         regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
 716                  (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
 717         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 718         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 719         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 720         regs->pc = (unsigned long) ka->sa.sa_handler;
 721         regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
 722
 723         set_fs(USER_DS);
 724
 725         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 726                  signal, current->comm, current->pid, frame,
 727                  regs->pc >> 32, regs->pc & 0xffffffff,
 728                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 729
 730         return 0;
 731
 732 give_sigsegv:
 733         force_sigsegv(sig, current);
 734         return -EFAULT;
 735 }
 736
 737 /*
 738  * OK, we're invoking a handler
 739  */
 740 static int
 741 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 742                 sigset_t *oldset, struct pt_regs * regs)
 743 {
 744         int ret;
 745
 746         /* Set up the stack frame */
 747         if (ka->sa.sa_flags & SA_SIGINFO)
 748                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 749         else
 750                 ret = setup_frame(sig, ka, oldset, regs);
 751
 752         if (ka->sa.sa_flags & SA_ONESHOT)
 753                 ka->sa.sa_handler = SIG_DFL;
 754
 755         if (ret == 0) {
 756                 spin_lock_irq(&current->sighand->siglock);
 757                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 758                 if (!(ka->sa.sa_flags & SA_NODEFER))
 759                         sigaddset(&current->blocked,sig);
 760                 recalc_sigpending();
 761                 spin_unlock_irq(&current->sighand->siglock);
 762         }
 763
 764         return ret;
 765 }
 766
 767 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 768 {
 769         if (thread_info_flags & _TIF_SIGPENDING)
 770                 do_signal(regs, 0);
 771
 772         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 773                 clear_thread_flag(TIF_NOTIFY_RESUME);
 774                 tracehook_notify_resume(regs);
 775         }
 776 }