arch/arc/kernel/signal.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Signal Handling for ARC
   4  *
   5  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
   6  *
   7  * vineetg: Jan 2010 (Restarting of timer related syscalls)
   8  *
   9  * vineetg: Nov 2009 (Everything needed for TIF_RESTORE_SIGMASK)
  10  *  -do_signal() supports TIF_RESTORE_SIGMASK
  11  *  -do_signal() no longer needs oldset, required by OLD sys_sigsuspend
  12  *  -sys_rt_sigsuspend() now comes from generic code, so discard arch
  13  *   implementation
  14  *  -sys_sigsuspend() no longer needs to fudge ptregs, hence that arg removed
  15  *  -sys_sigsuspend() no longer loops for do_signal(), sets TIF_xxx and leaves
  16  *   the job to do_signal()
  17  *
  18  * vineetg: July 2009
  19  *  -Modified Code to support the uClibc provided userland sigreturn stub
  20  *   to avoid kernel synthesizing it on user stack at runtime, costing TLB
  21  *   probes and Cache line flushes.
  22  *
  23  * vineetg: July 2009
  24  *  -In stash_usr_regs( ) and restore_usr_regs( ), save/restore of user regs
  25  *   in done in block copy rather than one word at a time.
  26  *   This saves around 2K of code and improves LMBench lat_sig <catch>
  27  *
  28  * rajeshwarr: Feb 2009
  29  *  - Support for Realtime Signals
  30  *
  31  * vineetg: Aug 11th 2008: Bug #94183
  32  *  -ViXS were still seeing crashes when using insmod to load drivers.
  33  *   It turned out that the code to change Execute permssions for TLB entries
  34  *   of user was not guarded for interrupts (mod_tlb_permission)
  35  *   This was causing TLB entries to be overwritten on unrelated indexes
  36  *
  37  * Vineetg: July 15th 2008: Bug #94183
  38  *  -Exception happens in Delay slot of a JMP, and before user space resumes,
  39  *   Signal is delivered (Ctrl + C) = >SIGINT.
  40  *   setup_frame( ) sets up PC,SP,BLINK to enable user space signal handler
  41  *   to run, but doesn't clear the Delay slot bit from status32. As a result,
  42  *   on resuming user mode, signal handler branches off to BTA of orig JMP
  43  *  -FIX: clear the DE bit from status32 in setup_frame( )
  44  *
  45  * Rahul Trivedi, Kanika Nema: Codito Technologies 2004
  46  */
  47
  48 #include <linux/signal.h>
  49 #include <linux/ptrace.h>
  50 #include <linux/personality.h>
  51 #include <linux/uaccess.h>
  52 #include <linux/syscalls.h>
  53 #include <linux/resume_user_mode.h>
  54 #include <linux/sched/task_stack.h>
  55
  56 #include <asm/ucontext.h>
  57 #include <asm/entry.h>
  58
  59 struct rt_sigframe {
  60         struct siginfo info;
  61         struct ucontext uc;
  62 #define MAGIC_SIGALTSTK         0x07302004
  63         unsigned int sigret_magic;
  64 };
  65
  66 static int save_arcv2_regs(struct sigcontext __user *mctx, struct pt_regs *regs)
  67 {
  68         int err = 0;
  69 #ifndef CONFIG_ISA_ARCOMPACT
  70         struct user_regs_arcv2 v2abi;
  71
  72         v2abi.r30 = regs->r30;
  73 #ifdef CONFIG_ARC_HAS_ACCL_REGS
  74         v2abi.r58 = regs->r58;
  75         v2abi.r59 = regs->r59;
  76 #else
  77         v2abi.r58 = v2abi.r59 = 0;
  78 #endif
  79         err = __copy_to_user(&mctx->v2abi, (void const *)&v2abi, sizeof(v2abi));
  80 #endif
  81         return err;
  82 }
  83
  84 static int restore_arcv2_regs(struct sigcontext __user *mctx, struct pt_regs *regs)
  85 {
  86         int err = 0;
  87 #ifndef CONFIG_ISA_ARCOMPACT
  88         struct user_regs_arcv2 v2abi;
  89
  90         err = __copy_from_user(&v2abi, &mctx->v2abi, sizeof(v2abi));
  91
  92         regs->r30 = v2abi.r30;
  93 #ifdef CONFIG_ARC_HAS_ACCL_REGS
  94         regs->r58 = v2abi.r58;
  95         regs->r59 = v2abi.r59;
  96 #endif
  97 #endif
  98         return err;
  99 }
 100
 101 static int
 102 stash_usr_regs(struct rt_sigframe __user *sf, struct pt_regs *regs,
 103                sigset_t *set)
 104 {
 105         int err;
 106         struct user_regs_struct uregs;
 107
 108         uregs.scratch.bta       = regs->bta;
 109         uregs.scratch.lp_start  = regs->lp_start;
 110         uregs.scratch.lp_end    = regs->lp_end;
 111         uregs.scratch.lp_count  = regs->lp_count;
 112         uregs.scratch.status32  = regs->status32;
 113         uregs.scratch.ret       = regs->ret;
 114         uregs.scratch.blink     = regs->blink;
 115         uregs.scratch.fp        = regs->fp;
 116         uregs.scratch.gp        = regs->r26;
 117         uregs.scratch.r12       = regs->r12;
 118         uregs.scratch.r11       = regs->r11;
 119         uregs.scratch.r10       = regs->r10;
 120         uregs.scratch.r9        = regs->r9;
 121         uregs.scratch.r8        = regs->r8;
 122         uregs.scratch.r7        = regs->r7;
 123         uregs.scratch.r6        = regs->r6;
 124         uregs.scratch.r5        = regs->r5;
 125         uregs.scratch.r4        = regs->r4;
 126         uregs.scratch.r3        = regs->r3;
 127         uregs.scratch.r2        = regs->r2;
 128         uregs.scratch.r1        = regs->r1;
 129         uregs.scratch.r0        = regs->r0;
 130         uregs.scratch.sp        = regs->sp;
 131
 132         err = __copy_to_user(&(sf->uc.uc_mcontext.regs.scratch), &uregs.scratch,
 133                              sizeof(sf->uc.uc_mcontext.regs.scratch));
 134
 135         if (is_isa_arcv2())
 136                 err |= save_arcv2_regs(&(sf->uc.uc_mcontext), regs);
 137
 138         err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t));
 139
 140         return err ? -EFAULT : 0;
 141 }
 142
 143 static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf)
 144 {
 145         sigset_t set;
 146         int err;
 147         struct user_regs_struct uregs;
 148
 149         err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
 150         err |= __copy_from_user(&uregs.scratch,
 151                                 &(sf->uc.uc_mcontext.regs.scratch),
 152                                 sizeof(sf->uc.uc_mcontext.regs.scratch));
 153
 154         if (is_isa_arcv2())
 155                 err |= restore_arcv2_regs(&(sf->uc.uc_mcontext), regs);
 156
 157         if (err)
 158                 return -EFAULT;
 159
 160         set_current_blocked(&set);
 161         regs->bta       = uregs.scratch.bta;
 162         regs->lp_start  = uregs.scratch.lp_start;
 163         regs->lp_end    = uregs.scratch.lp_end;
 164         regs->lp_count  = uregs.scratch.lp_count;
 165         regs->status32  = uregs.scratch.status32;
 166         regs->ret       = uregs.scratch.ret;
 167         regs->blink     = uregs.scratch.blink;
 168         regs->fp        = uregs.scratch.fp;
 169         regs->r26       = uregs.scratch.gp;
 170         regs->r12       = uregs.scratch.r12;
 171         regs->r11       = uregs.scratch.r11;
 172         regs->r10       = uregs.scratch.r10;
 173         regs->r9        = uregs.scratch.r9;
 174         regs->r8        = uregs.scratch.r8;
 175         regs->r7        = uregs.scratch.r7;
 176         regs->r6        = uregs.scratch.r6;
 177         regs->r5        = uregs.scratch.r5;
 178         regs->r4        = uregs.scratch.r4;
 179         regs->r3        = uregs.scratch.r3;
 180         regs->r2        = uregs.scratch.r2;
 181         regs->r1        = uregs.scratch.r1;
 182         regs->r0        = uregs.scratch.r0;
 183         regs->sp        = uregs.scratch.sp;
 184
 185         return 0;
 186 }
 187
 188 static inline int is_do_ss_needed(unsigned int magic)
 189 {
 190         if (MAGIC_SIGALTSTK == magic)
 191                 return 1;
 192         else
 193                 return 0;
 194 }
 195
 196 SYSCALL_DEFINE0(rt_sigreturn)
 197 {
 198         struct rt_sigframe __user *sf;
 199         unsigned int magic;
 200         struct pt_regs *regs = current_pt_regs();
 201
 202         /* Always make any pending restarted system calls return -EINTR */
 203         current->restart_block.fn = do_no_restart_syscall;
 204
 205         /* Since we stacked the signal on a word boundary,
 206          * then 'sp' should be word aligned here.  If it's
 207          * not, then the user is trying to mess with us.
 208          */
 209         if (regs->sp & 3)
 210                 goto badframe;
 211
 212         sf = (struct rt_sigframe __force __user *)(regs->sp);
 213
 214         if (!access_ok(sf, sizeof(*sf)))
 215                 goto badframe;
 216
 217         if (__get_user(magic, &sf->sigret_magic))
 218                 goto badframe;
 219
 220         if (unlikely(is_do_ss_needed(magic)))
 221                 if (restore_altstack(&sf->uc.uc_stack))
 222                         goto badframe;
 223
 224         if (restore_usr_regs(regs, sf))
 225                 goto badframe;
 226
 227         /* Don't restart from sigreturn */
 228         syscall_wont_restart(regs);
 229
 230         /*
 231          * Ensure that sigreturn always returns to user mode (in case the
 232          * regs saved on user stack got fudged between save and sigreturn)
 233          * Otherwise it is easy to panic the kernel with a custom
 234          * signal handler and/or restorer which clobberes the status32/ret
 235          * to return to a bogus location in kernel mode.
 236          */
 237         regs->status32 |= STATUS_U_MASK;
 238
 239         return regs->r0;
 240
 241 badframe:
 242         force_sig(SIGSEGV);
 243         return 0;
 244 }
 245
 246 /*
 247  * Determine which stack to use..
 248  */
 249 static inline void __user *get_sigframe(struct ksignal *ksig,
 250                                         struct pt_regs *regs,
 251                                         unsigned long framesize)
 252 {
 253         unsigned long sp = sigsp(regs->sp, ksig);
 254         void __user *frame;
 255
 256         /* No matter what happens, 'sp' must be word
 257          * aligned otherwise nasty things could happen
 258          */
 259
 260         /* ATPCS B01 mandates 8-byte alignment */
 261         frame = (void __user *)((sp - framesize) & ~7);
 262
 263         /* Check that we can actually write to the signal frame */
 264         if (!access_ok(frame, framesize))
 265                 frame = NULL;
 266
 267         return frame;
 268 }
 269
 270 static int
 271 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 272 {
 273         struct rt_sigframe __user *sf;
 274         unsigned int magic = 0;
 275         int err = 0;
 276
 277         sf = get_sigframe(ksig, regs, sizeof(struct rt_sigframe));
 278         if (!sf)
 279                 return 1;
 280
 281         /*
 282          * w/o SA_SIGINFO, struct ucontext is partially populated (only
 283          * uc_mcontext/uc_sigmask) for kernel's normal user state preservation
 284          * during signal handler execution. This works for SA_SIGINFO as well
 285          * although the semantics are now overloaded (the same reg state can be
 286          * inspected by userland: but are they allowed to fiddle with it ?
 287          */
 288         err |= stash_usr_regs(sf, regs, set);
 289
 290         /*
 291          * SA_SIGINFO requires 3 args to signal handler:
 292          *  #1: sig-no (common to any handler)
 293          *  #2: struct siginfo
 294          *  #3: struct ucontext (completely populated)
 295          */
 296         if (unlikely(ksig->ka.sa.sa_flags & SA_SIGINFO)) {
 297                 err |= copy_siginfo_to_user(&sf->info, &ksig->info);
 298                 err |= __put_user(0, &sf->uc.uc_flags);
 299                 err |= __put_user(NULL, &sf->uc.uc_link);
 300                 err |= __save_altstack(&sf->uc.uc_stack, regs->sp);
 301
 302                 /* setup args 2 and 3 for user mode handler */
 303                 regs->r1 = (unsigned long)&sf->info;
 304                 regs->r2 = (unsigned long)&sf->uc;
 305
 306                 /*
 307                  * small optim to avoid unconditionally calling do_sigaltstack
 308                  * in sigreturn path, now that we only have rt_sigreturn
 309                  */
 310                 magic = MAGIC_SIGALTSTK;
 311         }
 312
 313         err |= __put_user(magic, &sf->sigret_magic);
 314         if (err)
 315                 return err;
 316
 317         /* #1 arg to the user Signal handler */
 318         regs->r0 = ksig->sig;
 319
 320         /* setup PC of user space signal handler */
 321         regs->ret = (unsigned long)ksig->ka.sa.sa_handler;
 322
 323         /*
 324          * handler returns using sigreturn stub provided already by userspace
 325          * If not, nuke the process right away
 326          */
 327         if(!(ksig->ka.sa.sa_flags & SA_RESTORER))
 328                 return 1;
 329
 330         regs->blink = (unsigned long)ksig->ka.sa.sa_restorer;
 331
 332         /* User Stack for signal handler will be above the frame just carved */
 333         regs->sp = (unsigned long)sf;
 334
 335         /*
 336          * Bug 94183, Clear the DE bit, so that when signal handler
 337          * starts to run, it doesn't use BTA
 338          */
 339         regs->status32 &= ~STATUS_DE_MASK;
 340         regs->status32 |= STATUS_L_MASK;
 341
 342         return err;
 343 }
 344
 345 static void arc_restart_syscall(struct k_sigaction *ka, struct pt_regs *regs)
 346 {
 347         switch (regs->r0) {
 348         case -ERESTART_RESTARTBLOCK:
 349         case -ERESTARTNOHAND:
 350                 /*
 351                  * ERESTARTNOHAND means that the syscall should
 352                  * only be restarted if there was no handler for
 353                  * the signal, and since we only get here if there
 354                  * is a handler, we don't restart
 355                  */
 356                 regs->r0 = -EINTR;   /* ERESTART_xxx is internal */
 357                 break;
 358
 359         case -ERESTARTSYS:
 360                 /*
 361                  * ERESTARTSYS means to restart the syscall if
 362                  * there is no handler or the handler was
 363                  * registered with SA_RESTART
 364                  */
 365                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 366                         regs->r0 = -EINTR;
 367                         break;
 368                 }
 369                 fallthrough;
 370
 371         case -ERESTARTNOINTR:
 372                 /*
 373                  * ERESTARTNOINTR means that the syscall should
 374                  * be called again after the signal handler returns.
 375                  * Setup reg state just as it was before doing the trap
 376                  * r0 has been clobbered with sys call ret code thus it
 377                  * needs to be reloaded with orig first arg to syscall
 378                  * in orig_r0. Rest of relevant reg-file:
 379                  * r8 (syscall num) and (r1 - r7) will be reset to
 380                  * their orig user space value when we ret from kernel
 381                  */
 382                 regs->r0 = regs->orig_r0;
 383                 regs->ret -= is_isa_arcv2() ? 2 : 4;
 384                 break;
 385         }
 386 }
 387
 388 /*
 389  * OK, we're invoking a handler
 390  */
 391 static void
 392 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 393 {
 394         sigset_t *oldset = sigmask_to_save();
 395         int failed;
 396
 397         /* Set up the stack frame */
 398         failed = setup_rt_frame(ksig, oldset, regs);
 399
 400         signal_setup_done(failed, ksig, 0);
 401 }
 402
 403 void do_signal(struct pt_regs *regs)
 404 {
 405         struct ksignal ksig;
 406         int restart_scall;
 407
 408         restart_scall = in_syscall(regs) && syscall_restartable(regs);
 409
 410         if (test_thread_flag(TIF_SIGPENDING) && get_signal(&ksig)) {
 411                 if (restart_scall) {
 412                         arc_restart_syscall(&ksig.ka, regs);
 413                         syscall_wont_restart(regs);     /* No more restarts */
 414                 }
 415                 handle_signal(&ksig, regs);
 416                 return;
 417         }
 418
 419         if (restart_scall) {
 420                 /* No handler for syscall: restart it */
 421                 if (regs->r0 == -ERESTARTNOHAND ||
 422                     regs->r0 == -ERESTARTSYS || regs->r0 == -ERESTARTNOINTR) {
 423                         regs->r0 = regs->orig_r0;
 424                         regs->ret -= is_isa_arcv2() ? 2 : 4;
 425                 } else if (regs->r0 == -ERESTART_RESTARTBLOCK) {
 426                         regs->r8 = __NR_restart_syscall;
 427                         regs->ret -= is_isa_arcv2() ? 2 : 4;
 428                 }
 429                 syscall_wont_restart(regs);     /* No more restarts */
 430         }
 431
 432         /* If there's no signal to deliver, restore the saved sigmask back */
 433         restore_saved_sigmask();
 434 }
 435
 436 void do_notify_resume(struct pt_regs *regs)
 437 {
 438         /*
 439          * ASM glue guarantees that this is only called when returning to
 440          * user mode
 441          */
 442         if (test_thread_flag(TIF_NOTIFY_RESUME))
 443                 resume_user_mode_work(regs);
 444 }