sparc/kernel/sigutil_64.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <linux/kernel.h>
0003 #include <linux/types.h>
0004 #include <linux/thread_info.h>
0005 #include <linux/uaccess.h>
0006 #include <linux/errno.h>
0007
0008 #include <asm/sigcontext.h>
0009 #include <asm/fpumacro.h>
0010 #include <asm/ptrace.h>
0011 #include <asm/switch_to.h>
0012
0013 #include "sigutil.h"
0014
0015 int save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
0016 {
0017     unsigned long *fpregs = current_thread_info()->fpregs;
0018     unsigned long fprs;
0019     int err = 0;
0020
0021     fprs = current_thread_info()->fpsaved[0];
0022     if (fprs & FPRS_DL)
0023         err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
0024                     (sizeof(unsigned int) * 32));
0025     if (fprs & FPRS_DU)
0026         err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
0027                     (sizeof(unsigned int) * 32));
0028     err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
0029     err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
0030     err |= __put_user(fprs, &fpu->si_fprs);
0031
0032     return err;
0033 }
0034
0035 int restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
0036 {
0037     unsigned long *fpregs = current_thread_info()->fpregs;
0038     unsigned long fprs;
0039     int err;
0040
0041     if (((unsigned long) fpu) & 7)
0042         return -EFAULT;
0043
0044     err = get_user(fprs, &fpu->si_fprs);
0045     fprs_write(0);
0046     regs->tstate &= ~TSTATE_PEF;
0047     if (fprs & FPRS_DL)
0048         err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
0049                        (sizeof(unsigned int) * 32));
0050     if (fprs & FPRS_DU)
0051         err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32],
0052                        (sizeof(unsigned int) * 32));
0053     err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
0054     err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
0055     current_thread_info()->fpsaved[0] |= fprs;
0056     return err;
0057 }
0058
0059 int save_rwin_state(int wsaved, __siginfo_rwin_t __user *rwin)
0060 {
0061     int i, err = __put_user(wsaved, &rwin->wsaved);
0062
0063     for (i = 0; i < wsaved; i++) {
0064         struct reg_window *rp = &current_thread_info()->reg_window[i];
0065         unsigned long fp = current_thread_info()->rwbuf_stkptrs[i];
0066
0067         err |= copy_to_user(&rwin->reg_window[i], rp,
0068                     sizeof(struct reg_window));
0069         err |= __put_user(fp, &rwin->rwbuf_stkptrs[i]);
0070     }
0071     return err;
0072 }
0073
0074 int restore_rwin_state(__siginfo_rwin_t __user *rp)
0075 {
0076     struct thread_info *t = current_thread_info();
0077     int i, wsaved, err;
0078
0079     if (((unsigned long) rp) & 7)
0080         return -EFAULT;
0081
0082     get_user(wsaved, &rp->wsaved);
0083     if (wsaved > NSWINS)
0084         return -EFAULT;
0085
0086     err = 0;
0087     for (i = 0; i < wsaved; i++) {
0088         err |= copy_from_user(&t->reg_window[i],
0089                       &rp->reg_window[i],
0090                       sizeof(struct reg_window));
0091         err |= __get_user(t->rwbuf_stkptrs[i],
0092                   &rp->rwbuf_stkptrs[i]);
0093     }
0094     if (err)
0095         return err;
0096
0097     set_thread_wsaved(wsaved);
0098     synchronize_user_stack();
0099     if (get_thread_wsaved())
0100         return -EFAULT;
0101     return 0;
0102 }