LXR linux/arch/nds32/kernel/signal.c

   1// SPDX-License-Identifier: GPL-2.0
   2// Copyright (C) 2005-2017 Andes Technology Corporation
   3
   4#include <linux/errno.h>
   5#include <linux/signal.h>
   6#include <linux/ptrace.h>
   7#include <linux/personality.h>
   8#include <linux/freezer.h>
   9#include <linux/tracehook.h>
  10#include <linux/uaccess.h>
  11
  12#include <asm/cacheflush.h>
  13#include <asm/ucontext.h>
  14#include <asm/unistd.h>
  15#include <asm/fpu.h>
  16
  17#include <asm/ptrace.h>
  18#include <asm/vdso.h>
  19
  20struct rt_sigframe {
  21        struct siginfo info;
  22        struct ucontext uc;
  23};
  24#if IS_ENABLED(CONFIG_FPU)
  25static inline int restore_sigcontext_fpu(struct pt_regs *regs,
  26                                         struct sigcontext __user *sc)
  27{
  28        struct task_struct *tsk = current;
  29        unsigned long used_math_flag;
  30        int ret = 0;
  31
  32        clear_used_math();
  33        __get_user_error(used_math_flag, &sc->used_math_flag, ret);
  34
  35        if (!used_math_flag)
  36                return 0;
  37        set_used_math();
  38
  39#if IS_ENABLED(CONFIG_LAZY_FPU)
  40        preempt_disable();
  41        if (current == last_task_used_math) {
  42                last_task_used_math = NULL;
  43                disable_ptreg_fpu(regs);
  44        }
  45        preempt_enable();
  46#else
  47        clear_fpu(regs);
  48#endif
  49
  50        return __copy_from_user(&tsk->thread.fpu, &sc->fpu,
  51                                sizeof(struct fpu_struct));
  52}
  53
  54static inline int setup_sigcontext_fpu(struct pt_regs *regs,
  55                                       struct sigcontext __user *sc)
  56{
  57        struct task_struct *tsk = current;
  58        int ret = 0;
  59
  60        __put_user_error(used_math(), &sc->used_math_flag, ret);
  61
  62        if (!used_math())
  63                return ret;
  64
  65        preempt_disable();
  66#if IS_ENABLED(CONFIG_LAZY_FPU)
  67        if (last_task_used_math == tsk)
  68                save_fpu(last_task_used_math);
  69#else
  70        unlazy_fpu(tsk);
  71#endif
  72        ret = __copy_to_user(&sc->fpu, &tsk->thread.fpu,
  73                             sizeof(struct fpu_struct));
  74        preempt_enable();
  75        return ret;
  76}
  77#endif
  78
  79static int restore_sigframe(struct pt_regs *regs,
  80                            struct rt_sigframe __user * sf)
  81{
  82        sigset_t set;
  83        int err;
  84
  85        err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
  86        if (err == 0) {
  87                set_current_blocked(&set);
  88        }
  89
  90        __get_user_error(regs->uregs[0], &sf->uc.uc_mcontext.nds32_r0, err);
  91        __get_user_error(regs->uregs[1], &sf->uc.uc_mcontext.nds32_r1, err);
  92        __get_user_error(regs->uregs[2], &sf->uc.uc_mcontext.nds32_r2, err);
  93        __get_user_error(regs->uregs[3], &sf->uc.uc_mcontext.nds32_r3, err);
  94        __get_user_error(regs->uregs[4], &sf->uc.uc_mcontext.nds32_r4, err);
  95        __get_user_error(regs->uregs[5], &sf->uc.uc_mcontext.nds32_r5, err);
  96        __get_user_error(regs->uregs[6], &sf->uc.uc_mcontext.nds32_r6, err);
  97        __get_user_error(regs->uregs[7], &sf->uc.uc_mcontext.nds32_r7, err);
  98        __get_user_error(regs->uregs[8], &sf->uc.uc_mcontext.nds32_r8, err);
  99        __get_user_error(regs->uregs[9], &sf->uc.uc_mcontext.nds32_r9, err);
 100        __get_user_error(regs->uregs[10], &sf->uc.uc_mcontext.nds32_r10, err);
 101        __get_user_error(regs->uregs[11], &sf->uc.uc_mcontext.nds32_r11, err);
 102        __get_user_error(regs->uregs[12], &sf->uc.uc_mcontext.nds32_r12, err);
 103        __get_user_error(regs->uregs[13], &sf->uc.uc_mcontext.nds32_r13, err);
 104        __get_user_error(regs->uregs[14], &sf->uc.uc_mcontext.nds32_r14, err);
 105        __get_user_error(regs->uregs[15], &sf->uc.uc_mcontext.nds32_r15, err);
 106        __get_user_error(regs->uregs[16], &sf->uc.uc_mcontext.nds32_r16, err);
 107        __get_user_error(regs->uregs[17], &sf->uc.uc_mcontext.nds32_r17, err);
 108        __get_user_error(regs->uregs[18], &sf->uc.uc_mcontext.nds32_r18, err);
 109        __get_user_error(regs->uregs[19], &sf->uc.uc_mcontext.nds32_r19, err);
 110        __get_user_error(regs->uregs[20], &sf->uc.uc_mcontext.nds32_r20, err);
 111        __get_user_error(regs->uregs[21], &sf->uc.uc_mcontext.nds32_r21, err);
 112        __get_user_error(regs->uregs[22], &sf->uc.uc_mcontext.nds32_r22, err);
 113        __get_user_error(regs->uregs[23], &sf->uc.uc_mcontext.nds32_r23, err);
 114        __get_user_error(regs->uregs[24], &sf->uc.uc_mcontext.nds32_r24, err);
 115        __get_user_error(regs->uregs[25], &sf->uc.uc_mcontext.nds32_r25, err);
 116
 117        __get_user_error(regs->fp, &sf->uc.uc_mcontext.nds32_fp, err);
 118        __get_user_error(regs->gp, &sf->uc.uc_mcontext.nds32_gp, err);
 119        __get_user_error(regs->lp, &sf->uc.uc_mcontext.nds32_lp, err);
 120        __get_user_error(regs->sp, &sf->uc.uc_mcontext.nds32_sp, err);
 121        __get_user_error(regs->ipc, &sf->uc.uc_mcontext.nds32_ipc, err);
 122#if defined(CONFIG_HWZOL)
 123        __get_user_error(regs->lc, &sf->uc.uc_mcontext.zol.nds32_lc, err);
 124        __get_user_error(regs->le, &sf->uc.uc_mcontext.zol.nds32_le, err);
 125        __get_user_error(regs->lb, &sf->uc.uc_mcontext.zol.nds32_lb, err);
 126#endif
 127#if IS_ENABLED(CONFIG_FPU)
 128        err |= restore_sigcontext_fpu(regs, &sf->uc.uc_mcontext);
 129#endif
 130        /*
 131         * Avoid sys_rt_sigreturn() restarting.
 132         */
 133        forget_syscall(regs);
 134        return err;
 135}
 136
 137asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
 138{
 139        struct rt_sigframe __user *frame;
 140
 141        /* Always make any pending restarted system calls return -EINTR */
 142        current->restart_block.fn = do_no_restart_syscall;
 143
 144        /*
 145         * Since we stacked the signal on a 64-bit boundary,
 146         * then 'sp' should be two-word aligned here.  If it's
 147         * not, then the user is trying to mess with us.
 148         */
 149        if (regs->sp & 7)
 150                goto badframe;
 151
 152        frame = (struct rt_sigframe __user *)regs->sp;
 153
 154        if (!access_ok(frame, sizeof(*frame)))
 155                goto badframe;
 156
 157        if (restore_sigframe(regs, frame))
 158                goto badframe;
 159
 160        if (restore_altstack(&frame->uc.uc_stack))
 161                goto badframe;
 162
 163        return regs->uregs[0];
 164
 165badframe:
 166        force_sig(SIGSEGV);
 167        return 0;
 168}
 169
 170static int
 171setup_sigframe(struct rt_sigframe __user * sf, struct pt_regs *regs,
 172               sigset_t * set)
 173{
 174        int err = 0;
 175
 176        __put_user_error(regs->uregs[0], &sf->uc.uc_mcontext.nds32_r0, err);
 177        __put_user_error(regs->uregs[1], &sf->uc.uc_mcontext.nds32_r1, err);
 178        __put_user_error(regs->uregs[2], &sf->uc.uc_mcontext.nds32_r2, err);
 179        __put_user_error(regs->uregs[3], &sf->uc.uc_mcontext.nds32_r3, err);
 180        __put_user_error(regs->uregs[4], &sf->uc.uc_mcontext.nds32_r4, err);
 181        __put_user_error(regs->uregs[5], &sf->uc.uc_mcontext.nds32_r5, err);
 182        __put_user_error(regs->uregs[6], &sf->uc.uc_mcontext.nds32_r6, err);
 183        __put_user_error(regs->uregs[7], &sf->uc.uc_mcontext.nds32_r7, err);
 184        __put_user_error(regs->uregs[8], &sf->uc.uc_mcontext.nds32_r8, err);
 185        __put_user_error(regs->uregs[9], &sf->uc.uc_mcontext.nds32_r9, err);
 186        __put_user_error(regs->uregs[10], &sf->uc.uc_mcontext.nds32_r10, err);
 187        __put_user_error(regs->uregs[11], &sf->uc.uc_mcontext.nds32_r11, err);
 188        __put_user_error(regs->uregs[12], &sf->uc.uc_mcontext.nds32_r12, err);
 189        __put_user_error(regs->uregs[13], &sf->uc.uc_mcontext.nds32_r13, err);
 190        __put_user_error(regs->uregs[14], &sf->uc.uc_mcontext.nds32_r14, err);
 191        __put_user_error(regs->uregs[15], &sf->uc.uc_mcontext.nds32_r15, err);
 192        __put_user_error(regs->uregs[16], &sf->uc.uc_mcontext.nds32_r16, err);
 193        __put_user_error(regs->uregs[17], &sf->uc.uc_mcontext.nds32_r17, err);
 194        __put_user_error(regs->uregs[18], &sf->uc.uc_mcontext.nds32_r18, err);
 195        __put_user_error(regs->uregs[19], &sf->uc.uc_mcontext.nds32_r19, err);
 196        __put_user_error(regs->uregs[20], &sf->uc.uc_mcontext.nds32_r20, err);
 197
 198        __put_user_error(regs->uregs[21], &sf->uc.uc_mcontext.nds32_r21, err);
 199        __put_user_error(regs->uregs[22], &sf->uc.uc_mcontext.nds32_r22, err);
 200        __put_user_error(regs->uregs[23], &sf->uc.uc_mcontext.nds32_r23, err);
 201        __put_user_error(regs->uregs[24], &sf->uc.uc_mcontext.nds32_r24, err);
 202        __put_user_error(regs->uregs[25], &sf->uc.uc_mcontext.nds32_r25, err);
 203        __put_user_error(regs->fp, &sf->uc.uc_mcontext.nds32_fp, err);
 204        __put_user_error(regs->gp, &sf->uc.uc_mcontext.nds32_gp, err);
 205        __put_user_error(regs->lp, &sf->uc.uc_mcontext.nds32_lp, err);
 206        __put_user_error(regs->sp, &sf->uc.uc_mcontext.nds32_sp, err);
 207        __put_user_error(regs->ipc, &sf->uc.uc_mcontext.nds32_ipc, err);
 208#if defined(CONFIG_HWZOL)
 209        __put_user_error(regs->lc, &sf->uc.uc_mcontext.zol.nds32_lc, err);
 210        __put_user_error(regs->le, &sf->uc.uc_mcontext.zol.nds32_le, err);
 211        __put_user_error(regs->lb, &sf->uc.uc_mcontext.zol.nds32_lb, err);
 212#endif
 213#if IS_ENABLED(CONFIG_FPU)
 214        err |= setup_sigcontext_fpu(regs, &sf->uc.uc_mcontext);
 215#endif
 216
 217        __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no,
 218                         err);
 219        __put_user_error(current->thread.error_code,
 220                         &sf->uc.uc_mcontext.error_code, err);
 221        __put_user_error(current->thread.address,
 222                         &sf->uc.uc_mcontext.fault_address, err);
 223        __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
 224
 225        err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
 226
 227        return err;
 228}
 229
 230static inline void __user *get_sigframe(struct ksignal *ksig,
 231                                        struct pt_regs *regs, int framesize)
 232{
 233        unsigned long sp;
 234
 235        /* Default to using normal stack */
 236        sp = regs->sp;
 237
 238        /*
 239         * If we are on the alternate signal stack and would overflow it, don't.
 240         * Return an always-bogus address instead so we will die with SIGSEGV.
 241         */
 242        if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
 243                return (void __user __force *)(-1UL);
 244
 245        /* This is the X/Open sanctioned signal stack switching. */
 246        sp = (sigsp(sp, ksig) - framesize);
 247
 248        /*
 249         * nds32 mandates 8-byte alignment
 250         */
 251        sp &= ~0x7UL;
 252
 253        return (void __user *)sp;
 254}
 255
 256static int
 257setup_return(struct pt_regs *regs, struct ksignal *ksig, void __user * frame)
 258{
 259        unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
 260        unsigned long retcode;
 261
 262        retcode = VDSO_SYMBOL(current->mm->context.vdso, rt_sigtramp);
 263        regs->uregs[0] = ksig->sig;
 264        regs->sp = (unsigned long)frame;
 265        regs->lp = retcode;
 266        regs->ipc = handler;
 267
 268        return 0;
 269}
 270
 271static int
 272setup_rt_frame(struct ksignal *ksig, sigset_t * set, struct pt_regs *regs)
 273{
 274        struct rt_sigframe __user *frame =
 275            get_sigframe(ksig, regs, sizeof(*frame));
 276        int err = 0;
 277
 278        if (!access_ok(frame, sizeof(*frame)))
 279                return -EFAULT;
 280
 281        __put_user_error(0, &frame->uc.uc_flags, err);
 282        __put_user_error(NULL, &frame->uc.uc_link, err);
 283
 284        err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
 285        err |= setup_sigframe(frame, regs, set);
 286        if (err == 0) {
 287                setup_return(regs, ksig, frame);
 288                if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
 289                        err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 290                        regs->uregs[1] = (unsigned long)&frame->info;
 291                        regs->uregs[2] = (unsigned long)&frame->uc;
 292                }
 293        }
 294        return err;
 295}
 296
 297/*
 298 * OK, we're invoking a handler
 299 */
 300static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 301{
 302        int ret;
 303        sigset_t *oldset = sigmask_to_save();
 304
 305        if (in_syscall(regs)) {
 306                /* Avoid additional syscall restarting via ret_slow_syscall. */
 307                forget_syscall(regs);
 308
 309                switch (regs->uregs[0]) {
 310                case -ERESTART_RESTARTBLOCK:
 311                case -ERESTARTNOHAND:
 312                        regs->uregs[0] = -EINTR;
 313                        break;
 314                case -ERESTARTSYS:
 315                        if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
 316                                regs->uregs[0] = -EINTR;
 317                                break;
 318                        }
 319                        fallthrough;
 320                case -ERESTARTNOINTR:
 321                        regs->uregs[0] = regs->orig_r0;
 322                        regs->ipc -= 4;
 323                        break;
 324                }
 325        }
 326        /*
 327         * Set up the stack frame
 328         */
 329        ret = setup_rt_frame(ksig, oldset, regs);
 330
 331        signal_setup_done(ret, ksig, 0);
 332}
 333
 334/*
 335 * Note that 'init' is a special process: it doesn't get signals it doesn't
 336 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 337 * mistake.
 338 *
 339 * Note that we go through the signals twice: once to check the signals that
 340 * the kernel can handle, and then we build all the user-level signal handling
 341 * stack-frames in one go after that.
 342 */
 343static void do_signal(struct pt_regs *regs)
 344{
 345        struct ksignal ksig;
 346
 347        if (get_signal(&ksig)) {
 348                handle_signal(&ksig, regs);
 349                return;
 350        }
 351
 352        /*
 353         * If we were from a system call, check for system call restarting...
 354         */
 355        if (in_syscall(regs)) {
 356                /* Restart the system call - no handlers present */
 357
 358                /* Avoid additional syscall restarting via ret_slow_syscall. */
 359                forget_syscall(regs);
 360
 361                switch (regs->uregs[0]) {
 362                case -ERESTART_RESTARTBLOCK:
 363                        regs->uregs[15] = __NR_restart_syscall;
 364                        fallthrough;
 365                case -ERESTARTNOHAND:
 366                case -ERESTARTSYS:
 367                case -ERESTARTNOINTR:
 368                        regs->uregs[0] = regs->orig_r0;
 369                        regs->ipc -= 0x4;
 370                        break;
 371                }
 372        }
 373        restore_saved_sigmask();
 374}
 375
 376asmlinkage void
 377do_notify_resume(struct pt_regs *regs, unsigned int thread_flags)
 378{
 379        if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))
 380                do_signal(regs);
 381
 382        if (thread_flags & _TIF_NOTIFY_RESUME)
 383                tracehook_notify_resume(regs);
 384}
 385