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                 /*
 565                  * On SH5 all edited pointers are subject to NEFF
 566                  */
 567                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 568                         ka->sa.sa_restorer | 0x1);
 569         } else {
 570                 /*
 571                  * Different approach on SH5.
 572                  * . Endianness independent asm code gets placed in entry.S .
 573                  *   This is limited to four ASM instructions corresponding
 574                  *   to two long longs in size.
 575                  * . err checking is done on the else branch only
 576                  * . flush_icache_range() is called upon __put_user() only
 577                  * . all edited pointers are subject to NEFF
 578                  * . being code, linker turns ShMedia bit on, always
 579                  *   dereference index -1.
 580                  */
 581                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 582                         frame->retcode | 0x01);
 583
 584                 if (__copy_to_user(frame->retcode,
 585                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 586                         goto give_sigsegv;
 587
 588                 /* Cohere the trampoline with the I-cache. */
 589                 flush_cache_sigtramp(DEREF_REG_PR-1);
 590         }
 591
 592         /*
 593          * Set up registers for signal handler.
 594          * All edited pointers are subject to NEFF.
 595          */
 596         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 597         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 598
 599         /* FIXME:
 600            The glibc profiling support for SH-5 needs to be passed a sigcontext
 601            so it can retrieve the PC.  At some point during 2003 the glibc
 602            support was changed to receive the sigcontext through the 2nd
 603            argument, but there are still versions of libc.so in use that use
 604            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 605            through both 2nd and 3rd arguments.
 606         */
 607
 608         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 609         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 610
 611         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 612
 613         set_fs(USER_DS);
 614
 615         /* Broken %016Lx */
 616         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 617                  signal, current->comm, current->pid, frame,
 618                  regs->pc >> 32, regs->pc & 0xffffffff,
 619                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 620
 621         return 0;
 622
 623 give_sigsegv:
 624         force_sigsegv(sig, current);
 625         return -EFAULT;
 626 }
 627
 628 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 629                           sigset_t *set, struct pt_regs *regs)
 630 {
 631         struct rt_sigframe __user *frame;
 632         int err = 0;
 633         int signal;
 634
 635         frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
 636
 637         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 638                 goto give_sigsegv;
 639
 640         signal = current_thread_info()->exec_domain
 641                 && current_thread_info()->exec_domain->signal_invmap
 642                 && sig < 32
 643                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 644                 : sig;
 645
 646         err |= __put_user(&frame->info, &frame->pinfo);
 647         err |= __put_user(&frame->uc, &frame->puc);
 648         err |= copy_siginfo_to_user(&frame->info, info);
 649
 650         /* Give up earlier as i386, in case */
 651         if (err)
 652                 goto give_sigsegv;
 653
 654         /* Create the ucontext.  */
 655         err |= __put_user(0, &frame->uc.uc_flags);
 656         err |= __put_user(0, &frame->uc.uc_link);
 657         err |= __put_user((void *)current->sas_ss_sp,
 658                           &frame->uc.uc_stack.ss_sp);
 659         err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
 660                           &frame->uc.uc_stack.ss_flags);
 661         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 662         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 663                                 regs, set->sig[0]);
 664         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 665
 666         /* Give up earlier as i386, in case */
 667         if (err)
 668                 goto give_sigsegv;
 669
 670         /* Set up to return from userspace.  If provided, use a stub
 671            already in userspace.  */
 672         if (ka->sa.sa_flags & SA_RESTORER) {
 673                 /*
 674                  * On SH5 all edited pointers are subject to NEFF
 675                  */
 676                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 677                         ka->sa.sa_restorer | 0x1);
 678         } else {
 679                 /*
 680                  * Different approach on SH5.
 681                  * . Endianness independent asm code gets placed in entry.S .
 682                  *   This is limited to four ASM instructions corresponding
 683                  *   to two long longs in size.
 684                  * . err checking is done on the else branch only
 685                  * . flush_icache_range() is called upon __put_user() only
 686                  * . all edited pointers are subject to NEFF
 687                  * . being code, linker turns ShMedia bit on, always
 688                  *   dereference index -1.
 689                  */
 690                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 691                         frame->retcode | 0x01);
 692
 693                 if (__copy_to_user(frame->retcode,
 694                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 695                         goto give_sigsegv;
 696
 697                 /* Cohere the trampoline with the I-cache. */
 698                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 699         }
 700
 701         /*
 702          * Set up registers for signal handler.
 703          * All edited pointers are subject to NEFF.
 704          */
 705         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 706         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 707         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 708         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 709         regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
 710
 711         set_fs(USER_DS);
 712
 713         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 714                  signal, current->comm, current->pid, frame,
 715                  regs->pc >> 32, regs->pc & 0xffffffff,
 716                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 717
 718         return 0;
 719
 720 give_sigsegv:
 721         force_sigsegv(sig, current);
 722         return -EFAULT;
 723 }
 724
 725 /*
 726  * OK, we're invoking a handler
 727  */
 728 static int
 729 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 730                 sigset_t *oldset, struct pt_regs * regs)
 731 {
 732         int ret;
 733
 734         /* Set up the stack frame */
 735         if (ka->sa.sa_flags & SA_SIGINFO)
 736                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 737         else
 738                 ret = setup_frame(sig, ka, oldset, regs);
 739
 740         if (ka->sa.sa_flags & SA_ONESHOT)
 741                 ka->sa.sa_handler = SIG_DFL;
 742
 743         if (ret == 0) {
 744                 spin_lock_irq(&current->sighand->siglock);
 745                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 746                 if (!(ka->sa.sa_flags & SA_NODEFER))
 747                         sigaddset(&current->blocked,sig);
 748                 recalc_sigpending();
 749                 spin_unlock_irq(&current->sighand->siglock);
 750         }
 751
 752         return ret;
 753 }
 754
 755 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 756 {
 757         if (thread_info_flags & _TIF_SIGPENDING)
 758                 do_signal(regs, 0);
 759
 760         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 761                 clear_thread_flag(TIF_NOTIFY_RESUME);
 762                 tracehook_notify_resume(regs);
 763                 if (current->replacement_session_keyring)
 764                         key_replace_session_keyring();
 765         }
 766 }