static int fpa_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &task_thread_info(target)->fpstate, 0, sizeof(struct user_fp)); }
static int gpr_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { struct pt_regs *regs = task_pt_regs(target); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, sizeof(*regs)); }
static int fpregs32_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { const unsigned long *fpregs = target->thread.float_regs; int ret = 0; #if 0 if (target == current) save_and_clear_fpu(); #endif ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, fpregs, 0, 32 * sizeof(u32)); if (!ret) ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 32 * sizeof(u32), 33 * sizeof(u32)); if (!ret) ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &target->thread.fsr, 33 * sizeof(u32), 34 * sizeof(u32)); if (!ret) { unsigned long val; val = (1 << 8) | (8 << 16); ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &val, 34 * sizeof(u32), 35 * sizeof(u32)); } if (!ret) ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 35 * sizeof(u32), -1); return ret; }
static int system_call_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int syscallno = task_pt_regs(target)->syscallno; return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &syscallno, 0, -1); }
/* Copy the FP mode setting to the supplied NT_MIPS_FP_MODE buffer. */ static int fp_mode_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int fp_mode; fp_mode = mips_get_process_fp_mode(target); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &fp_mode, 0, sizeof(fp_mode)); }
int metag_gp_regs_copyout(const struct pt_regs *regs, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { const void *ptr; unsigned long data; int ret; /* D{0-1}.{0-7} */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs->ctx.DX, 0, 4*16); if (ret) goto out; /* A{0-1}.{0-1} */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs->ctx.AX, 4*16, 4*20); if (ret) goto out; /* A{0-1}.2 */ if (regs->ctx.SaveMask & TBICTX_XEXT_BIT) ptr = regs->ctx.Ext.Ctx.pExt; else ptr = ®s->ctx.Ext.AX2; ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ptr, 4*20, 4*22); if (ret) goto out; /* A{0-1}.3 */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->ctx.AX3, 4*22, 4*24); if (ret) goto out; /* PC */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->ctx.CurrPC, 4*24, 4*25); if (ret) goto out; /* TXSTATUS */ data = (unsigned long)regs->ctx.Flags; if (regs->ctx.SaveMask & TBICTX_CBUF_BIT) data |= USER_GP_REGS_STATUS_CATCH_BIT; ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &data, 4*25, 4*26); if (ret) goto out; /* TXRPT, TXBPOBITS, TXMODE */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->ctx.CurrRPT, 4*26, 4*29); if (ret) goto out; /* Padding */ ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 4*29, 4*30); out: return ret; }
static int gpr64_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { struct pt_regs *regs = task_pt_regs(target); u64 uregs[ELF_NGREG] = {}; mips_dump_regs64(uregs, regs); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, uregs, 0, sizeof(uregs)); }
static int fpr_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { unsigned i; int err; u64 fpr_val; if (sizeof(target->thread.fpu.fpr[i]) == sizeof(elf_fpreg_t)) { err = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &target->thread.fpu.fpr, 0, NUM_FPU_REGS * sizeof(elf_fpreg_t)); if (err) return err; } else { for (i = 0; i < NUM_FPU_REGS; i++) { fpr_val = get_fpr64(&target->thread.fpu.fpr[i], 0); err = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &fpr_val, i * sizeof(elf_fpreg_t), (i + 1) * sizeof(elf_fpreg_t)); if (err) return err; } } err = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &target->thread.fpu.fcr31, NUM_FPU_REGS * sizeof(elf_fpreg_t), (NUM_FPU_REGS * sizeof(elf_fpreg_t)) + sizeof(u32)); if (err) return err; /* Zero fill the remaining 4 bytes. */ return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, (NUM_FPU_REGS * sizeof(elf_fpreg_t)) + sizeof(u32), sizeof(elf_fpregset_t)); }
static int genregs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int ret; unsigned int dummy; struct pt_regs *regs = task_pt_regs(target); if (!regs) return -EIO; /* The general idea here is that the copyout must happen in * exactly the same order in which the userspace expects these * regs. Now, the sequence in userspace does not match the * sequence in the kernel, so everything past the 32 gprs * happens one at a time. */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->r00, 0, 32*sizeof(unsigned long)); #define ONEXT(KPT_REG, USR_REG) \ if (!ret) \ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, \ KPT_REG, offsetof(struct user_regs_struct, USR_REG), \ offsetof(struct user_regs_struct, USR_REG) + \ sizeof(unsigned long)); /* Must be exactly same sequence as struct user_regs_struct */ ONEXT(®s->sa0, sa0); ONEXT(®s->lc0, lc0); ONEXT(®s->sa1, sa1); ONEXT(®s->lc1, lc1); ONEXT(®s->m0, m0); ONEXT(®s->m1, m1); ONEXT(®s->usr, usr); ONEXT(®s->preds, p3_0); ONEXT(®s->gp, gp); ONEXT(®s->ugp, ugp); ONEXT(&pt_elr(regs), pc); dummy = pt_cause(regs); ONEXT(&dummy, cause); ONEXT(&pt_badva(regs), badva); /* Pad the rest with zeros, if needed */ if (!ret) ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, offsetof(struct user_regs_struct, pad1), -1); return ret; }
static int gpr_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { struct pt_regs *regs; regs = task_pt_regs(target); /* Abiv1 regs->tls is fake and we need sync here. */ regs->tls = task_thread_info(target)->tp_value; return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1); }
/* * retrieve the contents of MN10300 userspace general registers */ static int genregs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { const struct pt_regs *regs = task_pt_regs(target); int ret; /* we need to skip regs->next */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, PT_ORIG_D0 * sizeof(long)); if (ret < 0) return ret; ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->orig_d0, PT_ORIG_D0 * sizeof(long), NR_PTREGS * sizeof(long)); if (ret < 0) return ret; return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, NR_PTREGS * sizeof(long), -1); }
int metag_cb_regs_copyout(const struct pt_regs *regs, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int ret; /* TXCATCH{0-3} */ if (regs->ctx.SaveMask & TBICTX_XCBF_BIT) ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs->extcb0, 0, 4*4); else ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 0, 4*4); return ret; }
int metag_rp_state_copyout(const struct pt_regs *regs, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { unsigned long mask; u64 *ptr; int ret, i; /* Empty read pipeline */ if (!(regs->ctx.SaveMask & TBICTX_CBRP_BIT)) { ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 0, 4*13); goto out; } mask = (regs->ctx.CurrDIVTIME & TXDIVTIME_RPMASK_BITS) >> TXDIVTIME_RPMASK_S; /* Read pipeline entries */ ptr = (void *)®s->extcb0[1]; for (i = 0; i < 6; ++i, ++ptr) { if (mask & (1 << i)) ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ptr, 8*i, 8*(i + 1)); else ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, 8*i, 8*(i + 1)); if (ret) goto out; } /* Mask of entries */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &mask, 4*12, 4*13); out: return ret; }
static int fpr_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { struct user_fp *regs = (struct user_fp *)&target->thread.user_fp; #if defined(CONFIG_CPU_HAS_FPUV2) && !defined(CONFIG_CPU_HAS_VDSP) int i; struct user_fp tmp = *regs; for (i = 0; i < 16; i++) { tmp.vr[i*4] = regs->vr[i*2]; tmp.vr[i*4 + 1] = regs->vr[i*2 + 1]; } for (i = 0; i < 32; i++) tmp.vr[64 + i] = regs->vr[32 + i]; return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &tmp, 0, -1); #else return user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, -1); #endif }
static int regs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int r; struct user_regs_struct regs; long *reg = (long *)®s; /* build user regs in buffer */ for (r = 0; r < ARRAY_SIZE(register_offset); r++) *reg++ = h8300_get_reg(target, r); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s, 0, sizeof(regs)); }
static int regs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int r; struct user_regs_struct regs; long *reg = (long *)®s; /* build user regs in buffer */ BUILD_BUG_ON(sizeof(regs) % sizeof(long) != 0); for (r = 0; r < sizeof(regs) / sizeof(long); r++) *reg++ = h8300_get_reg(target, r); return user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s, 0, sizeof(regs)); }
/* * retrieve the contents of MN10300 userspace FPU registers */ static int fpuregs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { const struct fpu_state_struct *fpregs = &target->thread.fpu_state; int ret; unlazy_fpu(target); ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, fpregs, 0, sizeof(*fpregs)); if (ret < 0) return ret; return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, sizeof(*fpregs), -1); }
/* * retrieve the contents of Blackfin userspace general registers */ static int genregs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { struct pt_regs *regs = task_pt_regs(target); int ret; /* This sucks ... */ regs->usp = target->thread.usp; ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, regs, 0, sizeof(*regs)); if (ret < 0) return ret; return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, sizeof(*regs), -1); }
/* * Copy the floating-point context to the supplied NT_PRFPREG buffer, * CONFIG_CPU_HAS_MSA variant. Only lower 64 bits of FP context's * general register slots are copied to buffer slots. Only general * registers are copied. */ static int fpr_get_msa(struct task_struct *target, unsigned int *pos, unsigned int *count, void **kbuf, void __user **ubuf) { unsigned int i; u64 fpr_val; int err; BUILD_BUG_ON(sizeof(fpr_val) != sizeof(elf_fpreg_t)); for (i = 0; i < NUM_FPU_REGS; i++) { fpr_val = get_fpr64(&target->thread.fpu.fpr[i], 0); err = user_regset_copyout(pos, count, kbuf, ubuf, &fpr_val, i * sizeof(elf_fpreg_t), (i + 1) * sizeof(elf_fpreg_t)); if (err) return err; } return 0; }
/* * Copy the floating-point context to the supplied NT_PRFPREG buffer. * Choose the appropriate helper for general registers, and then copy * the FCSR register separately. */ static int fpr_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { const int fcr31_pos = NUM_FPU_REGS * sizeof(elf_fpreg_t); int err; if (sizeof(target->thread.fpu.fpr[0]) == sizeof(elf_fpreg_t)) err = fpr_get_fpa(target, &pos, &count, &kbuf, &ubuf); else err = fpr_get_msa(target, &pos, &count, &kbuf, &ubuf); if (err) return err; err = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &target->thread.fpu.fcr31, fcr31_pos, fcr31_pos + sizeof(u32)); return err; }