1 // SPDX-License-Identifier: GPL-2.0 <<
2 /* 1 /*
3 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@ !! 2 * This file is subject to the terms and conditions of the GNU General Public
>> 3 * License. See the file "COPYING" in the main directory of this archive
>> 4 * for more details.
>> 5 *
>> 6 * Copyright (C) 1991, 1992 Linus Torvalds
>> 7 * Copyright (C) 1994 - 2000 Ralf Baechle
>> 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
>> 9 * Copyright (C) 2014, Imagination Technologies Ltd.
4 */ 10 */
5 !! 11 #include <linux/cache.h>
6 #include <linux/module.h> !! 12 #include <linux/context_tracking.h>
7 #include <linux/ptrace.h> !! 13 #include <linux/irqflags.h>
8 #include <linux/sched.h> 14 #include <linux/sched.h>
9 #include <linux/ftrace.h> !! 15 #include <linux/mm.h>
10 #include <asm/siginfo.h> !! 16 #include <linux/personality.h>
11 #include <asm/signal.h> !! 17 #include <linux/smp.h>
12 #include <asm/unistd.h> !! 18 #include <linux/kernel.h>
13 #include <frame_kern.h> !! 19 #include <linux/signal.h>
14 #include <kern_util.h> !! 20 #include <linux/errno.h>
15 #include <os.h> !! 21 #include <linux/wait.h>
>> 22 #include <linux/ptrace.h>
>> 23 #include <linux/unistd.h>
>> 24 #include <linux/uprobes.h>
>> 25 #include <linux/compiler.h>
>> 26 #include <linux/syscalls.h>
>> 27 #include <linux/uaccess.h>
>> 28 #include <linux/resume_user_mode.h>
>> 29
>> 30 #include <asm/abi.h>
>> 31 #include <asm/asm.h>
>> 32 #include <linux/bitops.h>
>> 33 #include <asm/cacheflush.h>
>> 34 #include <asm/fpu.h>
>> 35 #include <asm/sim.h>
>> 36 #include <asm/ucontext.h>
>> 37 #include <asm/cpu-features.h>
>> 38 #include <asm/dsp.h>
>> 39 #include <asm/inst.h>
>> 40 #include <asm/msa.h>
>> 41 #include <asm/syscalls.h>
>> 42
>> 43 #include "signal-common.h"
>> 44
>> 45 static int (*save_fp_context)(void __user *sc);
>> 46 static int (*restore_fp_context)(void __user *sc);
>> 47
>> 48 struct sigframe {
>> 49 u32 sf_ass[4]; /* argument save space for o32 */
>> 50 u32 sf_pad[2]; /* Was: signal trampoline */
>> 51
>> 52 /* Matches struct ucontext from its uc_mcontext field onwards */
>> 53 struct sigcontext sf_sc;
>> 54 sigset_t sf_mask;
>> 55 unsigned long long sf_extcontext[];
>> 56 };
>> 57
>> 58 struct rt_sigframe {
>> 59 u32 rs_ass[4]; /* argument save space for o32 */
>> 60 u32 rs_pad[2]; /* Was: signal trampoline */
>> 61 struct siginfo rs_info;
>> 62 struct ucontext rs_uc;
>> 63 };
16 64
17 EXPORT_SYMBOL(block_signals); !! 65 #ifdef CONFIG_MIPS_FP_SUPPORT
18 EXPORT_SYMBOL(unblock_signals); <<
19 66
20 void block_signals_trace(void) !! 67 /*
>> 68 * Thread saved context copy to/from a signal context presumed to be on the
>> 69 * user stack, and therefore accessed with appropriate macros from uaccess.h.
>> 70 */
>> 71 static int copy_fp_to_sigcontext(void __user *sc)
21 { 72 {
22 block_signals(); !! 73 struct mips_abi *abi = current->thread.abi;
23 if (current_thread_info()) !! 74 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
24 trace_hardirqs_off(); !! 75 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 76 int i;
>> 77 int err = 0;
>> 78 int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
>> 79
>> 80 for (i = 0; i < NUM_FPU_REGS; i += inc) {
>> 81 err |=
>> 82 __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0),
>> 83 &fpregs[i]);
>> 84 }
>> 85 err |= __put_user(current->thread.fpu.fcr31, csr);
>> 86
>> 87 return err;
25 } 88 }
26 89
27 void unblock_signals_trace(void) !! 90 static int copy_fp_from_sigcontext(void __user *sc)
28 { 91 {
29 if (current_thread_info()) !! 92 struct mips_abi *abi = current->thread.abi;
30 trace_hardirqs_on(); !! 93 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
31 unblock_signals(); !! 94 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 95 int i;
>> 96 int err = 0;
>> 97 int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
>> 98 u64 fpr_val;
>> 99
>> 100 for (i = 0; i < NUM_FPU_REGS; i += inc) {
>> 101 err |= __get_user(fpr_val, &fpregs[i]);
>> 102 set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val);
>> 103 }
>> 104 err |= __get_user(current->thread.fpu.fcr31, csr);
>> 105
>> 106 return err;
32 } 107 }
33 108
34 void um_trace_signals_on(void) !! 109 #else /* !CONFIG_MIPS_FP_SUPPORT */
>> 110
>> 111 static int copy_fp_to_sigcontext(void __user *sc)
35 { 112 {
36 if (current_thread_info()) !! 113 return 0;
37 trace_hardirqs_on(); <<
38 } 114 }
39 115
40 void um_trace_signals_off(void) !! 116 static int copy_fp_from_sigcontext(void __user *sc)
41 { 117 {
42 if (current_thread_info()) !! 118 return 0;
43 trace_hardirqs_off(); <<
44 } 119 }
45 120
>> 121 #endif /* !CONFIG_MIPS_FP_SUPPORT */
>> 122
46 /* 123 /*
47 * OK, we're invoking a handler !! 124 * Wrappers for the assembly _{save,restore}_fp_context functions.
48 */ 125 */
49 static void handle_signal(struct ksignal *ksig !! 126 static int save_hw_fp_context(void __user *sc)
50 { 127 {
51 sigset_t *oldset = sigmask_to_save(); !! 128 struct mips_abi *abi = current->thread.abi;
52 int singlestep = 0; !! 129 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
53 unsigned long sp; !! 130 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 131
>> 132 return _save_fp_context(fpregs, csr);
>> 133 }
>> 134
>> 135 static int restore_hw_fp_context(void __user *sc)
>> 136 {
>> 137 struct mips_abi *abi = current->thread.abi;
>> 138 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
>> 139 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 140
>> 141 return _restore_fp_context(fpregs, csr);
>> 142 }
>> 143
>> 144 /*
>> 145 * Extended context handling.
>> 146 */
>> 147
>> 148 static inline void __user *sc_to_extcontext(void __user *sc)
>> 149 {
>> 150 struct ucontext __user *uc;
>> 151
>> 152 /*
>> 153 * We can just pretend the sigcontext is always embedded in a struct
>> 154 * ucontext here, because the offset from sigcontext to extended
>> 155 * context is the same in the struct sigframe case.
>> 156 */
>> 157 uc = container_of(sc, struct ucontext, uc_mcontext);
>> 158 return &uc->uc_extcontext;
>> 159 }
>> 160
>> 161 #ifdef CONFIG_CPU_HAS_MSA
>> 162
>> 163 static int save_msa_extcontext(void __user *buf)
>> 164 {
>> 165 struct msa_extcontext __user *msa = buf;
>> 166 uint64_t val;
>> 167 int i, err;
>> 168
>> 169 if (!thread_msa_context_live())
>> 170 return 0;
>> 171
>> 172 /*
>> 173 * Ensure that we can't lose the live MSA context between checking
>> 174 * for it & writing it to memory.
>> 175 */
>> 176 preempt_disable();
>> 177
>> 178 if (is_msa_enabled()) {
>> 179 /*
>> 180 * There are no EVA versions of the vector register load/store
>> 181 * instructions, so MSA context has to be saved to kernel memory
>> 182 * and then copied to user memory. The save to kernel memory
>> 183 * should already have been done when handling scalar FP
>> 184 * context.
>> 185 */
>> 186 BUG_ON(IS_ENABLED(CONFIG_EVA));
>> 187
>> 188 err = __put_user(read_msa_csr(), &msa->csr);
>> 189 err |= _save_msa_all_upper(&msa->wr);
>> 190
>> 191 preempt_enable();
>> 192 } else {
>> 193 preempt_enable();
>> 194
>> 195 err = __put_user(current->thread.fpu.msacsr, &msa->csr);
>> 196
>> 197 for (i = 0; i < NUM_FPU_REGS; i++) {
>> 198 val = get_fpr64(¤t->thread.fpu.fpr[i], 1);
>> 199 err |= __put_user(val, &msa->wr[i]);
>> 200 }
>> 201 }
>> 202
>> 203 err |= __put_user(MSA_EXTCONTEXT_MAGIC, &msa->ext.magic);
>> 204 err |= __put_user(sizeof(*msa), &msa->ext.size);
>> 205
>> 206 return err ? -EFAULT : sizeof(*msa);
>> 207 }
>> 208
>> 209 static int restore_msa_extcontext(void __user *buf, unsigned int size)
>> 210 {
>> 211 struct msa_extcontext __user *msa = buf;
>> 212 unsigned long long val;
>> 213 unsigned int csr;
>> 214 int i, err;
>> 215
>> 216 if (size != sizeof(*msa))
>> 217 return -EINVAL;
>> 218
>> 219 err = get_user(csr, &msa->csr);
>> 220 if (err)
>> 221 return err;
>> 222
>> 223 preempt_disable();
>> 224
>> 225 if (is_msa_enabled()) {
>> 226 /*
>> 227 * There are no EVA versions of the vector register load/store
>> 228 * instructions, so MSA context has to be copied to kernel
>> 229 * memory and later loaded to registers. The same is true of
>> 230 * scalar FP context, so FPU & MSA should have already been
>> 231 * disabled whilst handling scalar FP context.
>> 232 */
>> 233 BUG_ON(IS_ENABLED(CONFIG_EVA));
>> 234
>> 235 write_msa_csr(csr);
>> 236 err |= _restore_msa_all_upper(&msa->wr);
>> 237 preempt_enable();
>> 238 } else {
>> 239 preempt_enable();
>> 240
>> 241 current->thread.fpu.msacsr = csr;
>> 242
>> 243 for (i = 0; i < NUM_FPU_REGS; i++) {
>> 244 err |= __get_user(val, &msa->wr[i]);
>> 245 set_fpr64(¤t->thread.fpu.fpr[i], 1, val);
>> 246 }
>> 247 }
>> 248
>> 249 return err;
>> 250 }
>> 251
>> 252 #else /* !CONFIG_CPU_HAS_MSA */
>> 253
>> 254 static int save_msa_extcontext(void __user *buf)
>> 255 {
>> 256 return 0;
>> 257 }
>> 258
>> 259 static int restore_msa_extcontext(void __user *buf, unsigned int size)
>> 260 {
>> 261 return SIGSYS;
>> 262 }
>> 263
>> 264 #endif /* !CONFIG_CPU_HAS_MSA */
>> 265
>> 266 static int save_extcontext(void __user *buf)
>> 267 {
>> 268 int sz;
>> 269
>> 270 sz = save_msa_extcontext(buf);
>> 271 if (sz < 0)
>> 272 return sz;
>> 273 buf += sz;
>> 274
>> 275 /* If no context was saved then trivially return */
>> 276 if (!sz)
>> 277 return 0;
>> 278
>> 279 /* Write the end marker */
>> 280 if (__put_user(END_EXTCONTEXT_MAGIC, (u32 *)buf))
>> 281 return -EFAULT;
>> 282
>> 283 sz += sizeof(((struct extcontext *)NULL)->magic);
>> 284 return sz;
>> 285 }
>> 286
>> 287 static int restore_extcontext(void __user *buf)
>> 288 {
>> 289 struct extcontext ext;
54 int err; 290 int err;
55 291
56 if (test_thread_flag(TIF_SINGLESTEP) & !! 292 while (1) {
57 singlestep = 1; !! 293 err = __get_user(ext.magic, (unsigned int *)buf);
>> 294 if (err)
>> 295 return err;
>> 296
>> 297 if (ext.magic == END_EXTCONTEXT_MAGIC)
>> 298 return 0;
>> 299
>> 300 err = __get_user(ext.size, (unsigned int *)(buf
>> 301 + offsetof(struct extcontext, size)));
>> 302 if (err)
>> 303 return err;
>> 304
>> 305 switch (ext.magic) {
>> 306 case MSA_EXTCONTEXT_MAGIC:
>> 307 err = restore_msa_extcontext(buf, ext.size);
>> 308 break;
58 309
59 /* Did we come from a system call? */ !! 310 default:
60 if (PT_REGS_SYSCALL_NR(regs) >= 0) { !! 311 err = -EINVAL;
61 /* If so, check system call re <<
62 switch (PT_REGS_SYSCALL_RET(re <<
63 case -ERESTART_RESTARTBLOCK: <<
64 case -ERESTARTNOHAND: <<
65 PT_REGS_SYSCALL_RET(re <<
66 break; 312 break;
>> 313 }
>> 314
>> 315 if (err)
>> 316 return err;
>> 317
>> 318 buf += ext.size;
>> 319 }
>> 320 }
>> 321
>> 322 /*
>> 323 * Helper routines
>> 324 */
>> 325 int protected_save_fp_context(void __user *sc)
>> 326 {
>> 327 struct mips_abi *abi = current->thread.abi;
>> 328 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
>> 329 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 330 uint32_t __user *used_math = sc + abi->off_sc_used_math;
>> 331 unsigned int used, ext_sz;
>> 332 int err;
>> 333
>> 334 used = used_math() ? USED_FP : 0;
>> 335 if (!used)
>> 336 goto fp_done;
>> 337
>> 338 if (!test_thread_flag(TIF_32BIT_FPREGS))
>> 339 used |= USED_FR1;
>> 340 if (test_thread_flag(TIF_HYBRID_FPREGS))
>> 341 used |= USED_HYBRID_FPRS;
>> 342
>> 343 /*
>> 344 * EVA does not have userland equivalents of ldc1 or sdc1, so
>> 345 * save to the kernel FP context & copy that to userland below.
>> 346 */
>> 347 if (IS_ENABLED(CONFIG_EVA))
>> 348 lose_fpu(1);
>> 349
>> 350 while (1) {
>> 351 lock_fpu_owner();
>> 352 if (is_fpu_owner()) {
>> 353 err = save_fp_context(sc);
>> 354 unlock_fpu_owner();
>> 355 } else {
>> 356 unlock_fpu_owner();
>> 357 err = copy_fp_to_sigcontext(sc);
>> 358 }
>> 359 if (likely(!err))
>> 360 break;
>> 361 /* touch the sigcontext and try again */
>> 362 err = __put_user(0, &fpregs[0]) |
>> 363 __put_user(0, &fpregs[31]) |
>> 364 __put_user(0, csr);
>> 365 if (err)
>> 366 return err; /* really bad sigcontext */
>> 367 }
>> 368
>> 369 fp_done:
>> 370 ext_sz = err = save_extcontext(sc_to_extcontext(sc));
>> 371 if (err < 0)
>> 372 return err;
>> 373 used |= ext_sz ? USED_EXTCONTEXT : 0;
>> 374
>> 375 return __put_user(used, used_math);
>> 376 }
>> 377
>> 378 int protected_restore_fp_context(void __user *sc)
>> 379 {
>> 380 struct mips_abi *abi = current->thread.abi;
>> 381 uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
>> 382 uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
>> 383 uint32_t __user *used_math = sc + abi->off_sc_used_math;
>> 384 unsigned int used;
>> 385 int err, sig = 0, tmp __maybe_unused;
>> 386
>> 387 err = __get_user(used, used_math);
>> 388 conditional_used_math(used & USED_FP);
>> 389
>> 390 /*
>> 391 * The signal handler may have used FPU; give it up if the program
>> 392 * doesn't want it following sigreturn.
>> 393 */
>> 394 if (err || !(used & USED_FP))
>> 395 lose_fpu(0);
>> 396 if (err)
>> 397 return err;
>> 398 if (!(used & USED_FP))
>> 399 goto fp_done;
>> 400
>> 401 err = sig = fpcsr_pending(csr);
>> 402 if (err < 0)
>> 403 return err;
>> 404
>> 405 /*
>> 406 * EVA does not have userland equivalents of ldc1 or sdc1, so we
>> 407 * disable the FPU here such that the code below simply copies to
>> 408 * the kernel FP context.
>> 409 */
>> 410 if (IS_ENABLED(CONFIG_EVA))
>> 411 lose_fpu(0);
>> 412
>> 413 while (1) {
>> 414 lock_fpu_owner();
>> 415 if (is_fpu_owner()) {
>> 416 err = restore_fp_context(sc);
>> 417 unlock_fpu_owner();
>> 418 } else {
>> 419 unlock_fpu_owner();
>> 420 err = copy_fp_from_sigcontext(sc);
>> 421 }
>> 422 if (likely(!err))
>> 423 break;
>> 424 /* touch the sigcontext and try again */
>> 425 err = __get_user(tmp, &fpregs[0]) |
>> 426 __get_user(tmp, &fpregs[31]) |
>> 427 __get_user(tmp, csr);
>> 428 if (err)
>> 429 break; /* really bad sigcontext */
>> 430 }
>> 431
>> 432 fp_done:
>> 433 if (!err && (used & USED_EXTCONTEXT))
>> 434 err = restore_extcontext(sc_to_extcontext(sc));
>> 435
>> 436 return err ?: sig;
>> 437 }
>> 438
>> 439 int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
>> 440 {
>> 441 int err = 0;
>> 442 int i;
>> 443
>> 444 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
>> 445
>> 446 err |= __put_user(0, &sc->sc_regs[0]);
>> 447 for (i = 1; i < 32; i++)
>> 448 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
>> 449
>> 450 #ifdef CONFIG_CPU_HAS_SMARTMIPS
>> 451 err |= __put_user(regs->acx, &sc->sc_acx);
>> 452 #endif
>> 453 err |= __put_user(regs->hi, &sc->sc_mdhi);
>> 454 err |= __put_user(regs->lo, &sc->sc_mdlo);
>> 455 if (cpu_has_dsp) {
>> 456 err |= __put_user(mfhi1(), &sc->sc_hi1);
>> 457 err |= __put_user(mflo1(), &sc->sc_lo1);
>> 458 err |= __put_user(mfhi2(), &sc->sc_hi2);
>> 459 err |= __put_user(mflo2(), &sc->sc_lo2);
>> 460 err |= __put_user(mfhi3(), &sc->sc_hi3);
>> 461 err |= __put_user(mflo3(), &sc->sc_lo3);
>> 462 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
>> 463 }
>> 464
>> 465
>> 466 /*
>> 467 * Save FPU state to signal context. Signal handler
>> 468 * will "inherit" current FPU state.
>> 469 */
>> 470 err |= protected_save_fp_context(sc);
>> 471
>> 472 return err;
>> 473 }
>> 474
>> 475 static size_t extcontext_max_size(void)
>> 476 {
>> 477 size_t sz = 0;
>> 478
>> 479 /*
>> 480 * The assumption here is that between this point & the point at which
>> 481 * the extended context is saved the size of the context should only
>> 482 * ever be able to shrink (if the task is preempted), but never grow.
>> 483 * That is, what this function returns is an upper bound on the size of
>> 484 * the extended context for the current task at the current time.
>> 485 */
>> 486
>> 487 if (thread_msa_context_live())
>> 488 sz += sizeof(struct msa_extcontext);
>> 489
>> 490 /* If any context is saved then we'll append the end marker */
>> 491 if (sz)
>> 492 sz += sizeof(((struct extcontext *)NULL)->magic);
>> 493
>> 494 return sz;
>> 495 }
67 496
68 case -ERESTARTSYS: !! 497 int fpcsr_pending(unsigned int __user *fpcsr)
>> 498 {
>> 499 int err, sig = 0;
>> 500 unsigned int csr, enabled;
>> 501
>> 502 err = __get_user(csr, fpcsr);
>> 503 enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
>> 504 /*
>> 505 * If the signal handler set some FPU exceptions, clear it and
>> 506 * send SIGFPE.
>> 507 */
>> 508 if (csr & enabled) {
>> 509 csr &= ~enabled;
>> 510 err |= __put_user(csr, fpcsr);
>> 511 sig = SIGFPE;
>> 512 }
>> 513 return err ?: sig;
>> 514 }
>> 515
>> 516 int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
>> 517 {
>> 518 unsigned long treg;
>> 519 int err = 0;
>> 520 int i;
>> 521
>> 522 /* Always make any pending restarted system calls return -EINTR */
>> 523 current->restart_block.fn = do_no_restart_syscall;
>> 524
>> 525 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
>> 526
>> 527 #ifdef CONFIG_CPU_HAS_SMARTMIPS
>> 528 err |= __get_user(regs->acx, &sc->sc_acx);
>> 529 #endif
>> 530 err |= __get_user(regs->hi, &sc->sc_mdhi);
>> 531 err |= __get_user(regs->lo, &sc->sc_mdlo);
>> 532 if (cpu_has_dsp) {
>> 533 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
>> 534 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
>> 535 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
>> 536 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
>> 537 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
>> 538 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
>> 539 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
>> 540 }
>> 541
>> 542 for (i = 1; i < 32; i++)
>> 543 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
>> 544
>> 545 return err ?: protected_restore_fp_context(sc);
>> 546 }
>> 547
>> 548 #ifdef CONFIG_WAR_ICACHE_REFILLS
>> 549 #define SIGMASK ~(cpu_icache_line_size()-1)
>> 550 #else
>> 551 #define SIGMASK ALMASK
>> 552 #endif
>> 553
>> 554 void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
>> 555 size_t frame_size)
>> 556 {
>> 557 unsigned long sp;
>> 558
>> 559 /* Leave space for potential extended context */
>> 560 frame_size += extcontext_max_size();
>> 561
>> 562 /* Default to using normal stack */
>> 563 sp = regs->regs[29];
>> 564
>> 565 /*
>> 566 * If we are on the alternate signal stack and would overflow it, don't.
>> 567 * Return an always-bogus address instead so we will die with SIGSEGV.
>> 568 */
>> 569 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
>> 570 return (void __user __force *)(-1UL);
>> 571
>> 572 /*
>> 573 * FPU emulator may have its own trampoline active just
>> 574 * above the user stack, 16-bytes before the next lowest
>> 575 * 16 byte boundary. Try to avoid trashing it.
>> 576 */
>> 577 sp -= 32;
>> 578
>> 579 sp = sigsp(sp, ksig);
>> 580
>> 581 return (void __user *)((sp - frame_size) & SIGMASK);
>> 582 }
>> 583
>> 584 /*
>> 585 * Atomically swap in the new signal mask, and wait for a signal.
>> 586 */
>> 587
>> 588 #ifdef CONFIG_TRAD_SIGNALS
>> 589 SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset)
>> 590 {
>> 591 return sys_rt_sigsuspend(uset, sizeof(sigset_t));
>> 592 }
>> 593 #endif
>> 594
>> 595 #ifdef CONFIG_TRAD_SIGNALS
>> 596 SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
>> 597 struct sigaction __user *, oact)
>> 598 {
>> 599 struct k_sigaction new_ka, old_ka;
>> 600 int ret;
>> 601 int err = 0;
>> 602
>> 603 if (act) {
>> 604 old_sigset_t mask;
>> 605
>> 606 if (!access_ok(act, sizeof(*act)))
>> 607 return -EFAULT;
>> 608 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
>> 609 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
>> 610 err |= __get_user(mask, &act->sa_mask.sig[0]);
>> 611 if (err)
>> 612 return -EFAULT;
>> 613
>> 614 siginitset(&new_ka.sa.sa_mask, mask);
>> 615 }
>> 616
>> 617 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
>> 618
>> 619 if (!ret && oact) {
>> 620 if (!access_ok(oact, sizeof(*oact)))
>> 621 return -EFAULT;
>> 622 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
>> 623 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
>> 624 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
>> 625 err |= __put_user(0, &oact->sa_mask.sig[1]);
>> 626 err |= __put_user(0, &oact->sa_mask.sig[2]);
>> 627 err |= __put_user(0, &oact->sa_mask.sig[3]);
>> 628 if (err)
>> 629 return -EFAULT;
>> 630 }
>> 631
>> 632 return ret;
>> 633 }
>> 634 #endif
>> 635
>> 636 #ifdef CONFIG_TRAD_SIGNALS
>> 637 asmlinkage void sys_sigreturn(void)
>> 638 {
>> 639 struct sigframe __user *frame;
>> 640 struct pt_regs *regs;
>> 641 sigset_t blocked;
>> 642 int sig;
>> 643
>> 644 regs = current_pt_regs();
>> 645 frame = (struct sigframe __user *)regs->regs[29];
>> 646 if (!access_ok(frame, sizeof(*frame)))
>> 647 goto badframe;
>> 648 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
>> 649 goto badframe;
>> 650
>> 651 set_current_blocked(&blocked);
>> 652
>> 653 sig = restore_sigcontext(regs, &frame->sf_sc);
>> 654 if (sig < 0)
>> 655 goto badframe;
>> 656 else if (sig)
>> 657 force_sig(sig);
>> 658
>> 659 /*
>> 660 * Don't let your children do this ...
>> 661 */
>> 662 __asm__ __volatile__(
>> 663 "move\t$29, %0\n\t"
>> 664 "j\tsyscall_exit"
>> 665 : /* no outputs */
>> 666 : "r" (regs));
>> 667 /* Unreached */
>> 668
>> 669 badframe:
>> 670 force_sig(SIGSEGV);
>> 671 }
>> 672 #endif /* CONFIG_TRAD_SIGNALS */
>> 673
>> 674 asmlinkage void sys_rt_sigreturn(void)
>> 675 {
>> 676 struct rt_sigframe __user *frame;
>> 677 struct pt_regs *regs;
>> 678 sigset_t set;
>> 679 int sig;
>> 680
>> 681 regs = current_pt_regs();
>> 682 frame = (struct rt_sigframe __user *)regs->regs[29];
>> 683 if (!access_ok(frame, sizeof(*frame)))
>> 684 goto badframe;
>> 685 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
>> 686 goto badframe;
>> 687
>> 688 set_current_blocked(&set);
>> 689
>> 690 sig = restore_sigcontext(regs, &frame->rs_uc.uc_mcontext);
>> 691 if (sig < 0)
>> 692 goto badframe;
>> 693 else if (sig)
>> 694 force_sig(sig);
>> 695
>> 696 if (restore_altstack(&frame->rs_uc.uc_stack))
>> 697 goto badframe;
>> 698
>> 699 /*
>> 700 * Don't let your children do this ...
>> 701 */
>> 702 __asm__ __volatile__(
>> 703 "move\t$29, %0\n\t"
>> 704 "j\tsyscall_exit"
>> 705 : /* no outputs */
>> 706 : "r" (regs));
>> 707 /* Unreached */
>> 708
>> 709 badframe:
>> 710 force_sig(SIGSEGV);
>> 711 }
>> 712
>> 713 #ifdef CONFIG_TRAD_SIGNALS
>> 714 static int setup_frame(void *sig_return, struct ksignal *ksig,
>> 715 struct pt_regs *regs, sigset_t *set)
>> 716 {
>> 717 struct sigframe __user *frame;
>> 718 int err = 0;
>> 719
>> 720 frame = get_sigframe(ksig, regs, sizeof(*frame));
>> 721 if (!access_ok(frame, sizeof (*frame)))
>> 722 return -EFAULT;
>> 723
>> 724 err |= setup_sigcontext(regs, &frame->sf_sc);
>> 725 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
>> 726 if (err)
>> 727 return -EFAULT;
>> 728
>> 729 /*
>> 730 * Arguments to signal handler:
>> 731 *
>> 732 * a0 = signal number
>> 733 * a1 = 0 (should be cause)
>> 734 * a2 = pointer to struct sigcontext
>> 735 *
>> 736 * $25 and c0_epc point to the signal handler, $29 points to the
>> 737 * struct sigframe.
>> 738 */
>> 739 regs->regs[ 4] = ksig->sig;
>> 740 regs->regs[ 5] = 0;
>> 741 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
>> 742 regs->regs[29] = (unsigned long) frame;
>> 743 regs->regs[31] = (unsigned long) sig_return;
>> 744 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
>> 745
>> 746 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
>> 747 current->comm, current->pid,
>> 748 frame, regs->cp0_epc, regs->regs[31]);
>> 749 return 0;
>> 750 }
>> 751 #endif
>> 752
>> 753 static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
>> 754 struct pt_regs *regs, sigset_t *set)
>> 755 {
>> 756 struct rt_sigframe __user *frame;
>> 757
>> 758 frame = get_sigframe(ksig, regs, sizeof(*frame));
>> 759 if (!access_ok(frame, sizeof (*frame)))
>> 760 return -EFAULT;
>> 761
>> 762 /* Create siginfo. */
>> 763 if (copy_siginfo_to_user(&frame->rs_info, &ksig->info))
>> 764 return -EFAULT;
>> 765
>> 766 /* Create the ucontext. */
>> 767 if (__put_user(0, &frame->rs_uc.uc_flags))
>> 768 return -EFAULT;
>> 769 if (__put_user(NULL, &frame->rs_uc.uc_link))
>> 770 return -EFAULT;
>> 771 if (__save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]))
>> 772 return -EFAULT;
>> 773 if (setup_sigcontext(regs, &frame->rs_uc.uc_mcontext))
>> 774 return -EFAULT;
>> 775 if (__copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)))
>> 776 return -EFAULT;
>> 777
>> 778 /*
>> 779 * Arguments to signal handler:
>> 780 *
>> 781 * a0 = signal number
>> 782 * a1 = 0 (should be cause)
>> 783 * a2 = pointer to ucontext
>> 784 *
>> 785 * $25 and c0_epc point to the signal handler, $29 points to
>> 786 * the struct rt_sigframe.
>> 787 */
>> 788 regs->regs[ 4] = ksig->sig;
>> 789 regs->regs[ 5] = (unsigned long) &frame->rs_info;
>> 790 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
>> 791 regs->regs[29] = (unsigned long) frame;
>> 792 regs->regs[31] = (unsigned long) sig_return;
>> 793 regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
>> 794
>> 795 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
>> 796 current->comm, current->pid,
>> 797 frame, regs->cp0_epc, regs->regs[31]);
>> 798
>> 799 return 0;
>> 800 }
>> 801
>> 802 struct mips_abi mips_abi = {
>> 803 #ifdef CONFIG_TRAD_SIGNALS
>> 804 .setup_frame = setup_frame,
>> 805 #endif
>> 806 .setup_rt_frame = setup_rt_frame,
>> 807 .restart = __NR_restart_syscall,
>> 808
>> 809 .off_sc_fpregs = offsetof(struct sigcontext, sc_fpregs),
>> 810 .off_sc_fpc_csr = offsetof(struct sigcontext, sc_fpc_csr),
>> 811 .off_sc_used_math = offsetof(struct sigcontext, sc_used_math),
>> 812
>> 813 .vdso = &vdso_image,
>> 814 };
>> 815
>> 816 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
>> 817 {
>> 818 sigset_t *oldset = sigmask_to_save();
>> 819 int ret;
>> 820 struct mips_abi *abi = current->thread.abi;
>> 821 void *vdso = current->mm->context.vdso;
>> 822
>> 823 /*
>> 824 * If we were emulating a delay slot instruction, exit that frame such
>> 825 * that addresses in the sigframe are as expected for userland and we
>> 826 * don't have a problem if we reuse the thread's frame for an
>> 827 * instruction within the signal handler.
>> 828 */
>> 829 dsemul_thread_rollback(regs);
>> 830
>> 831 if (regs->regs[0]) {
>> 832 switch(regs->regs[2]) {
>> 833 case ERESTART_RESTARTBLOCK:
>> 834 case ERESTARTNOHAND:
>> 835 regs->regs[2] = EINTR;
>> 836 break;
>> 837 case ERESTARTSYS:
69 if (!(ksig->ka.sa.sa_f 838 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
70 PT_REGS_SYSCAL !! 839 regs->regs[2] = EINTR;
71 break; 840 break;
72 } 841 }
73 fallthrough; 842 fallthrough;
74 case -ERESTARTNOINTR: !! 843 case ERESTARTNOINTR:
75 PT_REGS_RESTART_SYSCAL !! 844 regs->regs[7] = regs->regs[26];
76 PT_REGS_ORIG_SYSCALL(r !! 845 regs->regs[2] = regs->regs[0];
77 break; !! 846 regs->cp0_epc -= 4;
78 } 847 }
>> 848
>> 849 regs->regs[0] = 0; /* Don't deal with this again. */
79 } 850 }
80 851
81 sp = PT_REGS_SP(regs); !! 852 rseq_signal_deliver(ksig, regs);
82 if ((ksig->ka.sa.sa_flags & SA_ONSTACK <<
83 sp = current->sas_ss_sp + curr <<
84 853
85 #ifdef CONFIG_ARCH_HAS_SC_SIGNALS !! 854 if (sig_uses_siginfo(&ksig->ka, abi))
86 if (!(ksig->ka.sa.sa_flags & SA_SIGINF !! 855 ret = abi->setup_rt_frame(vdso + abi->vdso->off_rt_sigreturn,
87 err = setup_signal_stack_sc(sp !! 856 ksig, regs, oldset);
88 else 857 else
89 #endif !! 858 ret = abi->setup_frame(vdso + abi->vdso->off_sigreturn,
90 err = setup_signal_stack_si(sp !! 859 ksig, regs, oldset);
91 860
92 signal_setup_done(err, ksig, singleste !! 861 signal_setup_done(ret, ksig, 0);
93 } 862 }
94 863
95 void do_signal(struct pt_regs *regs) !! 864 static void do_signal(struct pt_regs *regs)
96 { 865 {
97 struct ksignal ksig; 866 struct ksignal ksig;
98 int handled_sig = 0; <<
99 867
100 while (get_signal(&ksig)) { !! 868 if (get_signal(&ksig)) {
101 handled_sig = 1; !! 869 /* Whee! Actually deliver the signal. */
102 /* Whee! Actually deliver the <<
103 handle_signal(&ksig, regs); 870 handle_signal(&ksig, regs);
>> 871 return;
104 } 872 }
105 873
106 /* Did we come from a system call? */ !! 874 if (regs->regs[0]) {
107 if (!handled_sig && (PT_REGS_SYSCALL_N !! 875 switch (regs->regs[2]) {
108 /* Restart the system call - n !! 876 case ERESTARTNOHAND:
109 switch (PT_REGS_SYSCALL_RET(re !! 877 case ERESTARTSYS:
110 case -ERESTARTNOHAND: !! 878 case ERESTARTNOINTR:
111 case -ERESTARTSYS: !! 879 regs->regs[2] = regs->regs[0];
112 case -ERESTARTNOINTR: !! 880 regs->regs[7] = regs->regs[26];
113 PT_REGS_ORIG_SYSCALL(r !! 881 regs->cp0_epc -= 4;
114 PT_REGS_RESTART_SYSCAL <<
115 break; 882 break;
116 case -ERESTART_RESTARTBLOCK: !! 883
117 PT_REGS_ORIG_SYSCALL(r !! 884 case ERESTART_RESTARTBLOCK:
118 PT_REGS_RESTART_SYSCAL !! 885 regs->regs[2] = current->thread.abi->restart;
>> 886 regs->regs[7] = regs->regs[26];
>> 887 regs->cp0_epc -= 4;
119 break; 888 break;
120 } 889 }
>> 890 regs->regs[0] = 0; /* Don't deal with this again. */
121 } 891 }
122 892
123 /* 893 /*
124 * if there's no signal to deliver, we !! 894 * If there's no signal to deliver, we just put the saved sigmask
125 * back 895 * back
126 */ 896 */
127 if (!handled_sig) !! 897 restore_saved_sigmask();
128 restore_saved_sigmask(); !! 898 }
>> 899
>> 900 /*
>> 901 * notification of userspace execution resumption
>> 902 * - triggered by the TIF_WORK_MASK flags
>> 903 */
>> 904 asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
>> 905 __u32 thread_info_flags)
>> 906 {
>> 907 local_irq_enable();
>> 908
>> 909 user_exit();
>> 910
>> 911 if (thread_info_flags & _TIF_UPROBE)
>> 912 uprobe_notify_resume(regs);
>> 913
>> 914 /* deal with pending signal delivery */
>> 915 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))
>> 916 do_signal(regs);
>> 917
>> 918 if (thread_info_flags & _TIF_NOTIFY_RESUME)
>> 919 resume_user_mode_work(regs);
>> 920
>> 921 user_enter();
>> 922 }
>> 923
>> 924 #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
>> 925 static int smp_save_fp_context(void __user *sc)
>> 926 {
>> 927 return raw_cpu_has_fpu
>> 928 ? save_hw_fp_context(sc)
>> 929 : copy_fp_to_sigcontext(sc);
>> 930 }
>> 931
>> 932 static int smp_restore_fp_context(void __user *sc)
>> 933 {
>> 934 return raw_cpu_has_fpu
>> 935 ? restore_hw_fp_context(sc)
>> 936 : copy_fp_from_sigcontext(sc);
>> 937 }
>> 938 #endif
>> 939
>> 940 static int signal_setup(void)
>> 941 {
>> 942 /*
>> 943 * The offset from sigcontext to extended context should be the same
>> 944 * regardless of the type of signal, such that userland can always know
>> 945 * where to look if it wishes to find the extended context structures.
>> 946 */
>> 947 BUILD_BUG_ON((offsetof(struct sigframe, sf_extcontext) -
>> 948 offsetof(struct sigframe, sf_sc)) !=
>> 949 (offsetof(struct rt_sigframe, rs_uc.uc_extcontext) -
>> 950 offsetof(struct rt_sigframe, rs_uc.uc_mcontext)));
>> 951
>> 952 #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
>> 953 /* For now just do the cpu_has_fpu check when the functions are invoked */
>> 954 save_fp_context = smp_save_fp_context;
>> 955 restore_fp_context = smp_restore_fp_context;
>> 956 #else
>> 957 if (cpu_has_fpu) {
>> 958 save_fp_context = save_hw_fp_context;
>> 959 restore_fp_context = restore_hw_fp_context;
>> 960 } else {
>> 961 save_fp_context = copy_fp_to_sigcontext;
>> 962 restore_fp_context = copy_fp_from_sigcontext;
>> 963 }
>> 964 #endif /* CONFIG_SMP */
>> 965
>> 966 return 0;
129 } 967 }
>> 968
>> 969 arch_initcall(signal_setup);
130 970
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.