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 (current_thread_info()->status & TS_RESTORE_SIGMASK)
 102                 oldset = &current->saved_sigmask;
 103         else if (!oldset)
 104                 oldset = &current->blocked;
 105
 106         signr = get_signal_to_deliver(&info, &ka, regs, 0);
 107         if (signr > 0) {
 108                 handle_syscall_restart(regs, &ka.sa);
 109
 110                 /* Whee!  Actually deliver the signal.  */
 111                 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
 112                         /*
 113                          * If a signal was successfully delivered, the
 114                          * saved sigmask is in its frame, and we can
 115                          * clear the TS_RESTORE_SIGMASK flag.
 116                          */
 117                         current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
 118
 119                         tracehook_signal_handler(signr, &info, &ka, regs,
 120                                         test_thread_flag(TIF_SINGLESTEP));
 121                         return 1;
 122                 }
 123         }
 124
 125         /* Did we come from a system call? */
 126         if (regs->syscall_nr >= 0) {
 127                 /* Restart the system call - no handlers present */
 128                 switch (regs->regs[REG_RET]) {
 129                 case -ERESTARTNOHAND:
 130                 case -ERESTARTSYS:
 131                 case -ERESTARTNOINTR:
 132                         /* Decode Syscall # */
 133                         regs->regs[REG_RET] = regs->syscall_nr;
 134                         regs->pc -= 4;
 135                         break;
 136
 137                 case -ERESTART_RESTARTBLOCK:
 138                         regs->regs[REG_RET] = __NR_restart_syscall;
 139                         regs->pc -= 4;
 140                         break;
 141                 }
 142         }
 143
 144         /* No signal to deliver -- put the saved sigmask back */
 145         if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
 146                 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
 147                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 148         }
 149
 150         return 0;
 151 }
 152
 153 /*
 154  * Atomically swap in the new signal mask, and wait for a signal.
 155  */
 156 asmlinkage int
 157 sys_sigsuspend(old_sigset_t mask,
 158                unsigned long r3, unsigned long r4, unsigned long r5,
 159                unsigned long r6, unsigned long r7,
 160                struct pt_regs * regs)
 161 {
 162         sigset_t saveset;
 163
 164         mask &= _BLOCKABLE;
 165         spin_lock_irq(&current->sighand->siglock);
 166         saveset = current->blocked;
 167         siginitset(&current->blocked, mask);
 168         recalc_sigpending();
 169         spin_unlock_irq(&current->sighand->siglock);
 170
 171         REF_REG_RET = -EINTR;
 172         while (1) {
 173                 current->state = TASK_INTERRUPTIBLE;
 174                 schedule();
 175                 set_restore_sigmask();
 176                 regs->pc += 4;    /* because sys_sigreturn decrements the pc */
 177                 if (do_signal(regs, &saveset)) {
 178                         /* pc now points at signal handler. Need to decrement
 179                            it because entry.S will increment it. */
 180                         regs->pc -= 4;
 181                         return -EINTR;
 182                 }
 183         }
 184 }
 185
 186 asmlinkage int
 187 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
 188                   unsigned long r4, unsigned long r5, unsigned long r6,
 189                   unsigned long r7,
 190                   struct pt_regs * regs)
 191 {
 192         sigset_t saveset, newset;
 193
 194         /* XXX: Don't preclude handling different sized sigset_t's.  */
 195         if (sigsetsize != sizeof(sigset_t))
 196                 return -EINVAL;
 197
 198         if (copy_from_user(&newset, unewset, sizeof(newset)))
 199                 return -EFAULT;
 200         sigdelsetmask(&newset, ~_BLOCKABLE);
 201         spin_lock_irq(&current->sighand->siglock);
 202         saveset = current->blocked;
 203         current->blocked = newset;
 204         recalc_sigpending();
 205         spin_unlock_irq(&current->sighand->siglock);
 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
 412         spin_lock_irq(&current->sighand->siglock);
 413         current->blocked = set;
 414         recalc_sigpending();
 415         spin_unlock_irq(&current->sighand->siglock);
 416
 417         if (restore_sigcontext(regs, &frame->sc, &ret))
 418                 goto badframe;
 419         regs->pc -= 4;
 420
 421         return (int) ret;
 422
 423 badframe:
 424         force_sig(SIGSEGV, current);
 425         return 0;
 426 }
 427
 428 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 429                                 unsigned long r4, unsigned long r5,
 430                                 unsigned long r6, unsigned long r7,
 431                                 struct pt_regs * regs)
 432 {
 433         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 434         sigset_t set;
 435         stack_t __user st;
 436         long long ret;
 437
 438         /* Always make any pending restarted system calls return -EINTR */
 439         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 440
 441         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 442                 goto badframe;
 443
 444         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 445                 goto badframe;
 446
 447         sigdelsetmask(&set, ~_BLOCKABLE);
 448         spin_lock_irq(&current->sighand->siglock);
 449         current->blocked = set;
 450         recalc_sigpending();
 451         spin_unlock_irq(&current->sighand->siglock);
 452
 453         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 454                 goto badframe;
 455         regs->pc -= 4;
 456
 457         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 458                 goto badframe;
 459         /* It is more difficult to avoid calling this function than to
 460            call it and ignore errors.  */
 461         do_sigaltstack(&st, NULL, REF_REG_SP);
 462
 463         return (int) ret;
 464
 465 badframe:
 466         force_sig(SIGSEGV, current);
 467         return 0;
 468 }
 469
 470 /*
 471  * Set up a signal frame.
 472  */
 473 static int
 474 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 475                  unsigned long mask)
 476 {
 477         int err = 0;
 478
 479         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 480         err |= setup_sigcontext_fpu(regs, sc);
 481
 482 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 483
 484         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 485         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 486         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 487         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 488         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 489         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 490         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 491         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 492         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 493         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 494         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 495         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 496         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 497         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 498         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 499         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 500         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 501         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 502         COPY(sr);       COPY(pc);
 503
 504 #undef COPY
 505
 506         err |= __put_user(mask, &sc->oldmask);
 507
 508         return err;
 509 }
 510
 511 /*
 512  * Determine which stack to use..
 513  */
 514 static inline void __user *
 515 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 516 {
 517         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 518                 sp = current->sas_ss_sp + current->sas_ss_size;
 519
 520         return (void __user *)((sp - frame_size) & -8ul);
 521 }
 522
 523 void sa_default_restorer(void);         /* See comments below */
 524 void sa_default_rt_restorer(void);      /* See comments below */
 525
 526 static int setup_frame(int sig, struct k_sigaction *ka,
 527                        sigset_t *set, struct pt_regs *regs)
 528 {
 529         struct sigframe __user *frame;
 530         int err = 0;
 531         int signal;
 532
 533         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 534
 535         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 536                 goto give_sigsegv;
 537
 538         signal = current_thread_info()->exec_domain
 539                 && current_thread_info()->exec_domain->signal_invmap
 540                 && sig < 32
 541                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 542                 : sig;
 543
 544         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 545
 546         /* Give up earlier as i386, in case */
 547         if (err)
 548                 goto give_sigsegv;
 549
 550         if (_NSIG_WORDS > 1) {
 551                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 552                                       sizeof(frame->extramask)); }
 553
 554         /* Give up earlier as i386, in case */
 555         if (err)
 556                 goto give_sigsegv;
 557
 558         /* Set up to return from userspace.  If provided, use a stub
 559            already in userspace.  */
 560         if (ka->sa.sa_flags & SA_RESTORER) {
 561                 /*
 562                  * On SH5 all edited pointers are subject to NEFF
 563                  */
 564                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 565                         ka->sa.sa_restorer | 0x1);
 566         } else {
 567                 /*
 568                  * Different approach on SH5.
 569                  * . Endianness independent asm code gets placed in entry.S .
 570                  *   This is limited to four ASM instructions corresponding
 571                  *   to two long longs in size.
 572                  * . err checking is done on the else branch only
 573                  * . flush_icache_range() is called upon __put_user() only
 574                  * . all edited pointers are subject to NEFF
 575                  * . being code, linker turns ShMedia bit on, always
 576                  *   dereference index -1.
 577                  */
 578                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 579                         frame->retcode | 0x01);
 580
 581                 if (__copy_to_user(frame->retcode,
 582                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 583                         goto give_sigsegv;
 584
 585                 /* Cohere the trampoline with the I-cache. */
 586                 flush_cache_sigtramp(DEREF_REG_PR-1);
 587         }
 588
 589         /*
 590          * Set up registers for signal handler.
 591          * All edited pointers are subject to NEFF.
 592          */
 593         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 594         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 595
 596         /* FIXME:
 597            The glibc profiling support for SH-5 needs to be passed a sigcontext
 598            so it can retrieve the PC.  At some point during 2003 the glibc
 599            support was changed to receive the sigcontext through the 2nd
 600            argument, but there are still versions of libc.so in use that use
 601            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 602            through both 2nd and 3rd arguments.
 603         */
 604
 605         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 606         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 607
 608         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 609
 610         set_fs(USER_DS);
 611
 612         /* Broken %016Lx */
 613         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 614                  signal, current->comm, current->pid, frame,
 615                  regs->pc >> 32, regs->pc & 0xffffffff,
 616                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 617
 618         return 0;
 619
 620 give_sigsegv:
 621         force_sigsegv(sig, current);
 622         return -EFAULT;
 623 }
 624
 625 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 626                           sigset_t *set, struct pt_regs *regs)
 627 {
 628         struct rt_sigframe __user *frame;
 629         int err = 0;
 630         int signal;
 631
 632         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 633
 634         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 635                 goto give_sigsegv;
 636
 637         signal = current_thread_info()->exec_domain
 638                 && current_thread_info()->exec_domain->signal_invmap
 639                 && sig < 32
 640                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 641                 : sig;
 642
 643         err |= __put_user(&frame->info, &frame->pinfo);
 644         err |= __put_user(&frame->uc, &frame->puc);
 645         err |= copy_siginfo_to_user(&frame->info, info);
 646
 647         /* Give up earlier as i386, in case */
 648         if (err)
 649                 goto give_sigsegv;
 650
 651         /* Create the ucontext.  */
 652         err |= __put_user(0, &frame->uc.uc_flags);
 653         err |= __put_user(0, &frame->uc.uc_link);
 654         err |= __put_user((void *)current->sas_ss_sp,
 655                           &frame->uc.uc_stack.ss_sp);
 656         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
 657                           &frame->uc.uc_stack.ss_flags);
 658         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 659         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 660                                 regs, set->sig[0]);
 661         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 662
 663         /* Give up earlier as i386, in case */
 664         if (err)
 665                 goto give_sigsegv;
 666
 667         /* Set up to return from userspace.  If provided, use a stub
 668            already in userspace.  */
 669         if (ka->sa.sa_flags & SA_RESTORER) {
 670                 /*
 671                  * On SH5 all edited pointers are subject to NEFF
 672                  */
 673                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 674                         ka->sa.sa_restorer | 0x1);
 675         } else {
 676                 /*
 677                  * Different approach on SH5.
 678                  * . Endianness independent asm code gets placed in entry.S .
 679                  *   This is limited to four ASM instructions corresponding
 680                  *   to two long longs in size.
 681                  * . err checking is done on the else branch only
 682                  * . flush_icache_range() is called upon __put_user() only
 683                  * . all edited pointers are subject to NEFF
 684                  * . being code, linker turns ShMedia bit on, always
 685                  *   dereference index -1.
 686                  */
 687                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 688                         frame->retcode | 0x01);
 689
 690                 if (__copy_to_user(frame->retcode,
 691                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 692                         goto give_sigsegv;
 693
 694                 /* Cohere the trampoline with the I-cache. */
 695                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 696         }
 697
 698         /*
 699          * Set up registers for signal handler.
 700          * All edited pointers are subject to NEFF.
 701          */
 702         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 703         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 704         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 705         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 706         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 707
 708         set_fs(USER_DS);
 709
 710         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 711                  signal, current->comm, current->pid, frame,
 712                  regs->pc >> 32, regs->pc & 0xffffffff,
 713                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 714
 715         return 0;
 716
 717 give_sigsegv:
 718         force_sigsegv(sig, current);
 719         return -EFAULT;
 720 }
 721
 722 /*
 723  * OK, we're invoking a handler
 724  */
 725 static int
 726 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 727                 sigset_t *oldset, struct pt_regs * regs)
 728 {
 729         int ret;
 730
 731         /* Set up the stack frame */
 732         if (ka->sa.sa_flags & SA_SIGINFO)
 733                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 734         else
 735                 ret = setup_frame(sig, ka, oldset, regs);
 736
 737         if (ka->sa.sa_flags & SA_ONESHOT)
 738                 ka->sa.sa_handler = SIG_DFL;
 739
 740         if (ret == 0) {
 741                 spin_lock_irq(&current->sighand->siglock);
 742                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 743                 if (!(ka->sa.sa_flags & SA_NODEFER))
 744                         sigaddset(&current->blocked,sig);
 745                 recalc_sigpending();
 746                 spin_unlock_irq(&current->sighand->siglock);
 747         }
 748
 749         return ret;
 750 }
 751
 752 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 753 {
 754         if (thread_info_flags & _TIF_SIGPENDING)
 755                 do_signal(regs, 0);
 756
 757         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 758                 clear_thread_flag(TIF_NOTIFY_RESUME);
 759                 tracehook_notify_resume(regs);
 760                 if (current->replacement_session_keyring)
 761                         key_replace_session_keyring();
 762         }
 763 }