11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds * This file is subject to the terms and conditions of the GNU General Public
31da177e4SLinus Torvalds * License. See the file "COPYING" in the main directory of this archive
41da177e4SLinus Torvalds * for more details.
51da177e4SLinus Torvalds *
61da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
71da177e4SLinus Torvalds * Copyright (C) 1994 - 2000 Ralf Baechle
81da177e4SLinus Torvalds * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9ca750649SLeonid Yegoshin * Copyright (C) 2014, Imagination Technologies Ltd.
101da177e4SLinus Torvalds */
1102416dcfSRalf Baechle #include <linux/cache.h>
12c3fc5cd5SRalf Baechle #include <linux/context_tracking.h>
131f717929SRalf Baechle #include <linux/irqflags.h>
141da177e4SLinus Torvalds #include <linux/sched.h>
151da177e4SLinus Torvalds #include <linux/mm.h>
161da177e4SLinus Torvalds #include <linux/personality.h>
171da177e4SLinus Torvalds #include <linux/smp.h>
181da177e4SLinus Torvalds #include <linux/kernel.h>
191da177e4SLinus Torvalds #include <linux/signal.h>
201da177e4SLinus Torvalds #include <linux/errno.h>
211da177e4SLinus Torvalds #include <linux/wait.h>
221da177e4SLinus Torvalds #include <linux/ptrace.h>
231da177e4SLinus Torvalds #include <linux/unistd.h>
2440e084a5SRalf Baechle #include <linux/uprobes.h>
251da177e4SLinus Torvalds #include <linux/compiler.h>
26dbda6ac0SRalf Baechle #include <linux/syscalls.h>
27faea6234SAtsushi Nemoto #include <linux/uaccess.h>
28*03248addSEric W. Biederman #include <linux/resume_user_mode.h>
291da177e4SLinus Torvalds
30e50c0a8fSRalf Baechle #include <asm/abi.h>
311da177e4SLinus Torvalds #include <asm/asm.h>
321da177e4SLinus Torvalds #include <linux/bitops.h>
331da177e4SLinus Torvalds #include <asm/cacheflush.h>
341da177e4SLinus Torvalds #include <asm/fpu.h>
351da177e4SLinus Torvalds #include <asm/sim.h>
361da177e4SLinus Torvalds #include <asm/ucontext.h>
371da177e4SLinus Torvalds #include <asm/cpu-features.h>
3802416dcfSRalf Baechle #include <asm/dsp.h>
39b81947c6SDavid Howells #include <asm/inst.h>
4001be057bSDouglas Leung #include <asm/msa.h>
41bf82cb30SPaul Burton
421da177e4SLinus Torvalds #include "signal-common.h"
431da177e4SLinus Torvalds
441da177e4SLinus Torvalds static int (*save_fp_context)(void __user *sc);
452db9ca0aSPaul Burton static int (*restore_fp_context)(void __user *sc);
462db9ca0aSPaul Burton
47137f6f3eSRalf Baechle struct sigframe {
4866680583SRalf Baechle u32 sf_ass[4]; /* argument save space for o32 */
4966680583SRalf Baechle u32 sf_pad[2]; /* Was: signal trampoline */
50d814c28cSDavid Daney
51f1fe2d21SPaul Burton /* Matches struct ucontext from its uc_mcontext field onwards */
52f1fe2d21SPaul Burton struct sigcontext sf_sc;
5366680583SRalf Baechle sigset_t sf_mask;
5466680583SRalf Baechle unsigned long long sf_extcontext[];
55c4ad6ea9SGustavo A. R. Silva };
5666680583SRalf Baechle
5766680583SRalf Baechle struct rt_sigframe {
58c0b9bae9SFranck Bui-Huu u32 rs_ass[4]; /* argument save space for o32 */
59c0b9bae9SFranck Bui-Huu u32 rs_pad[2]; /* Was: signal trampoline */
60d814c28cSDavid Daney struct siginfo rs_info;
61c0b9bae9SFranck Bui-Huu struct ucontext rs_uc;
62c0b9bae9SFranck Bui-Huu };
63c0b9bae9SFranck Bui-Huu
64c0b9bae9SFranck Bui-Huu #ifdef CONFIG_MIPS_FP_SUPPORT
654eec81d7SPaul Burton
664eec81d7SPaul Burton /*
671da177e4SLinus Torvalds * Thread saved context copy to/from a signal context presumed to be on the
68b2ead528SPaul Burton * user stack, and therefore accessed with appropriate macros from uaccess.h.
69b2ead528SPaul Burton */
copy_fp_to_sigcontext(void __user * sc)70b2ead528SPaul Burton static int copy_fp_to_sigcontext(void __user *sc)
712db9ca0aSPaul Burton {
72b2ead528SPaul Burton struct mips_abi *abi = current->thread.abi;
732db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
742db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
752db9ca0aSPaul Burton int i;
76b2ead528SPaul Burton int err = 0;
77b2ead528SPaul Burton int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
786f0aba63SPaul Burton
79b2ead528SPaul Burton for (i = 0; i < NUM_FPU_REGS; i += inc) {
806f0aba63SPaul Burton err |=
81b2ead528SPaul Burton __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0),
82b2ead528SPaul Burton &fpregs[i]);
832db9ca0aSPaul Burton }
84b2ead528SPaul Burton err |= __put_user(current->thread.fpu.fcr31, csr);
852db9ca0aSPaul Burton
86b2ead528SPaul Burton return err;
87b2ead528SPaul Burton }
88b2ead528SPaul Burton
copy_fp_from_sigcontext(void __user * sc)89b2ead528SPaul Burton static int copy_fp_from_sigcontext(void __user *sc)
902db9ca0aSPaul Burton {
91b2ead528SPaul Burton struct mips_abi *abi = current->thread.abi;
922db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
932db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
942db9ca0aSPaul Burton int i;
95b2ead528SPaul Burton int err = 0;
96b2ead528SPaul Burton int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
976f0aba63SPaul Burton u64 fpr_val;
98b2ead528SPaul Burton
99b2ead528SPaul Burton for (i = 0; i < NUM_FPU_REGS; i += inc) {
1006f0aba63SPaul Burton err |= __get_user(fpr_val, &fpregs[i]);
1012db9ca0aSPaul Burton set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val);
102b2ead528SPaul Burton }
103b2ead528SPaul Burton err |= __get_user(current->thread.fpu.fcr31, csr);
1042db9ca0aSPaul Burton
105b2ead528SPaul Burton return err;
106b2ead528SPaul Burton }
107b2ead528SPaul Burton
108b2ead528SPaul Burton #else /* !CONFIG_MIPS_FP_SUPPORT */
1094eec81d7SPaul Burton
copy_fp_to_sigcontext(void __user * sc)1104eec81d7SPaul Burton static int copy_fp_to_sigcontext(void __user *sc)
1114eec81d7SPaul Burton {
1124eec81d7SPaul Burton return 0;
1134eec81d7SPaul Burton }
1144eec81d7SPaul Burton
copy_fp_from_sigcontext(void __user * sc)1154eec81d7SPaul Burton static int copy_fp_from_sigcontext(void __user *sc)
1164eec81d7SPaul Burton {
1174eec81d7SPaul Burton return 0;
1184eec81d7SPaul Burton }
1194eec81d7SPaul Burton
1204eec81d7SPaul Burton #endif /* !CONFIG_MIPS_FP_SUPPORT */
1214eec81d7SPaul Burton
1224eec81d7SPaul Burton /*
123b2ead528SPaul Burton * Wrappers for the assembly _{save,restore}_fp_context functions.
1242db9ca0aSPaul Burton */
save_hw_fp_context(void __user * sc)1252db9ca0aSPaul Burton static int save_hw_fp_context(void __user *sc)
1262db9ca0aSPaul Burton {
1272db9ca0aSPaul Burton struct mips_abi *abi = current->thread.abi;
1282db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
1292db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
1302db9ca0aSPaul Burton
1312db9ca0aSPaul Burton return _save_fp_context(fpregs, csr);
1322db9ca0aSPaul Burton }
1332db9ca0aSPaul Burton
restore_hw_fp_context(void __user * sc)1342db9ca0aSPaul Burton static int restore_hw_fp_context(void __user *sc)
1352db9ca0aSPaul Burton {
1362db9ca0aSPaul Burton struct mips_abi *abi = current->thread.abi;
1372db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
1382db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
1392db9ca0aSPaul Burton
1402db9ca0aSPaul Burton return _restore_fp_context(fpregs, csr);
1412db9ca0aSPaul Burton }
1422db9ca0aSPaul Burton
1432db9ca0aSPaul Burton /*
1442db9ca0aSPaul Burton * Extended context handling.
145bf82cb30SPaul Burton */
146bf82cb30SPaul Burton
sc_to_extcontext(void __user * sc)147bf82cb30SPaul Burton static inline void __user *sc_to_extcontext(void __user *sc)
148bf82cb30SPaul Burton {
149bf82cb30SPaul Burton struct ucontext __user *uc;
150bf82cb30SPaul Burton
151bf82cb30SPaul Burton /*
152bf82cb30SPaul Burton * We can just pretend the sigcontext is always embedded in a struct
153bf82cb30SPaul Burton * ucontext here, because the offset from sigcontext to extended
154bf82cb30SPaul Burton * context is the same in the struct sigframe case.
155bf82cb30SPaul Burton */
156bf82cb30SPaul Burton uc = container_of(sc, struct ucontext, uc_mcontext);
157bf82cb30SPaul Burton return &uc->uc_extcontext;
158bf82cb30SPaul Burton }
159bf82cb30SPaul Burton
160bf82cb30SPaul Burton #ifdef CONFIG_CPU_HAS_MSA
1614eec81d7SPaul Burton
save_msa_extcontext(void __user * buf)1624eec81d7SPaul Burton static int save_msa_extcontext(void __user *buf)
163bf82cb30SPaul Burton {
164bf82cb30SPaul Burton struct msa_extcontext __user *msa = buf;
165bf82cb30SPaul Burton uint64_t val;
166bf82cb30SPaul Burton int i, err;
167bf82cb30SPaul Burton
168bf82cb30SPaul Burton if (!thread_msa_context_live())
169bf82cb30SPaul Burton return 0;
170bf82cb30SPaul Burton
171bf82cb30SPaul Burton /*
172bf82cb30SPaul Burton * Ensure that we can't lose the live MSA context between checking
173bf82cb30SPaul Burton * for it & writing it to memory.
174bf82cb30SPaul Burton */
175bf82cb30SPaul Burton preempt_disable();
176bf82cb30SPaul Burton
177bf82cb30SPaul Burton if (is_msa_enabled()) {
178bf82cb30SPaul Burton /*
179bf82cb30SPaul Burton * There are no EVA versions of the vector register load/store
180bf82cb30SPaul Burton * instructions, so MSA context has to be saved to kernel memory
181bf82cb30SPaul Burton * and then copied to user memory. The save to kernel memory
182bf82cb30SPaul Burton * should already have been done when handling scalar FP
183bf82cb30SPaul Burton * context.
184bf82cb30SPaul Burton */
185bf82cb30SPaul Burton BUG_ON(IS_ENABLED(CONFIG_EVA));
18697f2645fSMasahiro Yamada
187bf82cb30SPaul Burton err = __put_user(read_msa_csr(), &msa->csr);
188bf82cb30SPaul Burton err |= _save_msa_all_upper(&msa->wr);
189bf82cb30SPaul Burton
190bf82cb30SPaul Burton preempt_enable();
191bf82cb30SPaul Burton } else {
192bf82cb30SPaul Burton preempt_enable();
193bf82cb30SPaul Burton
194bf82cb30SPaul Burton err = __put_user(current->thread.fpu.msacsr, &msa->csr);
195bf82cb30SPaul Burton
196bf82cb30SPaul Burton for (i = 0; i < NUM_FPU_REGS; i++) {
197bf82cb30SPaul Burton val = get_fpr64(¤t->thread.fpu.fpr[i], 1);
198bf82cb30SPaul Burton err |= __put_user(val, &msa->wr[i]);
199bf82cb30SPaul Burton }
200bf82cb30SPaul Burton }
201bf82cb30SPaul Burton
202bf82cb30SPaul Burton err |= __put_user(MSA_EXTCONTEXT_MAGIC, &msa->ext.magic);
203bf82cb30SPaul Burton err |= __put_user(sizeof(*msa), &msa->ext.size);
204bf82cb30SPaul Burton
205bf82cb30SPaul Burton return err ? -EFAULT : sizeof(*msa);
206bf82cb30SPaul Burton }
207bf82cb30SPaul Burton
restore_msa_extcontext(void __user * buf,unsigned int size)208bf82cb30SPaul Burton static int restore_msa_extcontext(void __user *buf, unsigned int size)
209bf82cb30SPaul Burton {
210bf82cb30SPaul Burton struct msa_extcontext __user *msa = buf;
211bf82cb30SPaul Burton unsigned long long val;
212bf82cb30SPaul Burton unsigned int csr;
213bf82cb30SPaul Burton int i, err;
214bf82cb30SPaul Burton
215bf82cb30SPaul Burton if (size != sizeof(*msa))
216bf82cb30SPaul Burton return -EINVAL;
217bf82cb30SPaul Burton
218bf82cb30SPaul Burton err = get_user(csr, &msa->csr);
219bf82cb30SPaul Burton if (err)
220bf82cb30SPaul Burton return err;
221bf82cb30SPaul Burton
222bf82cb30SPaul Burton preempt_disable();
223bf82cb30SPaul Burton
224bf82cb30SPaul Burton if (is_msa_enabled()) {
225bf82cb30SPaul Burton /*
226bf82cb30SPaul Burton * There are no EVA versions of the vector register load/store
227bf82cb30SPaul Burton * instructions, so MSA context has to be copied to kernel
228bf82cb30SPaul Burton * memory and later loaded to registers. The same is true of
229bf82cb30SPaul Burton * scalar FP context, so FPU & MSA should have already been
230bf82cb30SPaul Burton * disabled whilst handling scalar FP context.
231bf82cb30SPaul Burton */
232bf82cb30SPaul Burton BUG_ON(IS_ENABLED(CONFIG_EVA));
23397f2645fSMasahiro Yamada
234bf82cb30SPaul Burton write_msa_csr(csr);
235bf82cb30SPaul Burton err |= _restore_msa_all_upper(&msa->wr);
236bf82cb30SPaul Burton preempt_enable();
237bf82cb30SPaul Burton } else {
238bf82cb30SPaul Burton preempt_enable();
239bf82cb30SPaul Burton
240bf82cb30SPaul Burton current->thread.fpu.msacsr = csr;
241bf82cb30SPaul Burton
242bf82cb30SPaul Burton for (i = 0; i < NUM_FPU_REGS; i++) {
243bf82cb30SPaul Burton err |= __get_user(val, &msa->wr[i]);
244bf82cb30SPaul Burton set_fpr64(¤t->thread.fpu.fpr[i], 1, val);
245bf82cb30SPaul Burton }
246bf82cb30SPaul Burton }
247bf82cb30SPaul Burton
248bf82cb30SPaul Burton return err;
249bf82cb30SPaul Burton }
250bf82cb30SPaul Burton
251bf82cb30SPaul Burton #else /* !CONFIG_CPU_HAS_MSA */
2524eec81d7SPaul Burton
save_msa_extcontext(void __user * buf)2534eec81d7SPaul Burton static int save_msa_extcontext(void __user *buf)
2544eec81d7SPaul Burton {
2554eec81d7SPaul Burton return 0;
2564eec81d7SPaul Burton }
2574eec81d7SPaul Burton
restore_msa_extcontext(void __user * buf,unsigned int size)2584eec81d7SPaul Burton static int restore_msa_extcontext(void __user *buf, unsigned int size)
2594eec81d7SPaul Burton {
2604eec81d7SPaul Burton return SIGSYS;
2614eec81d7SPaul Burton }
2624eec81d7SPaul Burton
2634eec81d7SPaul Burton #endif /* !CONFIG_CPU_HAS_MSA */
2644eec81d7SPaul Burton
save_extcontext(void __user * buf)2654eec81d7SPaul Burton static int save_extcontext(void __user *buf)
266bf82cb30SPaul Burton {
267bf82cb30SPaul Burton int sz;
268bf82cb30SPaul Burton
269bf82cb30SPaul Burton sz = save_msa_extcontext(buf);
270bf82cb30SPaul Burton if (sz < 0)
271bf82cb30SPaul Burton return sz;
272bf82cb30SPaul Burton buf += sz;
273bf82cb30SPaul Burton
274bf82cb30SPaul Burton /* If no context was saved then trivially return */
275bf82cb30SPaul Burton if (!sz)
276bf82cb30SPaul Burton return 0;
277bf82cb30SPaul Burton
278bf82cb30SPaul Burton /* Write the end marker */
279bf82cb30SPaul Burton if (__put_user(END_EXTCONTEXT_MAGIC, (u32 *)buf))
280bf82cb30SPaul Burton return -EFAULT;
281bf82cb30SPaul Burton
282bf82cb30SPaul Burton sz += sizeof(((struct extcontext *)NULL)->magic);
283bf82cb30SPaul Burton return sz;
284bf82cb30SPaul Burton }
285bf82cb30SPaul Burton
restore_extcontext(void __user * buf)286bf82cb30SPaul Burton static int restore_extcontext(void __user *buf)
287bf82cb30SPaul Burton {
288bf82cb30SPaul Burton struct extcontext ext;
289bf82cb30SPaul Burton int err;
290bf82cb30SPaul Burton
291bf82cb30SPaul Burton while (1) {
292bf82cb30SPaul Burton err = __get_user(ext.magic, (unsigned int *)buf);
293bf82cb30SPaul Burton if (err)
294bf82cb30SPaul Burton return err;
295bf82cb30SPaul Burton
296bf82cb30SPaul Burton if (ext.magic == END_EXTCONTEXT_MAGIC)
297bf82cb30SPaul Burton return 0;
298bf82cb30SPaul Burton
299bf82cb30SPaul Burton err = __get_user(ext.size, (unsigned int *)(buf
300bf82cb30SPaul Burton + offsetof(struct extcontext, size)));
301bf82cb30SPaul Burton if (err)
302bf82cb30SPaul Burton return err;
303bf82cb30SPaul Burton
304bf82cb30SPaul Burton switch (ext.magic) {
305bf82cb30SPaul Burton case MSA_EXTCONTEXT_MAGIC:
306bf82cb30SPaul Burton err = restore_msa_extcontext(buf, ext.size);
307bf82cb30SPaul Burton break;
308bf82cb30SPaul Burton
309bf82cb30SPaul Burton default:
310bf82cb30SPaul Burton err = -EINVAL;
311bf82cb30SPaul Burton break;
312bf82cb30SPaul Burton }
313bf82cb30SPaul Burton
314bf82cb30SPaul Burton if (err)
315bf82cb30SPaul Burton return err;
316bf82cb30SPaul Burton
317bf82cb30SPaul Burton buf += ext.size;
318bf82cb30SPaul Burton }
319bf82cb30SPaul Burton }
320bf82cb30SPaul Burton
321bf82cb30SPaul Burton /*
322bf82cb30SPaul Burton * Helper routines
323c3fc4ab3SFranck Bui-Huu */
protected_save_fp_context(void __user * sc)324c3fc4ab3SFranck Bui-Huu int protected_save_fp_context(void __user *sc)
325d02a40afSPaul Burton {
326faea6234SAtsushi Nemoto struct mips_abi *abi = current->thread.abi;
3272db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
3282db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
3292db9ca0aSPaul Burton uint32_t __user *used_math = sc + abi->off_sc_used_math;
33064243c2aSPaul Burton unsigned int used, ext_sz;
331bf82cb30SPaul Burton int err;
332faea6234SAtsushi Nemoto
333689ee856SPaul Burton used = used_math() ? USED_FP : 0;
3340d071fa3SPaul Burton if (!used)
335bf82cb30SPaul Burton goto fp_done;
336bf82cb30SPaul Burton
337bf82cb30SPaul Burton if (!test_thread_flag(TIF_32BIT_FPREGS))
3380d071fa3SPaul Burton used |= USED_FR1;
3390d071fa3SPaul Burton if (test_thread_flag(TIF_HYBRID_FPREGS))
3400d071fa3SPaul Burton used |= USED_HYBRID_FPRS;
3410d071fa3SPaul Burton
34264243c2aSPaul Burton /*
343689ee856SPaul Burton * EVA does not have userland equivalents of ldc1 or sdc1, so
344689ee856SPaul Burton * save to the kernel FP context & copy that to userland below.
345689ee856SPaul Burton */
346689ee856SPaul Burton if (IS_ENABLED(CONFIG_EVA))
34797f2645fSMasahiro Yamada lose_fpu(1);
348689ee856SPaul Burton
349689ee856SPaul Burton while (1) {
350faea6234SAtsushi Nemoto lock_fpu_owner();
351faea6234SAtsushi Nemoto if (is_fpu_owner()) {
352ff3aa5f2SPaul Burton err = save_fp_context(sc);
353ff3aa5f2SPaul Burton unlock_fpu_owner();
354faea6234SAtsushi Nemoto } else {
355ff3aa5f2SPaul Burton unlock_fpu_owner();
356ff3aa5f2SPaul Burton err = copy_fp_to_sigcontext(sc);
357ff3aa5f2SPaul Burton }
358ff3aa5f2SPaul Burton if (likely(!err))
359faea6234SAtsushi Nemoto break;
360faea6234SAtsushi Nemoto /* touch the sigcontext and try again */
361faea6234SAtsushi Nemoto err = __put_user(0, &fpregs[0]) |
3622db9ca0aSPaul Burton __put_user(0, &fpregs[31]) |
3632db9ca0aSPaul Burton __put_user(0, csr);
3642db9ca0aSPaul Burton if (err)
365faea6234SAtsushi Nemoto return err; /* really bad sigcontext */
366bf82cb30SPaul Burton }
367faea6234SAtsushi Nemoto
368689ee856SPaul Burton fp_done:
369bf82cb30SPaul Burton ext_sz = err = save_extcontext(sc_to_extcontext(sc));
370bf82cb30SPaul Burton if (err < 0)
371bf82cb30SPaul Burton return err;
372faea6234SAtsushi Nemoto used |= ext_sz ? USED_EXTCONTEXT : 0;
373bf82cb30SPaul Burton
374bf82cb30SPaul Burton return __put_user(used, used_math);
375bf82cb30SPaul Burton }
376faea6234SAtsushi Nemoto
protected_restore_fp_context(void __user * sc)377faea6234SAtsushi Nemoto int protected_restore_fp_context(void __user *sc)
378d02a40afSPaul Burton {
379faea6234SAtsushi Nemoto struct mips_abi *abi = current->thread.abi;
3802db9ca0aSPaul Burton uint64_t __user *fpregs = sc + abi->off_sc_fpregs;
3812db9ca0aSPaul Burton uint32_t __user *csr = sc + abi->off_sc_fpc_csr;
3822db9ca0aSPaul Burton uint32_t __user *used_math = sc + abi->off_sc_used_math;
38364243c2aSPaul Burton unsigned int used;
38464243c2aSPaul Burton int err, sig = 0, tmp __maybe_unused;
385bf82cb30SPaul Burton
38664243c2aSPaul Burton err = __get_user(used, used_math);
38764243c2aSPaul Burton conditional_used_math(used & USED_FP);
3880d071fa3SPaul Burton
38964243c2aSPaul Burton /*
39064243c2aSPaul Burton * The signal handler may have used FPU; give it up if the program
39164243c2aSPaul Burton * doesn't want it following sigreturn.
39264243c2aSPaul Burton */
39364243c2aSPaul Burton if (err || !(used & USED_FP))
394bf82cb30SPaul Burton lose_fpu(0);
39564243c2aSPaul Burton if (err)
396bf82cb30SPaul Burton return err;
39764243c2aSPaul Burton if (!(used & USED_FP))
398bf82cb30SPaul Burton goto fp_done;
399bf82cb30SPaul Burton
40064243c2aSPaul Burton err = sig = fpcsr_pending(csr);
40164243c2aSPaul Burton if (err < 0)
40264243c2aSPaul Burton return err;
40364243c2aSPaul Burton
404689ee856SPaul Burton /*
405689ee856SPaul Burton * EVA does not have userland equivalents of ldc1 or sdc1, so we
406689ee856SPaul Burton * disable the FPU here such that the code below simply copies to
407689ee856SPaul Burton * the kernel FP context.
408689ee856SPaul Burton */
409689ee856SPaul Burton if (IS_ENABLED(CONFIG_EVA))
41097f2645fSMasahiro Yamada lose_fpu(0);
411689ee856SPaul Burton
412689ee856SPaul Burton while (1) {
413faea6234SAtsushi Nemoto lock_fpu_owner();
414faea6234SAtsushi Nemoto if (is_fpu_owner()) {
415ff3aa5f2SPaul Burton err = restore_fp_context(sc);
416ff3aa5f2SPaul Burton unlock_fpu_owner();
417faea6234SAtsushi Nemoto } else {
418ff3aa5f2SPaul Burton unlock_fpu_owner();
419ff3aa5f2SPaul Burton err = copy_fp_from_sigcontext(sc);
420ff3aa5f2SPaul Burton }
421ff3aa5f2SPaul Burton if (likely(!err))
422faea6234SAtsushi Nemoto break;
423faea6234SAtsushi Nemoto /* touch the sigcontext and try again */
424faea6234SAtsushi Nemoto err = __get_user(tmp, &fpregs[0]) |
4252db9ca0aSPaul Burton __get_user(tmp, &fpregs[31]) |
4262db9ca0aSPaul Burton __get_user(tmp, csr);
4272db9ca0aSPaul Burton if (err)
428faea6234SAtsushi Nemoto break; /* really bad sigcontext */
429faea6234SAtsushi Nemoto }
430faea6234SAtsushi Nemoto
431689ee856SPaul Burton fp_done:
432bf82cb30SPaul Burton if (!err && (used & USED_EXTCONTEXT))
4336533af4dSPaul Burton err = restore_extcontext(sc_to_extcontext(sc));
4346533af4dSPaul Burton
435bf82cb30SPaul Burton return err ?: sig;
43664243c2aSPaul Burton }
437faea6234SAtsushi Nemoto
setup_sigcontext(struct pt_regs * regs,struct sigcontext __user * sc)438faea6234SAtsushi Nemoto int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
439c3fc4ab3SFranck Bui-Huu {
440c3fc4ab3SFranck Bui-Huu int err = 0;
441c3fc4ab3SFranck Bui-Huu int i;
442c3fc4ab3SFranck Bui-Huu
443c3fc4ab3SFranck Bui-Huu err |= __put_user(regs->cp0_epc, &sc->sc_pc);
444c3fc4ab3SFranck Bui-Huu
445c3fc4ab3SFranck Bui-Huu err |= __put_user(0, &sc->sc_regs[0]);
446c3fc4ab3SFranck Bui-Huu for (i = 1; i < 32; i++)
447c3fc4ab3SFranck Bui-Huu err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
448c3fc4ab3SFranck Bui-Huu
449c3fc4ab3SFranck Bui-Huu #ifdef CONFIG_CPU_HAS_SMARTMIPS
4509693a853SFranck Bui-Huu err |= __put_user(regs->acx, &sc->sc_acx);
4519693a853SFranck Bui-Huu #endif
4529693a853SFranck Bui-Huu err |= __put_user(regs->hi, &sc->sc_mdhi);
453c3fc4ab3SFranck Bui-Huu err |= __put_user(regs->lo, &sc->sc_mdlo);
454c3fc4ab3SFranck Bui-Huu if (cpu_has_dsp) {
455c3fc4ab3SFranck Bui-Huu err |= __put_user(mfhi1(), &sc->sc_hi1);
456c3fc4ab3SFranck Bui-Huu err |= __put_user(mflo1(), &sc->sc_lo1);
457c3fc4ab3SFranck Bui-Huu err |= __put_user(mfhi2(), &sc->sc_hi2);
458c3fc4ab3SFranck Bui-Huu err |= __put_user(mflo2(), &sc->sc_lo2);
459c3fc4ab3SFranck Bui-Huu err |= __put_user(mfhi3(), &sc->sc_hi3);
460c3fc4ab3SFranck Bui-Huu err |= __put_user(mflo3(), &sc->sc_lo3);
461c3fc4ab3SFranck Bui-Huu err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
462c3fc4ab3SFranck Bui-Huu }
463c3fc4ab3SFranck Bui-Huu
464c3fc4ab3SFranck Bui-Huu
465c3fc4ab3SFranck Bui-Huu /*
466c3fc4ab3SFranck Bui-Huu * Save FPU state to signal context. Signal handler
467c3fc4ab3SFranck Bui-Huu * will "inherit" current FPU state.
468c3fc4ab3SFranck Bui-Huu */
469c3fc4ab3SFranck Bui-Huu err |= protected_save_fp_context(sc);
47016f77de8SPaul Burton
47164243c2aSPaul Burton return err;
472c3fc4ab3SFranck Bui-Huu }
473c3fc4ab3SFranck Bui-Huu
extcontext_max_size(void)474c3fc4ab3SFranck Bui-Huu static size_t extcontext_max_size(void)
475bf82cb30SPaul Burton {
476bf82cb30SPaul Burton size_t sz = 0;
477bf82cb30SPaul Burton
478bf82cb30SPaul Burton /*
479bf82cb30SPaul Burton * The assumption here is that between this point & the point at which
480bf82cb30SPaul Burton * the extended context is saved the size of the context should only
481bf82cb30SPaul Burton * ever be able to shrink (if the task is preempted), but never grow.
482bf82cb30SPaul Burton * That is, what this function returns is an upper bound on the size of
483bf82cb30SPaul Burton * the extended context for the current task at the current time.
484bf82cb30SPaul Burton */
485bf82cb30SPaul Burton
486bf82cb30SPaul Burton if (thread_msa_context_live())
487bf82cb30SPaul Burton sz += sizeof(struct msa_extcontext);
488bf82cb30SPaul Burton
489bf82cb30SPaul Burton /* If any context is saved then we'll append the end marker */
490bf82cb30SPaul Burton if (sz)
491bf82cb30SPaul Burton sz += sizeof(((struct extcontext *)NULL)->magic);
492bf82cb30SPaul Burton
493bf82cb30SPaul Burton return sz;
494bf82cb30SPaul Burton }
495bf82cb30SPaul Burton
fpcsr_pending(unsigned int __user * fpcsr)496bf82cb30SPaul Burton int fpcsr_pending(unsigned int __user *fpcsr)
497c6a2f467SAtsushi Nemoto {
498c6a2f467SAtsushi Nemoto int err, sig = 0;
499c6a2f467SAtsushi Nemoto unsigned int csr, enabled;
500c6a2f467SAtsushi Nemoto
501c6a2f467SAtsushi Nemoto err = __get_user(csr, fpcsr);
502c6a2f467SAtsushi Nemoto enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
503c6a2f467SAtsushi Nemoto /*
504c6a2f467SAtsushi Nemoto * If the signal handler set some FPU exceptions, clear it and
505c6a2f467SAtsushi Nemoto * send SIGFPE.
506c6a2f467SAtsushi Nemoto */
507c6a2f467SAtsushi Nemoto if (csr & enabled) {
508c6a2f467SAtsushi Nemoto csr &= ~enabled;
509c6a2f467SAtsushi Nemoto err |= __put_user(csr, fpcsr);
510c6a2f467SAtsushi Nemoto sig = SIGFPE;
511c6a2f467SAtsushi Nemoto }
512c6a2f467SAtsushi Nemoto return err ?: sig;
513c6a2f467SAtsushi Nemoto }
514c6a2f467SAtsushi Nemoto
restore_sigcontext(struct pt_regs * regs,struct sigcontext __user * sc)515c6a2f467SAtsushi Nemoto int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
516c3fc4ab3SFranck Bui-Huu {
517c3fc4ab3SFranck Bui-Huu unsigned long treg;
518c3fc4ab3SFranck Bui-Huu int err = 0;
519c3fc4ab3SFranck Bui-Huu int i;
520c3fc4ab3SFranck Bui-Huu
521c3fc4ab3SFranck Bui-Huu /* Always make any pending restarted system calls return -EINTR */
522c3fc4ab3SFranck Bui-Huu current->restart_block.fn = do_no_restart_syscall;
523f56141e3SAndy Lutomirski
524c3fc4ab3SFranck Bui-Huu err |= __get_user(regs->cp0_epc, &sc->sc_pc);
525c3fc4ab3SFranck Bui-Huu
5269693a853SFranck Bui-Huu #ifdef CONFIG_CPU_HAS_SMARTMIPS
5279693a853SFranck Bui-Huu err |= __get_user(regs->acx, &sc->sc_acx);
5289693a853SFranck Bui-Huu #endif
5299693a853SFranck Bui-Huu err |= __get_user(regs->hi, &sc->sc_mdhi);
530c3fc4ab3SFranck Bui-Huu err |= __get_user(regs->lo, &sc->sc_mdlo);
531c3fc4ab3SFranck Bui-Huu if (cpu_has_dsp) {
532c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
533c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
534c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
535c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
536c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
537c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
538c3fc4ab3SFranck Bui-Huu err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
539c3fc4ab3SFranck Bui-Huu }
540c3fc4ab3SFranck Bui-Huu
541c3fc4ab3SFranck Bui-Huu for (i = 1; i < 32; i++)
542c3fc4ab3SFranck Bui-Huu err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
543c3fc4ab3SFranck Bui-Huu
544c3fc4ab3SFranck Bui-Huu return err ?: protected_restore_fp_context(sc);
54564243c2aSPaul Burton }
546c3fc4ab3SFranck Bui-Huu
547c3fc4ab3SFranck Bui-Huu #ifdef CONFIG_WAR_ICACHE_REFILLS
548886ee136SThomas Bogendoerfer #define SIGMASK ~(cpu_icache_line_size()-1)
549886ee136SThomas Bogendoerfer #else
550886ee136SThomas Bogendoerfer #define SIGMASK ALMASK
551886ee136SThomas Bogendoerfer #endif
552886ee136SThomas Bogendoerfer
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,size_t frame_size)553886ee136SThomas Bogendoerfer void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
5547c4f5635SRichard Weinberger size_t frame_size)
555c3fc4ab3SFranck Bui-Huu {
556c3fc4ab3SFranck Bui-Huu unsigned long sp;
557c3fc4ab3SFranck Bui-Huu
558c3fc4ab3SFranck Bui-Huu /* Leave space for potential extended context */
559bf82cb30SPaul Burton frame_size += extcontext_max_size();
560bf82cb30SPaul Burton
561bf82cb30SPaul Burton /* Default to using normal stack */
562c3fc4ab3SFranck Bui-Huu sp = regs->regs[29];
563c3fc4ab3SFranck Bui-Huu
564c3fc4ab3SFranck Bui-Huu /*
565c3fc4ab3SFranck Bui-Huu * If we are on the alternate signal stack and would overflow it, don't.
5660ebd37a2STiezhu Yang * Return an always-bogus address instead so we will die with SIGSEGV.
5670ebd37a2STiezhu Yang */
5680ebd37a2STiezhu Yang if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
5690ebd37a2STiezhu Yang return (void __user __force *)(-1UL);
5700ebd37a2STiezhu Yang
5710ebd37a2STiezhu Yang /*
5720ebd37a2STiezhu Yang * FPU emulator may have it's own trampoline active just
573c3fc4ab3SFranck Bui-Huu * above the user stack, 16-bytes before the next lowest
574c3fc4ab3SFranck Bui-Huu * 16 byte boundary. Try to avoid trashing it.
575c3fc4ab3SFranck Bui-Huu */
576c3fc4ab3SFranck Bui-Huu sp -= 32;
577c3fc4ab3SFranck Bui-Huu
578c3fc4ab3SFranck Bui-Huu sp = sigsp(sp, ksig);
5797c4f5635SRichard Weinberger
580c3fc4ab3SFranck Bui-Huu return (void __user *)((sp - frame_size) & SIGMASK);
581886ee136SThomas Bogendoerfer }
582c3fc4ab3SFranck Bui-Huu
583c3fc4ab3SFranck Bui-Huu /*
584c3fc4ab3SFranck Bui-Huu * Atomically swap in the new signal mask, and wait for a signal.
5851da177e4SLinus Torvalds */
5861da177e4SLinus Torvalds
5871da177e4SLinus Torvalds #ifdef CONFIG_TRAD_SIGNALS
SYSCALL_DEFINE1(sigsuspend,sigset_t __user *,uset)5881da177e4SLinus Torvalds SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset)
5891910f4abSAl Viro {
5901da177e4SLinus Torvalds return sys_rt_sigsuspend(uset, sizeof(sigset_t));
5911910f4abSAl Viro }
5921da177e4SLinus Torvalds #endif
5931da177e4SLinus Torvalds
5941da177e4SLinus Torvalds #ifdef CONFIG_TRAD_SIGNALS
SYSCALL_DEFINE3(sigaction,int,sig,const struct sigaction __user *,act,struct sigaction __user *,oact)5951da177e4SLinus Torvalds SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
596dbda6ac0SRalf Baechle struct sigaction __user *, oact)
597dbda6ac0SRalf Baechle {
5981da177e4SLinus Torvalds struct k_sigaction new_ka, old_ka;
5991da177e4SLinus Torvalds int ret;
6001da177e4SLinus Torvalds int err = 0;
6011da177e4SLinus Torvalds
6021da177e4SLinus Torvalds if (act) {
6031da177e4SLinus Torvalds old_sigset_t mask;
6041da177e4SLinus Torvalds
6051da177e4SLinus Torvalds if (!access_ok(act, sizeof(*act)))
60696d4f267SLinus Torvalds return -EFAULT;
6071da177e4SLinus Torvalds err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
6081da177e4SLinus Torvalds err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
6091da177e4SLinus Torvalds err |= __get_user(mask, &act->sa_mask.sig[0]);
6101da177e4SLinus Torvalds if (err)
6111da177e4SLinus Torvalds return -EFAULT;
6121da177e4SLinus Torvalds
6131da177e4SLinus Torvalds siginitset(&new_ka.sa.sa_mask, mask);
6141da177e4SLinus Torvalds }
6151da177e4SLinus Torvalds
6161da177e4SLinus Torvalds ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
6171da177e4SLinus Torvalds
6181da177e4SLinus Torvalds if (!ret && oact) {
6191da177e4SLinus Torvalds if (!access_ok(oact, sizeof(*oact)))
62096d4f267SLinus Torvalds return -EFAULT;
6211da177e4SLinus Torvalds err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
6221da177e4SLinus Torvalds err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
6231da177e4SLinus Torvalds err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
6241da177e4SLinus Torvalds err |= __put_user(0, &oact->sa_mask.sig[1]);
6251da177e4SLinus Torvalds err |= __put_user(0, &oact->sa_mask.sig[2]);
6261da177e4SLinus Torvalds err |= __put_user(0, &oact->sa_mask.sig[3]);
6271da177e4SLinus Torvalds if (err)
6281da177e4SLinus Torvalds return -EFAULT;
6291da177e4SLinus Torvalds }
6301da177e4SLinus Torvalds
6311da177e4SLinus Torvalds return ret;
6321da177e4SLinus Torvalds }
6331da177e4SLinus Torvalds #endif
6341da177e4SLinus Torvalds
6351da177e4SLinus Torvalds #ifdef CONFIG_TRAD_SIGNALS
sys_sigreturn(void)6361da177e4SLinus Torvalds asmlinkage void sys_sigreturn(void)
63796a68b14SPaul Burton {
6381da177e4SLinus Torvalds struct sigframe __user *frame;
6399bbf28a3SAtsushi Nemoto struct pt_regs *regs;
64096a68b14SPaul Burton sigset_t blocked;
6411da177e4SLinus Torvalds int sig;
642c6a2f467SAtsushi Nemoto
6431da177e4SLinus Torvalds regs = current_pt_regs();
64496a68b14SPaul Burton frame = (struct sigframe __user *)regs->regs[29];
64596a68b14SPaul Burton if (!access_ok(frame, sizeof(*frame)))
64696d4f267SLinus Torvalds goto badframe;
6471da177e4SLinus Torvalds if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
6481da177e4SLinus Torvalds goto badframe;
6491da177e4SLinus Torvalds
6501da177e4SLinus Torvalds set_current_blocked(&blocked);
6518598f3cdSMatt Fleming
6521da177e4SLinus Torvalds sig = restore_sigcontext(regs, &frame->sf_sc);
65396a68b14SPaul Burton if (sig < 0)
654c6a2f467SAtsushi Nemoto goto badframe;
6551da177e4SLinus Torvalds else if (sig)
656c6a2f467SAtsushi Nemoto force_sig(sig);
6573cf5d076SEric W. Biederman
6581da177e4SLinus Torvalds /*
6591da177e4SLinus Torvalds * Don't let your children do this ...
6601da177e4SLinus Torvalds */
6611da177e4SLinus Torvalds __asm__ __volatile__(
6621da177e4SLinus Torvalds "move\t$29, %0\n\t"
6631da177e4SLinus Torvalds "j\tsyscall_exit"
6641da177e4SLinus Torvalds : /* no outputs */
6651da177e4SLinus Torvalds : "r" (regs));
66696a68b14SPaul Burton /* Unreached */
6671da177e4SLinus Torvalds
6681da177e4SLinus Torvalds badframe:
6691da177e4SLinus Torvalds force_sig(SIGSEGV);
6703cf5d076SEric W. Biederman }
6711da177e4SLinus Torvalds #endif /* CONFIG_TRAD_SIGNALS */
672e50c0a8fSRalf Baechle
sys_rt_sigreturn(void)6731da177e4SLinus Torvalds asmlinkage void sys_rt_sigreturn(void)
67496a68b14SPaul Burton {
6751da177e4SLinus Torvalds struct rt_sigframe __user *frame;
6769bbf28a3SAtsushi Nemoto struct pt_regs *regs;
67796a68b14SPaul Burton sigset_t set;
6781da177e4SLinus Torvalds int sig;
679c6a2f467SAtsushi Nemoto
6801da177e4SLinus Torvalds regs = current_pt_regs();
68196a68b14SPaul Burton frame = (struct rt_sigframe __user *)regs->regs[29];
68296a68b14SPaul Burton if (!access_ok(frame, sizeof(*frame)))
68396d4f267SLinus Torvalds goto badframe;
6841da177e4SLinus Torvalds if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
6851da177e4SLinus Torvalds goto badframe;
6861da177e4SLinus Torvalds
6871da177e4SLinus Torvalds set_current_blocked(&set);
6888598f3cdSMatt Fleming
6891da177e4SLinus Torvalds sig = restore_sigcontext(regs, &frame->rs_uc.uc_mcontext);
69096a68b14SPaul Burton if (sig < 0)
691c6a2f467SAtsushi Nemoto goto badframe;
6921da177e4SLinus Torvalds else if (sig)
693c6a2f467SAtsushi Nemoto force_sig(sig);
6943cf5d076SEric W. Biederman
6951da177e4SLinus Torvalds if (restore_altstack(&frame->rs_uc.uc_stack))
696ea536ad4SAl Viro goto badframe;
697ea536ad4SAl Viro
6981da177e4SLinus Torvalds /*
6991da177e4SLinus Torvalds * Don't let your children do this ...
7001da177e4SLinus Torvalds */
7011da177e4SLinus Torvalds __asm__ __volatile__(
7021da177e4SLinus Torvalds "move\t$29, %0\n\t"
7031da177e4SLinus Torvalds "j\tsyscall_exit"
7041da177e4SLinus Torvalds : /* no outputs */
7051da177e4SLinus Torvalds : "r" (regs));
70696a68b14SPaul Burton /* Unreached */
7071da177e4SLinus Torvalds
7081da177e4SLinus Torvalds badframe:
7091da177e4SLinus Torvalds force_sig(SIGSEGV);
7103cf5d076SEric W. Biederman }
7111da177e4SLinus Torvalds
7121da177e4SLinus Torvalds #ifdef CONFIG_TRAD_SIGNALS
setup_frame(void * sig_return,struct ksignal * ksig,struct pt_regs * regs,sigset_t * set)7131da177e4SLinus Torvalds static int setup_frame(void *sig_return, struct ksignal *ksig,
71481d103bfSRichard Weinberger struct pt_regs *regs, sigset_t *set)
71581d103bfSRichard Weinberger {
7161da177e4SLinus Torvalds struct sigframe __user *frame;
7179bbf28a3SAtsushi Nemoto int err = 0;
7181da177e4SLinus Torvalds
7191da177e4SLinus Torvalds frame = get_sigframe(ksig, regs, sizeof(*frame));
7207c4f5635SRichard Weinberger if (!access_ok(frame, sizeof (*frame)))
72196d4f267SLinus Torvalds return -EFAULT;
72281d103bfSRichard Weinberger
7231da177e4SLinus Torvalds err |= setup_sigcontext(regs, &frame->sf_sc);
7241da177e4SLinus Torvalds err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
7251da177e4SLinus Torvalds if (err)
7261da177e4SLinus Torvalds return -EFAULT;
72781d103bfSRichard Weinberger
7281da177e4SLinus Torvalds /*
7291da177e4SLinus Torvalds * Arguments to signal handler:
7301da177e4SLinus Torvalds *
7311da177e4SLinus Torvalds * a0 = signal number
7321da177e4SLinus Torvalds * a1 = 0 (should be cause)
7331da177e4SLinus Torvalds * a2 = pointer to struct sigcontext
7341da177e4SLinus Torvalds *
7351da177e4SLinus Torvalds * $25 and c0_epc point to the signal handler, $29 points to the
7361da177e4SLinus Torvalds * struct sigframe.
7371da177e4SLinus Torvalds */
7381da177e4SLinus Torvalds regs->regs[ 4] = ksig->sig;
73981d103bfSRichard Weinberger regs->regs[ 5] = 0;
7401da177e4SLinus Torvalds regs->regs[ 6] = (unsigned long) &frame->sf_sc;
7411da177e4SLinus Torvalds regs->regs[29] = (unsigned long) frame;
7421da177e4SLinus Torvalds regs->regs[31] = (unsigned long) sig_return;
743d814c28cSDavid Daney regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
74481d103bfSRichard Weinberger
7451da177e4SLinus Torvalds DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
746722bb63dSFranck Bui-Huu current->comm, current->pid,
7471da177e4SLinus Torvalds frame, regs->cp0_epc, regs->regs[31]);
748722bb63dSFranck Bui-Huu return 0;
7497b3e2fc8SRalf Baechle }
7501da177e4SLinus Torvalds #endif
7511da177e4SLinus Torvalds
setup_rt_frame(void * sig_return,struct ksignal * ksig,struct pt_regs * regs,sigset_t * set)7521da177e4SLinus Torvalds static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
75381d103bfSRichard Weinberger struct pt_regs *regs, sigset_t *set)
75481d103bfSRichard Weinberger {
7551da177e4SLinus Torvalds struct rt_sigframe __user *frame;
7569bbf28a3SAtsushi Nemoto
7571da177e4SLinus Torvalds frame = get_sigframe(ksig, regs, sizeof(*frame));
7587c4f5635SRichard Weinberger if (!access_ok(frame, sizeof (*frame)))
75996d4f267SLinus Torvalds return -EFAULT;
76081d103bfSRichard Weinberger
7611da177e4SLinus Torvalds /* Create siginfo. */
7621da177e4SLinus Torvalds if (copy_siginfo_to_user(&frame->rs_info, &ksig->info))
763408bd9ddSTiezhu Yang return -EFAULT;
764408bd9ddSTiezhu Yang
7651da177e4SLinus Torvalds /* Create the ucontext. */
7661da177e4SLinus Torvalds if (__put_user(0, &frame->rs_uc.uc_flags))
767408bd9ddSTiezhu Yang return -EFAULT;
768408bd9ddSTiezhu Yang if (__put_user(NULL, &frame->rs_uc.uc_link))
769408bd9ddSTiezhu Yang return -EFAULT;
770408bd9ddSTiezhu Yang if (__save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]))
771408bd9ddSTiezhu Yang return -EFAULT;
772408bd9ddSTiezhu Yang if (setup_sigcontext(regs, &frame->rs_uc.uc_mcontext))
773408bd9ddSTiezhu Yang return -EFAULT;
774408bd9ddSTiezhu Yang if (__copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)))
775408bd9ddSTiezhu Yang return -EFAULT;
77681d103bfSRichard Weinberger
7771da177e4SLinus Torvalds /*
7781da177e4SLinus Torvalds * Arguments to signal handler:
7791da177e4SLinus Torvalds *
7801da177e4SLinus Torvalds * a0 = signal number
7811da177e4SLinus Torvalds * a1 = 0 (should be cause)
7821da177e4SLinus Torvalds * a2 = pointer to ucontext
7831da177e4SLinus Torvalds *
7841da177e4SLinus Torvalds * $25 and c0_epc point to the signal handler, $29 points to
7851da177e4SLinus Torvalds * the struct rt_sigframe.
7861da177e4SLinus Torvalds */
7871da177e4SLinus Torvalds regs->regs[ 4] = ksig->sig;
78881d103bfSRichard Weinberger regs->regs[ 5] = (unsigned long) &frame->rs_info;
7891da177e4SLinus Torvalds regs->regs[ 6] = (unsigned long) &frame->rs_uc;
7901da177e4SLinus Torvalds regs->regs[29] = (unsigned long) frame;
7911da177e4SLinus Torvalds regs->regs[31] = (unsigned long) sig_return;
792d814c28cSDavid Daney regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
79381d103bfSRichard Weinberger
7941da177e4SLinus Torvalds DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
795722bb63dSFranck Bui-Huu current->comm, current->pid,
7961da177e4SLinus Torvalds frame, regs->cp0_epc, regs->regs[31]);
7971da177e4SLinus Torvalds
798722bb63dSFranck Bui-Huu return 0;
7997b3e2fc8SRalf Baechle }
8001da177e4SLinus Torvalds
8011da177e4SLinus Torvalds struct mips_abi mips_abi = {
802151fd6acSRalf Baechle #ifdef CONFIG_TRAD_SIGNALS
803151fd6acSRalf Baechle .setup_frame = setup_frame,
804151fd6acSRalf Baechle #endif
805151fd6acSRalf Baechle .setup_rt_frame = setup_rt_frame,
806151fd6acSRalf Baechle .restart = __NR_restart_syscall,
80777856100SPaul Burton
80877856100SPaul Burton .off_sc_fpregs = offsetof(struct sigcontext, sc_fpregs),
80977856100SPaul Burton .off_sc_fpc_csr = offsetof(struct sigcontext, sc_fpc_csr),
81077856100SPaul Burton .off_sc_used_math = offsetof(struct sigcontext, sc_used_math),
81177856100SPaul Burton
812ebb5e78cSAlex Smith .vdso = &vdso_image,
813ebb5e78cSAlex Smith };
814151fd6acSRalf Baechle
handle_signal(struct ksignal * ksig,struct pt_regs * regs)815151fd6acSRalf Baechle static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
81681d103bfSRichard Weinberger {
8171da177e4SLinus Torvalds sigset_t *oldset = sigmask_to_save();
818b7f9a11aSAl Viro int ret;
819129bc8f7SRalf Baechle struct mips_abi *abi = current->thread.abi;
820d814c28cSDavid Daney void *vdso = current->mm->context.vdso;
821d814c28cSDavid Daney
822129bc8f7SRalf Baechle /*
823432c6bacSPaul Burton * If we were emulating a delay slot instruction, exit that frame such
824432c6bacSPaul Burton * that addresses in the sigframe are as expected for userland and we
825432c6bacSPaul Burton * don't have a problem if we reuse the thread's frame for an
826432c6bacSPaul Burton * instruction within the signal handler.
827432c6bacSPaul Burton */
828432c6bacSPaul Burton dsemul_thread_rollback(regs);
829432c6bacSPaul Burton
830432c6bacSPaul Burton if (regs->regs[0]) {
8318f5a00ebSAl Viro switch(regs->regs[2]) {
8328f5a00ebSAl Viro case ERESTART_RESTARTBLOCK:
8331da177e4SLinus Torvalds case ERESTARTNOHAND:
8341da177e4SLinus Torvalds regs->regs[2] = EINTR;
8351da177e4SLinus Torvalds break;
8361da177e4SLinus Torvalds case ERESTARTSYS:
8371da177e4SLinus Torvalds if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
83881d103bfSRichard Weinberger regs->regs[2] = EINTR;
8391da177e4SLinus Torvalds break;
8401da177e4SLinus Torvalds }
8411da177e4SLinus Torvalds fallthrough;
842c9b02990SLiangliang Huang case ERESTARTNOINTR:
8438f5a00ebSAl Viro regs->regs[7] = regs->regs[26];
8441da177e4SLinus Torvalds regs->regs[2] = regs->regs[0];
8458f5a00ebSAl Viro regs->cp0_epc -= 4;
8468f5a00ebSAl Viro }
8471da177e4SLinus Torvalds
8481da177e4SLinus Torvalds regs->regs[0] = 0; /* Don't deal with this again. */
8491da177e4SLinus Torvalds }
8508f5a00ebSAl Viro
8511da177e4SLinus Torvalds rseq_signal_deliver(ksig, regs);
852662d855cSPaul Burton
8539ea141adSPaul Burton if (sig_uses_siginfo(&ksig->ka, abi))
8547939469dSLeonid Yegoshin ret = abi->setup_rt_frame(vdso + abi->vdso->off_rt_sigreturn,
855ebb5e78cSAlex Smith ksig, regs, oldset);
85681d103bfSRichard Weinberger else
8571da177e4SLinus Torvalds ret = abi->setup_frame(vdso + abi->vdso->off_sigreturn,
858ebb5e78cSAlex Smith ksig, regs, oldset);
859ebb5e78cSAlex Smith
8601da177e4SLinus Torvalds signal_setup_done(ret, ksig, 0);
86181d103bfSRichard Weinberger }
8621da177e4SLinus Torvalds
do_signal(struct pt_regs * regs)8631da177e4SLinus Torvalds static void do_signal(struct pt_regs *regs)
864151fd6acSRalf Baechle {
8651da177e4SLinus Torvalds struct ksignal ksig;
86681d103bfSRichard Weinberger
8671da177e4SLinus Torvalds if (get_signal(&ksig)) {
86881d103bfSRichard Weinberger /* Whee! Actually deliver the signal. */
8697b3e2fc8SRalf Baechle handle_signal(&ksig, regs);
87081d103bfSRichard Weinberger return;
87145887e12SRalf Baechle }
8727b3e2fc8SRalf Baechle
8731da177e4SLinus Torvalds if (regs->regs[0]) {
8741da177e4SLinus Torvalds switch (regs->regs[2]) {
8759ec9b5acSRalf Baechle case ERESTARTNOHAND:
8769ec9b5acSRalf Baechle case ERESTARTSYS:
8779ec9b5acSRalf Baechle case ERESTARTNOINTR:
8789ec9b5acSRalf Baechle regs->regs[2] = regs->regs[0];
8798f5a00ebSAl Viro regs->regs[7] = regs->regs[26];
8801da177e4SLinus Torvalds regs->cp0_epc -= 4;
8818f5a00ebSAl Viro break;
8829ec9b5acSRalf Baechle
8839ec9b5acSRalf Baechle case ERESTART_RESTARTBLOCK:
8849ec9b5acSRalf Baechle regs->regs[2] = current->thread.abi->restart;
885151fd6acSRalf Baechle regs->regs[7] = regs->regs[26];
8861da177e4SLinus Torvalds regs->cp0_epc -= 4;
8871da177e4SLinus Torvalds break;
8889ec9b5acSRalf Baechle }
8891da177e4SLinus Torvalds regs->regs[0] = 0; /* Don't deal with this again. */
89013fdd31aSRalf Baechle }
8911da177e4SLinus Torvalds
8927b3e2fc8SRalf Baechle /*
8937b3e2fc8SRalf Baechle * If there's no signal to deliver, we just put the saved sigmask
8947b3e2fc8SRalf Baechle * back
8957b3e2fc8SRalf Baechle */
8967b3e2fc8SRalf Baechle restore_saved_sigmask();
89751a7b448SAl Viro }
8981da177e4SLinus Torvalds
8991da177e4SLinus Torvalds /*
9001da177e4SLinus Torvalds * notification of userspace execution resumption
9011da177e4SLinus Torvalds * - triggered by the TIF_WORK_MASK flags
9027b3e2fc8SRalf Baechle */
do_notify_resume(struct pt_regs * regs,void * unused,__u32 thread_info_flags)9031da177e4SLinus Torvalds asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
9047b3e2fc8SRalf Baechle __u32 thread_info_flags)
9051da177e4SLinus Torvalds {
9061da177e4SLinus Torvalds local_irq_enable();
9071f717929SRalf Baechle
9081f717929SRalf Baechle user_exit();
909c3fc5cd5SRalf Baechle
910c3fc5cd5SRalf Baechle if (thread_info_flags & _TIF_UPROBE)
91140e084a5SRalf Baechle uprobe_notify_resume(regs);
91240e084a5SRalf Baechle
91340e084a5SRalf Baechle /* deal with pending signal delivery */
9141da177e4SLinus Torvalds if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))
915f45c184bSJens Axboe do_signal(regs);
916151fd6acSRalf Baechle
917d0420c83SDavid Howells if (thread_info_flags & _TIF_NOTIFY_RESUME)
918a68de80fSSean Christopherson resume_user_mode_work(regs);
919*03248addSEric W. Biederman
920c3fc5cd5SRalf Baechle user_enter();
921c3fc5cd5SRalf Baechle }
9221da177e4SLinus Torvalds
923137f6f3eSRalf Baechle #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
smp_save_fp_context(void __user * sc)9244eec81d7SPaul Burton static int smp_save_fp_context(void __user *sc)
9252db9ca0aSPaul Burton {
926137f6f3eSRalf Baechle return raw_cpu_has_fpu
927137f6f3eSRalf Baechle ? save_hw_fp_context(sc)
9282db9ca0aSPaul Burton : copy_fp_to_sigcontext(sc);
929b2ead528SPaul Burton }
930137f6f3eSRalf Baechle
smp_restore_fp_context(void __user * sc)931137f6f3eSRalf Baechle static int smp_restore_fp_context(void __user *sc)
9322db9ca0aSPaul Burton {
933137f6f3eSRalf Baechle return raw_cpu_has_fpu
934137f6f3eSRalf Baechle ? restore_hw_fp_context(sc)
9352db9ca0aSPaul Burton : copy_fp_from_sigcontext(sc);
936b2ead528SPaul Burton }
937137f6f3eSRalf Baechle #endif
938137f6f3eSRalf Baechle
signal_setup(void)939137f6f3eSRalf Baechle static int signal_setup(void)
940137f6f3eSRalf Baechle {
941137f6f3eSRalf Baechle /*
942f1fe2d21SPaul Burton * The offset from sigcontext to extended context should be the same
943f1fe2d21SPaul Burton * regardless of the type of signal, such that userland can always know
944f1fe2d21SPaul Burton * where to look if it wishes to find the extended context structures.
945f1fe2d21SPaul Burton */
946f1fe2d21SPaul Burton BUILD_BUG_ON((offsetof(struct sigframe, sf_extcontext) -
947f1fe2d21SPaul Burton offsetof(struct sigframe, sf_sc)) !=
948f1fe2d21SPaul Burton (offsetof(struct rt_sigframe, rs_uc.uc_extcontext) -
949f1fe2d21SPaul Burton offsetof(struct rt_sigframe, rs_uc.uc_mcontext)));
950f1fe2d21SPaul Burton
951f1fe2d21SPaul Burton #if defined(CONFIG_SMP) && defined(CONFIG_MIPS_FP_SUPPORT)
9524eec81d7SPaul Burton /* For now just do the cpu_has_fpu check when the functions are invoked */
953137f6f3eSRalf Baechle save_fp_context = smp_save_fp_context;
954137f6f3eSRalf Baechle restore_fp_context = smp_restore_fp_context;
955137f6f3eSRalf Baechle #else
956137f6f3eSRalf Baechle if (cpu_has_fpu) {
957137f6f3eSRalf Baechle save_fp_context = save_hw_fp_context;
9582db9ca0aSPaul Burton restore_fp_context = restore_hw_fp_context;
9592db9ca0aSPaul Burton } else {
960137f6f3eSRalf Baechle save_fp_context = copy_fp_to_sigcontext;
96114fa12dfSPaul Burton restore_fp_context = copy_fp_from_sigcontext;
96214fa12dfSPaul Burton }
963137f6f3eSRalf Baechle #endif /* CONFIG_SMP */
964ca750649SLeonid Yegoshin
965137f6f3eSRalf Baechle return 0;
966137f6f3eSRalf Baechle }
967137f6f3eSRalf Baechle
968137f6f3eSRalf Baechle arch_initcall(signal_setup);
969137f6f3eSRalf Baechle