LXR linux/arch/sh/kernel/signal

   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/ptrace.h>
  22#include <linux/unistd.h>
  23#include <linux/stddef.h>
  24#include <linux/tracehook.h>
  25#include <asm/ucontext.h>
  26#include <asm/uaccess.h>
  27#include <asm/pgtable.h>
  28#include <asm/cacheflush.h>
  29#include <asm/fpu.h>
  30
  31#define REG_RET 9
  32#define REG_ARG1 2
  33#define REG_ARG2 3
  34#define REG_ARG3 4
  35#define REG_SP 15
  36#define REG_PR 18
  37#define REF_REG_RET regs->regs[REG_RET]
  38#define REF_REG_SP regs->regs[REG_SP]
  39#define DEREF_REG_PR regs->regs[REG_PR]
  40
  41#define DEBUG_SIG 0
  42
  43static void
  44handle_signal(struct ksignal *ksig, struct pt_regs *regs);
  45
  46static inline void
  47handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
  48{
  49        /* If we're not from a syscall, bail out */
  50        if (regs->syscall_nr < 0)
  51                return;
  52
  53        /* check for system call restart.. */
  54        switch (regs->regs[REG_RET]) {
  55                case -ERESTART_RESTARTBLOCK:
  56                case -ERESTARTNOHAND:
  57                no_system_call_restart:
  58                        regs->regs[REG_RET] = -EINTR;
  59                        break;
  60
  61                case -ERESTARTSYS:
  62                        if (!(sa->sa_flags & SA_RESTART))
  63                                goto no_system_call_restart;
  64                /* fallthrough */
  65                case -ERESTARTNOINTR:
  66                        /* Decode syscall # */
  67                        regs->regs[REG_RET] = regs->syscall_nr;
  68                        regs->pc -= 4;
  69                        break;
  70        }
  71}
  72
  73/*
  74 * Note that 'init' is a special process: it doesn't get signals it doesn't
  75 * want to handle. Thus you cannot kill init even with a SIGKILL even by
  76 * mistake.
  77 *
  78 * Note that we go through the signals twice: once to check the signals that
  79 * the kernel can handle, and then we build all the user-level signal handling
  80 * stack-frames in one go after that.
  81 */
  82static void do_signal(struct pt_regs *regs)
  83{
  84        struct ksignal ksig;
  85
  86        /*
  87         * We want the common case to go fast, which
  88         * is why we may in certain cases get here from
  89         * kernel mode. Just return without doing anything
  90         * if so.
  91         */
  92        if (!user_mode(regs))
  93                return;
  94
  95        if (get_signal(&ksig)) {
  96                handle_syscall_restart(regs, &ksig.ka.sa);
  97
  98                /* Whee!  Actually deliver the signal.  */
  99                handle_signal(&ksig, regs);
 100                return;
 101        }
 102
 103        /* Did we come from a system call? */
 104        if (regs->syscall_nr >= 0) {
 105                /* Restart the system call - no handlers present */
 106                switch (regs->regs[REG_RET]) {
 107                case -ERESTARTNOHAND:
 108                case -ERESTARTSYS:
 109                case -ERESTARTNOINTR:
 110                        /* Decode Syscall # */
 111                        regs->regs[REG_RET] = regs->syscall_nr;
 112                        regs->pc -= 4;
 113                        break;
 114
 115                case -ERESTART_RESTARTBLOCK:
 116                        regs->regs[REG_RET] = __NR_restart_syscall;
 117                        regs->pc -= 4;
 118                        break;
 119                }
 120        }
 121
 122        /* No signal to deliver -- put the saved sigmask back */
 123        restore_saved_sigmask();
 124}
 125
 126/*
 127 * Do a signal return; undo the signal stack.
 128 */
 129struct sigframe {
 130        struct sigcontext sc;
 131        unsigned long extramask[_NSIG_WORDS-1];
 132        long long retcode[2];
 133};
 134
 135struct rt_sigframe {
 136        struct siginfo __user *pinfo;
 137        void *puc;
 138        struct siginfo info;
 139        struct ucontext uc;
 140        long long retcode[2];
 141};
 142
 143#ifdef CONFIG_SH_FPU
 144static inline int
 145restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 146{
 147        int err = 0;
 148        int fpvalid;
 149
 150        err |= __get_user (fpvalid, &sc->sc_fpvalid);
 151        conditional_used_math(fpvalid);
 152        if (! fpvalid)
 153                return err;
 154
 155        if (current == last_task_used_math) {
 156                last_task_used_math = NULL;
 157                regs->sr |= SR_FD;
 158        }
 159
 160        err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
 161                                (sizeof(long long) * 32) + (sizeof(int) * 1));
 162
 163        return err;
 164}
 165
 166static inline int
 167setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 168{
 169        int err = 0;
 170        int fpvalid;
 171
 172        fpvalid = !!used_math();
 173        err |= __put_user(fpvalid, &sc->sc_fpvalid);
 174        if (! fpvalid)
 175                return err;
 176
 177        if (current == last_task_used_math) {
 178                enable_fpu();
 179                save_fpu(current);
 180                disable_fpu();
 181                last_task_used_math = NULL;
 182                regs->sr |= SR_FD;
 183        }
 184
 185        err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
 186                              (sizeof(long long) * 32) + (sizeof(int) * 1));
 187        clear_used_math();
 188
 189        return err;
 190}
 191#else
 192static inline int
 193restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 194{
 195        return 0;
 196}
 197static inline int
 198setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 199{
 200        return 0;
 201}
 202#endif
 203
 204static int
 205restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 206{
 207        unsigned int err = 0;
 208        unsigned long long current_sr, new_sr;
 209#define SR_MASK 0xffff8cfd
 210
 211#define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 212
 213        COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 214        COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 215        COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 216        COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 217        COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 218        COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 219        COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 220        COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 221        COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 222        COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 223        COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 224        COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 225        COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 226        COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 227        COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 228        COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 229        COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 230        COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 231
 232        /* Prevent the signal handler manipulating SR in a way that can
 233           crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 234           modified */
 235        current_sr = regs->sr;
 236        err |= __get_user(new_sr, &sc->sc_sr);
 237        regs->sr &= SR_MASK;
 238        regs->sr |= (new_sr & ~SR_MASK);
 239
 240        COPY(pc);
 241
 242#undef COPY
 243
 244        /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 245         * has been restored above.) */
 246        err |= restore_sigcontext_fpu(regs, sc);
 247
 248        regs->syscall_nr = -1;          /* disable syscall checks */
 249        err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 250        return err;
 251}
 252
 253asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 254                                   unsigned long r4, unsigned long r5,
 255                                   unsigned long r6, unsigned long r7,
 256                                   struct pt_regs * regs)
 257{
 258        struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 259        sigset_t set;
 260        long long ret;
 261
 262        /* Always make any pending restarted system calls return -EINTR */
 263        current->restart_block.fn = do_no_restart_syscall;
 264
 265        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 266                goto badframe;
 267
 268        if (__get_user(set.sig[0], &frame->sc.oldmask)
 269            || (_NSIG_WORDS > 1
 270                && __copy_from_user(&set.sig[1], &frame->extramask,
 271                                    sizeof(frame->extramask))))
 272                goto badframe;
 273
 274        set_current_blocked(&set);
 275
 276        if (restore_sigcontext(regs, &frame->sc, &ret))
 277                goto badframe;
 278        regs->pc -= 4;
 279
 280        return (int) ret;
 281
 282badframe:
 283        force_sig(SIGSEGV, current);
 284        return 0;
 285}
 286
 287asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 288                                unsigned long r4, unsigned long r5,
 289                                unsigned long r6, unsigned long r7,
 290                                struct pt_regs * regs)
 291{
 292        struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 293        sigset_t set;
 294        long long ret;
 295
 296        /* Always make any pending restarted system calls return -EINTR */
 297        current->restart_block.fn = do_no_restart_syscall;
 298
 299        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 300                goto badframe;
 301
 302        if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 303                goto badframe;
 304
 305        set_current_blocked(&set);
 306
 307        if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 308                goto badframe;
 309        regs->pc -= 4;
 310
 311        if (restore_altstack(&frame->uc.uc_stack))
 312                goto badframe;
 313
 314        return (int) ret;
 315
 316badframe:
 317        force_sig(SIGSEGV, current);
 318        return 0;
 319}
 320
 321/*
 322 * Set up a signal frame.
 323 */
 324static int
 325setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 326                 unsigned long mask)
 327{
 328        int err = 0;
 329
 330        /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 331        err |= setup_sigcontext_fpu(regs, sc);
 332
 333#define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 334
 335        COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 336        COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 337        COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 338        COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 339        COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 340        COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 341        COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 342        COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 343        COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 344        COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 345        COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 346        COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 347        COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 348        COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 349        COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 350        COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 351        COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 352        COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 353        COPY(sr);       COPY(pc);
 354
 355#undef COPY
 356
 357        err |= __put_user(mask, &sc->oldmask);
 358
 359        return err;
 360}
 361
 362/*
 363 * Determine which stack to use..
 364 */
 365static inline void __user *
 366get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 367{
 368        if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 369                sp = current->sas_ss_sp + current->sas_ss_size;
 370
 371        return (void __user *)((sp - frame_size) & -8ul);
 372}
 373
 374void sa_default_restorer(void);         /* See comments below */
 375void sa_default_rt_restorer(void);      /* See comments below */
 376
 377static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 378{
 379        struct sigframe __user *frame;
 380        int err = 0, sig = ksig->sig;
 381        int signal;
 382
 383        frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 384
 385        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 386                return -EFAULT;
 387
 388        err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 389
 390        /* Give up earlier as i386, in case */
 391        if (err)
 392                return -EFAULT;
 393
 394        if (_NSIG_WORDS > 1) {
 395                err |= __copy_to_user(frame->extramask, &set->sig[1],
 396                                      sizeof(frame->extramask)); }
 397
 398        /* Give up earlier as i386, in case */
 399        if (err)
 400                return -EFAULT;
 401
 402        /* Set up to return from userspace.  If provided, use a stub
 403           already in userspace.  */
 404        if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 405                /*
 406                 * On SH5 all edited pointers are subject to NEFF
 407                 */
 408                DEREF_REG_PR = neff_sign_extend((unsigned long)
 409                        ksig->ka->sa.sa_restorer | 0x1);
 410        } else {
 411                /*
 412                 * Different approach on SH5.
 413                 * . Endianness independent asm code gets placed in entry.S .
 414                 *   This is limited to four ASM instructions corresponding
 415                 *   to two long longs in size.
 416                 * . err checking is done on the else branch only
 417                 * . flush_icache_range() is called upon __put_user() only
 418                 * . all edited pointers are subject to NEFF
 419                 * . being code, linker turns ShMedia bit on, always
 420                 *   dereference index -1.
 421                 */
 422                DEREF_REG_PR = neff_sign_extend((unsigned long)
 423                        frame->retcode | 0x01);
 424
 425                if (__copy_to_user(frame->retcode,
 426                        (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 427                        return -EFAULT;
 428
 429                /* Cohere the trampoline with the I-cache. */
 430                flush_cache_sigtramp(DEREF_REG_PR-1);
 431        }
 432
 433        /*
 434         * Set up registers for signal handler.
 435         * All edited pointers are subject to NEFF.
 436         */
 437        regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 438        regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
 439
 440        /* FIXME:
 441           The glibc profiling support for SH-5 needs to be passed a sigcontext
 442           so it can retrieve the PC.  At some point during 2003 the glibc
 443           support was changed to receive the sigcontext through the 2nd
 444           argument, but there are still versions of libc.so in use that use
 445           the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 446           through both 2nd and 3rd arguments.
 447        */
 448
 449        regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 450        regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 451
 452        regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 453
 454        /* Broken %016Lx */
 455        pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 456                 sig, current->comm, current->pid, frame,
 457                 regs->pc >> 32, regs->pc & 0xffffffff,
 458                 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 459
 460        return 0;
 461}
 462
 463static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
 464                          struct pt_regs *regs)
 465{
 466        struct rt_sigframe __user *frame;
 467        int err = 0, sig = ksig->sig;
 468
 469        frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 470
 471        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 472                return -EFAULT;
 473
 474        err |= __put_user(&frame->info, &frame->pinfo);
 475        err |= __put_user(&frame->uc, &frame->puc);
 476        err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 477
 478        /* Give up earlier as i386, in case */
 479        if (err)
 480                return -EFAULT;
 481
 482        /* Create the ucontext.  */
 483        err |= __put_user(0, &frame->uc.uc_flags);
 484        err |= __put_user(0, &frame->uc.uc_link);
 485        err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
 486        err |= setup_sigcontext(&frame->uc.uc_mcontext,
 487                                regs, set->sig[0]);
 488        err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 489
 490        /* Give up earlier as i386, in case */
 491        if (err)
 492                return -EFAULT;
 493
 494        /* Set up to return from userspace.  If provided, use a stub
 495           already in userspace.  */
 496        if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 497                /*
 498                 * On SH5 all edited pointers are subject to NEFF
 499                 */
 500                DEREF_REG_PR = neff_sign_extend((unsigned long)
 501                        ksig->ka.sa.sa_restorer | 0x1);
 502        } else {
 503                /*
 504                 * Different approach on SH5.
 505                 * . Endianness independent asm code gets placed in entry.S .
 506                 *   This is limited to four ASM instructions corresponding
 507                 *   to two long longs in size.
 508                 * . err checking is done on the else branch only
 509                 * . flush_icache_range() is called upon __put_user() only
 510                 * . all edited pointers are subject to NEFF
 511                 * . being code, linker turns ShMedia bit on, always
 512                 *   dereference index -1.
 513                 */
 514                DEREF_REG_PR = neff_sign_extend((unsigned long)
 515                        frame->retcode | 0x01);
 516
 517                if (__copy_to_user(frame->retcode,
 518                        (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 519                        return -EFAULT;
 520
 521                /* Cohere the trampoline with the I-cache. */
 522                flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 523        }
 524
 525        /*
 526         * Set up registers for signal handler.
 527         * All edited pointers are subject to NEFF.
 528         */
 529        regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 530        regs->regs[REG_ARG1] = sig; /* Arg for signal handler */
 531        regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 532        regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 533        regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 534
 535        pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 536                 sig, current->comm, current->pid, frame,
 537                 regs->pc >> 32, regs->pc & 0xffffffff,
 538                 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 539
 540        return 0;
 541}
 542
 543/*
 544 * OK, we're invoking a handler
 545 */
 546static void
 547handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 548{
 549        sigset_t *oldset = sigmask_to_save();
 550        int ret;
 551
 552        /* Set up the stack frame */
 553        if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 554                ret = setup_rt_frame(ksig, oldset, regs);
 555        else
 556                ret = setup_frame(ksig, oldset, regs);
 557
 558        signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
 559}
 560
 561asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 562{
 563        if (thread_info_flags & _TIF_SIGPENDING)
 564                do_signal(regs);
 565
 566        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 567                clear_thread_flag(TIF_NOTIFY_RESUME);
 568                tracehook_notify_resume(regs);
 569        }
 570}
 571