LXR linux/arch/sh/kernel/signal

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