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 (current_thread_info()->status & TS_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 TS_RESTORE_SIGMASK flag.
 119                          */
 120                         current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
 121
 122                         tracehook_signal_handler(signr, &info, &ka, regs,
 123                                         test_thread_flag(TIF_SINGLESTEP));
 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 (current_thread_info()->status & TS_RESTORE_SIGMASK) {
 150                 current_thread_info()->status &= ~TS_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, blocked;
 167
 168         saveset = current->blocked;
 169
 170         mask &= _BLOCKABLE;
 171         siginitset(&blocked, mask);
 172         set_current_blocked(&blocked);
 173
 174         REF_REG_RET = -EINTR;
 175         while (1) {
 176                 current->state = TASK_INTERRUPTIBLE;
 177                 schedule();
 178                 set_restore_sigmask();
 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         saveset = current->blocked;
 205         set_current_blocked(&newset);
 206
 207         REF_REG_RET = -EINTR;
 208         while (1) {
 209                 current->state = TASK_INTERRUPTIBLE;
 210                 schedule();
 211                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 212                 if (do_signal(regs, &saveset)) {
 213                         /* pc now points at signal handler. Need to decrement
 214                            it because entry.S will increment it. */
 215                         regs->pc -= 4;
 216                         return -EINTR;
 217                 }
 218         }
 219 }
 220
 221 asmlinkage int
 222 sys_sigaction(int sig, const struct old_sigaction __user *act,
 223               struct old_sigaction __user *oact)
 224 {
 225         struct k_sigaction new_ka, old_ka;
 226         int ret;
 227
 228         if (act) {
 229                 old_sigset_t mask;
 230                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 231                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 232                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 233                         return -EFAULT;
 234                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 235                 __get_user(mask, &act->sa_mask);
 236                 siginitset(&new_ka.sa.sa_mask, mask);
 237         }
 238
 239         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 240
 241         if (!ret && oact) {
 242                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 243                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 244                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 245                         return -EFAULT;
 246                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 247                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 248         }
 249
 250         return ret;
 251 }
 252
 253 asmlinkage int
 254 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 255                 unsigned long r4, unsigned long r5, unsigned long r6,
 256                 unsigned long r7,
 257                 struct pt_regs * regs)
 258 {
 259         return do_sigaltstack(uss, uoss, REF_REG_SP);
 260 }
 261
 262 /*
 263  * Do a signal return; undo the signal stack.
 264  */
 265 struct sigframe {
 266         struct sigcontext sc;
 267         unsigned long extramask[_NSIG_WORDS-1];
 268         long long retcode[2];
 269 };
 270
 271 struct rt_sigframe {
 272         struct siginfo __user *pinfo;
 273         void *puc;
 274         struct siginfo info;
 275         struct ucontext uc;
 276         long long retcode[2];
 277 };
 278
 279 #ifdef CONFIG_SH_FPU
 280 static inline int
 281 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 282 {
 283         int err = 0;
 284         int fpvalid;
 285
 286         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 287         conditional_used_math(fpvalid);
 288         if (! fpvalid)
 289                 return err;
 290
 291         if (current == last_task_used_math) {
 292                 last_task_used_math = NULL;
 293                 regs->sr |= SR_FD;
 294         }
 295
 296         err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
 297                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 298
 299         return err;
 300 }
 301
 302 static inline int
 303 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 304 {
 305         int err = 0;
 306         int fpvalid;
 307
 308         fpvalid = !!used_math();
 309         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 310         if (! fpvalid)
 311                 return err;
 312
 313         if (current == last_task_used_math) {
 314                 enable_fpu();
 315                 save_fpu(current);
 316                 disable_fpu();
 317                 last_task_used_math = NULL;
 318                 regs->sr |= SR_FD;
 319         }
 320
 321         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
 322                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 323         clear_used_math();
 324
 325         return err;
 326 }
 327 #else
 328 static inline int
 329 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 330 {
 331         return 0;
 332 }
 333 static inline int
 334 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 335 {
 336         return 0;
 337 }
 338 #endif
 339
 340 static int
 341 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 342 {
 343         unsigned int err = 0;
 344         unsigned long long current_sr, new_sr;
 345 #define SR_MASK 0xffff8cfd
 346
 347 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 348
 349         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 350         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 351         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 352         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 353         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 354         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 355         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 356         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 357         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 358         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 359         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 360         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 361         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 362         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 363         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 364         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 365         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 366         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 367
 368         /* Prevent the signal handler manipulating SR in a way that can
 369            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 370            modified */
 371         current_sr = regs->sr;
 372         err |= __get_user(new_sr, &sc->sc_sr);
 373         regs->sr &= SR_MASK;
 374         regs->sr |= (new_sr & ~SR_MASK);
 375
 376         COPY(pc);
 377
 378 #undef COPY
 379
 380         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 381          * has been restored above.) */
 382         err |= restore_sigcontext_fpu(regs, sc);
 383
 384         regs->syscall_nr = -1;          /* disable syscall checks */
 385         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 386         return err;
 387 }
 388
 389 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 390                                    unsigned long r4, unsigned long r5,
 391                                    unsigned long r6, unsigned long r7,
 392                                    struct pt_regs * regs)
 393 {
 394         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 395         sigset_t set;
 396         long long ret;
 397
 398         /* Always make any pending restarted system calls return -EINTR */
 399         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 400
 401         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 402                 goto badframe;
 403
 404         if (__get_user(set.sig[0], &frame->sc.oldmask)
 405             || (_NSIG_WORDS > 1
 406                 && __copy_from_user(&set.sig[1], &frame->extramask,
 407                                     sizeof(frame->extramask))))
 408                 goto badframe;
 409
 410         sigdelsetmask(&set, ~_BLOCKABLE);
 411         set_current_blocked(&set);
 412
 413         if (restore_sigcontext(regs, &frame->sc, &ret))
 414                 goto badframe;
 415         regs->pc -= 4;
 416
 417         return (int) ret;
 418
 419 badframe:
 420         force_sig(SIGSEGV, current);
 421         return 0;
 422 }
 423
 424 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 425                                 unsigned long r4, unsigned long r5,
 426                                 unsigned long r6, unsigned long r7,
 427                                 struct pt_regs * regs)
 428 {
 429         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 430         sigset_t set;
 431         stack_t __user st;
 432         long long ret;
 433
 434         /* Always make any pending restarted system calls return -EINTR */
 435         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 436
 437         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 438                 goto badframe;
 439
 440         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 441                 goto badframe;
 442
 443         sigdelsetmask(&set, ~_BLOCKABLE);
 444         set_current_blocked(&set);
 445
 446         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 447                 goto badframe;
 448         regs->pc -= 4;
 449
 450         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 451                 goto badframe;
 452         /* It is more difficult to avoid calling this function than to
 453            call it and ignore errors.  */
 454         do_sigaltstack(&st, NULL, REF_REG_SP);
 455
 456         return (int) ret;
 457
 458 badframe:
 459         force_sig(SIGSEGV, current);
 460         return 0;
 461 }
 462
 463 /*
 464  * Set up a signal frame.
 465  */
 466 static int
 467 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 468                  unsigned long mask)
 469 {
 470         int err = 0;
 471
 472         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 473         err |= setup_sigcontext_fpu(regs, sc);
 474
 475 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 476
 477         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 478         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 479         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 480         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 481         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 482         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 483         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 484         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 485         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 486         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 487         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 488         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 489         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 490         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 491         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 492         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 493         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 494         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 495         COPY(sr);       COPY(pc);
 496
 497 #undef COPY
 498
 499         err |= __put_user(mask, &sc->oldmask);
 500
 501         return err;
 502 }
 503
 504 /*
 505  * Determine which stack to use..
 506  */
 507 static inline void __user *
 508 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 509 {
 510         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 511                 sp = current->sas_ss_sp + current->sas_ss_size;
 512
 513         return (void __user *)((sp - frame_size) & -8ul);
 514 }
 515
 516 void sa_default_restorer(void);         /* See comments below */
 517 void sa_default_rt_restorer(void);      /* See comments below */
 518
 519 static int setup_frame(int sig, struct k_sigaction *ka,
 520                        sigset_t *set, struct pt_regs *regs)
 521 {
 522         struct sigframe __user *frame;
 523         int err = 0;
 524         int signal;
 525
 526         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 527
 528         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 529                 goto give_sigsegv;
 530
 531         signal = current_thread_info()->exec_domain
 532                 && current_thread_info()->exec_domain->signal_invmap
 533                 && sig < 32
 534                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 535                 : sig;
 536
 537         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 538
 539         /* Give up earlier as i386, in case */
 540         if (err)
 541                 goto give_sigsegv;
 542
 543         if (_NSIG_WORDS > 1) {
 544                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 545                                       sizeof(frame->extramask)); }
 546
 547         /* Give up earlier as i386, in case */
 548         if (err)
 549                 goto give_sigsegv;
 550
 551         /* Set up to return from userspace.  If provided, use a stub
 552            already in userspace.  */
 553         if (ka->sa.sa_flags & SA_RESTORER) {
 554                 /*
 555                  * On SH5 all edited pointers are subject to NEFF
 556                  */
 557                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 558                         ka->sa.sa_restorer | 0x1);
 559         } else {
 560                 /*
 561                  * Different approach on SH5.
 562                  * . Endianness independent asm code gets placed in entry.S .
 563                  *   This is limited to four ASM instructions corresponding
 564                  *   to two long longs in size.
 565                  * . err checking is done on the else branch only
 566                  * . flush_icache_range() is called upon __put_user() only
 567                  * . all edited pointers are subject to NEFF
 568                  * . being code, linker turns ShMedia bit on, always
 569                  *   dereference index -1.
 570                  */
 571                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 572                         frame->retcode | 0x01);
 573
 574                 if (__copy_to_user(frame->retcode,
 575                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 576                         goto give_sigsegv;
 577
 578                 /* Cohere the trampoline with the I-cache. */
 579                 flush_cache_sigtramp(DEREF_REG_PR-1);
 580         }
 581
 582         /*
 583          * Set up registers for signal handler.
 584          * All edited pointers are subject to NEFF.
 585          */
 586         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 587         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 588
 589         /* FIXME:
 590            The glibc profiling support for SH-5 needs to be passed a sigcontext
 591            so it can retrieve the PC.  At some point during 2003 the glibc
 592            support was changed to receive the sigcontext through the 2nd
 593            argument, but there are still versions of libc.so in use that use
 594            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 595            through both 2nd and 3rd arguments.
 596         */
 597
 598         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 599         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 600
 601         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 602
 603         set_fs(USER_DS);
 604
 605         /* Broken %016Lx */
 606         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 607                  signal, current->comm, current->pid, frame,
 608                  regs->pc >> 32, regs->pc & 0xffffffff,
 609                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 610
 611         return 0;
 612
 613 give_sigsegv:
 614         force_sigsegv(sig, current);
 615         return -EFAULT;
 616 }
 617
 618 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 619                           sigset_t *set, struct pt_regs *regs)
 620 {
 621         struct rt_sigframe __user *frame;
 622         int err = 0;
 623         int signal;
 624
 625         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 626
 627         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 628                 goto give_sigsegv;
 629
 630         signal = current_thread_info()->exec_domain
 631                 && current_thread_info()->exec_domain->signal_invmap
 632                 && sig < 32
 633                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 634                 : sig;
 635
 636         err |= __put_user(&frame->info, &frame->pinfo);
 637         err |= __put_user(&frame->uc, &frame->puc);
 638         err |= copy_siginfo_to_user(&frame->info, info);
 639
 640         /* Give up earlier as i386, in case */
 641         if (err)
 642                 goto give_sigsegv;
 643
 644         /* Create the ucontext.  */
 645         err |= __put_user(0, &frame->uc.uc_flags);
 646         err |= __put_user(0, &frame->uc.uc_link);
 647         err |= __put_user((void *)current->sas_ss_sp,
 648                           &frame->uc.uc_stack.ss_sp);
 649         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
 650                           &frame->uc.uc_stack.ss_flags);
 651         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 652         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 653                                 regs, set->sig[0]);
 654         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 655
 656         /* Give up earlier as i386, in case */
 657         if (err)
 658                 goto give_sigsegv;
 659
 660         /* Set up to return from userspace.  If provided, use a stub
 661            already in userspace.  */
 662         if (ka->sa.sa_flags & SA_RESTORER) {
 663                 /*
 664                  * On SH5 all edited pointers are subject to NEFF
 665                  */
 666                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 667                         ka->sa.sa_restorer | 0x1);
 668         } else {
 669                 /*
 670                  * Different approach on SH5.
 671                  * . Endianness independent asm code gets placed in entry.S .
 672                  *   This is limited to four ASM instructions corresponding
 673                  *   to two long longs in size.
 674                  * . err checking is done on the else branch only
 675                  * . flush_icache_range() is called upon __put_user() only
 676                  * . all edited pointers are subject to NEFF
 677                  * . being code, linker turns ShMedia bit on, always
 678                  *   dereference index -1.
 679                  */
 680                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 681                         frame->retcode | 0x01);
 682
 683                 if (__copy_to_user(frame->retcode,
 684                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 685                         goto give_sigsegv;
 686
 687                 /* Cohere the trampoline with the I-cache. */
 688                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 689         }
 690
 691         /*
 692          * Set up registers for signal handler.
 693          * All edited pointers are subject to NEFF.
 694          */
 695         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 696         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 697         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 698         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 699         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 700
 701         set_fs(USER_DS);
 702
 703         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 704                  signal, current->comm, current->pid, frame,
 705                  regs->pc >> 32, regs->pc & 0xffffffff,
 706                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 707
 708         return 0;
 709
 710 give_sigsegv:
 711         force_sigsegv(sig, current);
 712         return -EFAULT;
 713 }
 714
 715 /*
 716  * OK, we're invoking a handler
 717  */
 718 static int
 719 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 720                 sigset_t *oldset, struct pt_regs * regs)
 721 {
 722         int ret;
 723
 724         /* Set up the stack frame */
 725         if (ka->sa.sa_flags & SA_SIGINFO)
 726                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 727         else
 728                 ret = setup_frame(sig, ka, oldset, regs);
 729
 730         if (ret == 0)
 731                 block_sigmask(ka, sig);
 732
 733         return ret;
 734 }
 735
 736 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 737 {
 738         if (thread_info_flags & _TIF_SIGPENDING)
 739                 do_signal(regs, 0);
 740
 741         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 742                 clear_thread_flag(TIF_NOTIFY_RESUME);
 743                 tracehook_notify_resume(regs);
 744                 if (current->replacement_session_keyring)
 745                         key_replace_session_keyring();
 746         }
 747 }