1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/arch/sh/kernel/signal.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 * 7 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 8 * 9 * SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima 10 * 11 */ 12 #include <linux/sched.h> 13 #include <linux/sched/task_stack.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/ptrace.h> 21 #include <linux/unistd.h> 22 #include <linux/stddef.h> 23 #include <linux/tty.h> 24 #include <linux/elf.h> 25 #include <linux/personality.h> 26 #include <linux/binfmts.h> 27 #include <linux/io.h> 28 #include <linux/resume_user_mode.h> 29 #include <asm/ucontext.h> 30 #include <linux/uaccess.h> 31 #include <asm/cacheflush.h> 32 #include <asm/syscalls.h> 33 #include <asm/fpu.h> 34 35 struct fdpic_func_descriptor { 36 unsigned long text; 37 unsigned long GOT; 38 }; 39 40 /* 41 * The following define adds a 64 byte gap between the signal 42 * stack frame and previous contents of the stack. This allows 43 * frame unwinding in a function epilogue but only if a frame 44 * pointer is used in the function. This is necessary because 45 * current gcc compilers (<4.3) do not generate unwind info on 46 * SH for function epilogues. 47 */ 48 #define UNWINDGUARD 64 49 50 /* 51 * Do a signal return; undo the signal stack. 52 */ 53 54 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */ 55 #if defined(CONFIG_CPU_SH2) 56 #define TRAP_NOARG 0xc320 /* Syscall w/no args (NR in R3) */ 57 #else 58 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) */ 59 #endif 60 #define OR_R0_R0 0x200b /* or r0,r0 (insert to avoid hardware bug) */ 61 62 struct sigframe 63 { 64 struct sigcontext sc; 65 unsigned long extramask[_NSIG_WORDS-1]; 66 u16 retcode[8]; 67 }; 68 69 struct rt_sigframe 70 { 71 struct siginfo info; 72 struct ucontext uc; 73 u16 retcode[8]; 74 }; 75 76 #ifdef CONFIG_SH_FPU 77 static inline int restore_sigcontext_fpu(struct sigcontext __user *sc) 78 { 79 struct task_struct *tsk = current; 80 81 if (!(boot_cpu_data.flags & CPU_HAS_FPU)) 82 return 0; 83 84 set_used_math(); 85 return __copy_from_user(&tsk->thread.xstate->hardfpu, &sc->sc_fpregs[0], 86 sizeof(long)*(16*2+2)); 87 } 88 89 static inline int save_sigcontext_fpu(struct sigcontext __user *sc, 90 struct pt_regs *regs) 91 { 92 struct task_struct *tsk = current; 93 94 if (!(boot_cpu_data.flags & CPU_HAS_FPU)) 95 return 0; 96 97 if (!used_math()) 98 return __put_user(0, &sc->sc_ownedfp); 99 100 if (__put_user(1, &sc->sc_ownedfp)) 101 return -EFAULT; 102 103 /* This will cause a "finit" to be triggered by the next 104 attempted FPU operation by the 'current' process. 105 */ 106 clear_used_math(); 107 108 unlazy_fpu(tsk, regs); 109 return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.xstate->hardfpu, 110 sizeof(long)*(16*2+2)); 111 } 112 #endif /* CONFIG_SH_FPU */ 113 114 static int 115 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p) 116 { 117 unsigned int err = 0; 118 119 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x) 120 COPY(regs[1]); 121 COPY(regs[2]); COPY(regs[3]); 122 COPY(regs[4]); COPY(regs[5]); 123 COPY(regs[6]); COPY(regs[7]); 124 COPY(regs[8]); COPY(regs[9]); 125 COPY(regs[10]); COPY(regs[11]); 126 COPY(regs[12]); COPY(regs[13]); 127 COPY(regs[14]); COPY(regs[15]); 128 COPY(gbr); COPY(mach); 129 COPY(macl); COPY(pr); 130 COPY(sr); COPY(pc); 131 #undef COPY 132 133 #ifdef CONFIG_SH_FPU 134 if (boot_cpu_data.flags & CPU_HAS_FPU) { 135 int owned_fp; 136 struct task_struct *tsk = current; 137 138 regs->sr |= SR_FD; /* Release FPU */ 139 clear_fpu(tsk, regs); 140 clear_used_math(); 141 err |= __get_user (owned_fp, &sc->sc_ownedfp); 142 if (owned_fp) 143 err |= restore_sigcontext_fpu(sc); 144 } 145 #endif 146 147 regs->tra = -1; /* disable syscall checks */ 148 err |= __get_user(*r0_p, &sc->sc_regs[0]); 149 return err; 150 } 151 152 asmlinkage int sys_sigreturn(void) 153 { 154 struct pt_regs *regs = current_pt_regs(); 155 struct sigframe __user *frame = (struct sigframe __user *)regs->regs[15]; 156 sigset_t set; 157 int r0; 158 159 /* Always make any pending restarted system calls return -EINTR */ 160 current->restart_block.fn = do_no_restart_syscall; 161 162 if (!access_ok(frame, sizeof(*frame))) 163 goto badframe; 164 165 if (__get_user(set.sig[0], &frame->sc.oldmask) 166 || (_NSIG_WORDS > 1 167 && __copy_from_user(&set.sig[1], &frame->extramask, 168 sizeof(frame->extramask)))) 169 goto badframe; 170 171 set_current_blocked(&set); 172 173 if (restore_sigcontext(regs, &frame->sc, &r0)) 174 goto badframe; 175 return r0; 176 177 badframe: 178 force_sig(SIGSEGV); 179 return 0; 180 } 181 182 asmlinkage int sys_rt_sigreturn(void) 183 { 184 struct pt_regs *regs = current_pt_regs(); 185 struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs->regs[15]; 186 sigset_t set; 187 int r0; 188 189 /* Always make any pending restarted system calls return -EINTR */ 190 current->restart_block.fn = do_no_restart_syscall; 191 192 if (!access_ok(frame, sizeof(*frame))) 193 goto badframe; 194 195 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 196 goto badframe; 197 198 set_current_blocked(&set); 199 200 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0)) 201 goto badframe; 202 203 if (restore_altstack(&frame->uc.uc_stack)) 204 goto badframe; 205 206 return r0; 207 208 badframe: 209 force_sig(SIGSEGV); 210 return 0; 211 } 212 213 /* 214 * Set up a signal frame. 215 */ 216 217 static int 218 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 219 unsigned long mask) 220 { 221 int err = 0; 222 223 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x) 224 COPY(regs[0]); COPY(regs[1]); 225 COPY(regs[2]); COPY(regs[3]); 226 COPY(regs[4]); COPY(regs[5]); 227 COPY(regs[6]); COPY(regs[7]); 228 COPY(regs[8]); COPY(regs[9]); 229 COPY(regs[10]); COPY(regs[11]); 230 COPY(regs[12]); COPY(regs[13]); 231 COPY(regs[14]); COPY(regs[15]); 232 COPY(gbr); COPY(mach); 233 COPY(macl); COPY(pr); 234 COPY(sr); COPY(pc); 235 #undef COPY 236 237 #ifdef CONFIG_SH_FPU 238 err |= save_sigcontext_fpu(sc, regs); 239 #endif 240 241 /* non-iBCS2 extensions.. */ 242 err |= __put_user(mask, &sc->oldmask); 243 244 return err; 245 } 246 247 /* 248 * Determine which stack to use.. 249 */ 250 static inline void __user * 251 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 252 { 253 if (ka->sa.sa_flags & SA_ONSTACK) { 254 if (sas_ss_flags(sp) == 0) 255 sp = current->sas_ss_sp + current->sas_ss_size; 256 } 257 258 return (void __user *)((sp - (frame_size+UNWINDGUARD)) & -8ul); 259 } 260 261 /* These symbols are defined with the addresses in the vsyscall page. 262 See vsyscall-trapa.S. */ 263 extern void __kernel_sigreturn(void); 264 extern void __kernel_rt_sigreturn(void); 265 266 static int setup_frame(struct ksignal *ksig, sigset_t *set, 267 struct pt_regs *regs) 268 { 269 struct sigframe __user *frame; 270 int err = 0, sig = ksig->sig; 271 272 frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame)); 273 274 if (!access_ok(frame, sizeof(*frame))) 275 return -EFAULT; 276 277 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]); 278 279 if (_NSIG_WORDS > 1) 280 err |= __copy_to_user(frame->extramask, &set->sig[1], 281 sizeof(frame->extramask)); 282 283 /* Set up to return from userspace. If provided, use a stub 284 already in userspace. */ 285 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 286 regs->pr = (unsigned long) ksig->ka.sa.sa_restorer; 287 #ifdef CONFIG_VSYSCALL 288 } else if (likely(current->mm->context.vdso)) { 289 regs->pr = VDSO_SYM(&__kernel_sigreturn); 290 #endif 291 } else { 292 /* Generate return code (system call to sigreturn) */ 293 err |= __put_user(MOVW(7), &frame->retcode[0]); 294 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 295 err |= __put_user(OR_R0_R0, &frame->retcode[2]); 296 err |= __put_user(OR_R0_R0, &frame->retcode[3]); 297 err |= __put_user(OR_R0_R0, &frame->retcode[4]); 298 err |= __put_user(OR_R0_R0, &frame->retcode[5]); 299 err |= __put_user(OR_R0_R0, &frame->retcode[6]); 300 err |= __put_user((__NR_sigreturn), &frame->retcode[7]); 301 regs->pr = (unsigned long) frame->retcode; 302 flush_icache_range(regs->pr, regs->pr + sizeof(frame->retcode)); 303 } 304 305 if (err) 306 return -EFAULT; 307 308 /* Set up registers for signal handler */ 309 regs->regs[15] = (unsigned long) frame; 310 regs->regs[4] = sig; /* Arg for signal handler */ 311 regs->regs[5] = 0; 312 regs->regs[6] = (unsigned long) &frame->sc; 313 314 if (current->personality & FDPIC_FUNCPTRS) { 315 struct fdpic_func_descriptor __user *funcptr = 316 (struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler; 317 318 err |= __get_user(regs->pc, &funcptr->text); 319 err |= __get_user(regs->regs[12], &funcptr->GOT); 320 } else 321 regs->pc = (unsigned long)ksig->ka.sa.sa_handler; 322 323 if (err) 324 return -EFAULT; 325 326 pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n", 327 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr); 328 329 return 0; 330 } 331 332 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, 333 struct pt_regs *regs) 334 { 335 struct rt_sigframe __user *frame; 336 int err = 0, sig = ksig->sig; 337 338 frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame)); 339 340 if (!access_ok(frame, sizeof(*frame))) 341 return -EFAULT; 342 343 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 344 345 /* Create the ucontext. */ 346 err |= __put_user(0, &frame->uc.uc_flags); 347 err |= __put_user(NULL, &frame->uc.uc_link); 348 err |= __save_altstack(&frame->uc.uc_stack, regs->regs[15]); 349 err |= setup_sigcontext(&frame->uc.uc_mcontext, 350 regs, set->sig[0]); 351 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 352 353 /* Set up to return from userspace. If provided, use a stub 354 already in userspace. */ 355 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 356 regs->pr = (unsigned long) ksig->ka.sa.sa_restorer; 357 #ifdef CONFIG_VSYSCALL 358 } else if (likely(current->mm->context.vdso)) { 359 regs->pr = VDSO_SYM(&__kernel_rt_sigreturn); 360 #endif 361 } else { 362 /* Generate return code (system call to rt_sigreturn) */ 363 err |= __put_user(MOVW(7), &frame->retcode[0]); 364 err |= __put_user(TRAP_NOARG, &frame->retcode[1]); 365 err |= __put_user(OR_R0_R0, &frame->retcode[2]); 366 err |= __put_user(OR_R0_R0, &frame->retcode[3]); 367 err |= __put_user(OR_R0_R0, &frame->retcode[4]); 368 err |= __put_user(OR_R0_R0, &frame->retcode[5]); 369 err |= __put_user(OR_R0_R0, &frame->retcode[6]); 370 err |= __put_user((__NR_rt_sigreturn), &frame->retcode[7]); 371 regs->pr = (unsigned long) frame->retcode; 372 flush_icache_range(regs->pr, regs->pr + sizeof(frame->retcode)); 373 } 374 375 if (err) 376 return -EFAULT; 377 378 /* Set up registers for signal handler */ 379 regs->regs[15] = (unsigned long) frame; 380 regs->regs[4] = sig; /* Arg for signal handler */ 381 regs->regs[5] = (unsigned long) &frame->info; 382 regs->regs[6] = (unsigned long) &frame->uc; 383 384 if (current->personality & FDPIC_FUNCPTRS) { 385 struct fdpic_func_descriptor __user *funcptr = 386 (struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler; 387 388 err |= __get_user(regs->pc, &funcptr->text); 389 err |= __get_user(regs->regs[12], &funcptr->GOT); 390 } else 391 regs->pc = (unsigned long)ksig->ka.sa.sa_handler; 392 393 if (err) 394 return -EFAULT; 395 396 pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n", 397 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr); 398 399 return 0; 400 } 401 402 static inline void 403 handle_syscall_restart(unsigned long save_r0, struct pt_regs *regs, 404 struct sigaction *sa) 405 { 406 /* If we're not from a syscall, bail out */ 407 if (regs->tra < 0) 408 return; 409 410 /* check for system call restart.. */ 411 switch (regs->regs[0]) { 412 case -ERESTART_RESTARTBLOCK: 413 case -ERESTARTNOHAND: 414 no_system_call_restart: 415 regs->regs[0] = -EINTR; 416 break; 417 418 case -ERESTARTSYS: 419 if (!(sa->sa_flags & SA_RESTART)) 420 goto no_system_call_restart; 421 fallthrough; 422 case -ERESTARTNOINTR: 423 regs->regs[0] = save_r0; 424 regs->pc -= instruction_size(__raw_readw(regs->pc - 4)); 425 break; 426 } 427 } 428 429 /* 430 * OK, we're invoking a handler 431 */ 432 static void 433 handle_signal(struct ksignal *ksig, struct pt_regs *regs, unsigned int save_r0) 434 { 435 sigset_t *oldset = sigmask_to_save(); 436 int ret; 437 438 /* Set up the stack frame */ 439 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 440 ret = setup_rt_frame(ksig, oldset, regs); 441 else 442 ret = setup_frame(ksig, oldset, regs); 443 444 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP)); 445 } 446 447 /* 448 * Note that 'init' is a special process: it doesn't get signals it doesn't 449 * want to handle. Thus you cannot kill init even with a SIGKILL even by 450 * mistake. 451 * 452 * Note that we go through the signals twice: once to check the signals that 453 * the kernel can handle, and then we build all the user-level signal handling 454 * stack-frames in one go after that. 455 */ 456 static void do_signal(struct pt_regs *regs, unsigned int save_r0) 457 { 458 struct ksignal ksig; 459 460 /* 461 * We want the common case to go fast, which 462 * is why we may in certain cases get here from 463 * kernel mode. Just return without doing anything 464 * if so. 465 */ 466 if (!user_mode(regs)) 467 return; 468 469 if (get_signal(&ksig)) { 470 handle_syscall_restart(save_r0, regs, &ksig.ka.sa); 471 472 /* Whee! Actually deliver the signal. */ 473 handle_signal(&ksig, regs, save_r0); 474 return; 475 } 476 477 /* Did we come from a system call? */ 478 if (regs->tra >= 0) { 479 /* Restart the system call - no handlers present */ 480 if (regs->regs[0] == -ERESTARTNOHAND || 481 regs->regs[0] == -ERESTARTSYS || 482 regs->regs[0] == -ERESTARTNOINTR) { 483 regs->regs[0] = save_r0; 484 regs->pc -= instruction_size(__raw_readw(regs->pc - 4)); 485 } else if (regs->regs[0] == -ERESTART_RESTARTBLOCK) { 486 regs->pc -= instruction_size(__raw_readw(regs->pc - 4)); 487 regs->regs[3] = __NR_restart_syscall; 488 } 489 } 490 491 /* 492 * If there's no signal to deliver, we just put the saved sigmask 493 * back. 494 */ 495 restore_saved_sigmask(); 496 } 497 498 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned int save_r0, 499 unsigned long thread_info_flags) 500 { 501 /* deal with pending signal delivery */ 502 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) 503 do_signal(regs, save_r0); 504 505 if (thread_info_flags & _TIF_NOTIFY_RESUME) 506 resume_user_mode_work(regs); 507 } 508