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