/* MN10300 Process tracing * * Copyright (C) 2007 Matsushita Electric Industrial Co., Ltd. * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. * Modified by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public Licence * as published by the Free Software Foundation; either version * 2 of the Licence, or (at your option) any later version. */ #include <linux/kernel.h> #include <linux/sched.h> #include <linux/sched/task_stack.h> #include <linux/mm.h> #include <linux/smp.h> #include <linux/errno.h> #include <linux/ptrace.h> #include <linux/user.h> #include <linux/regset.h> #include <linux/elf.h> #include <linux/tracehook.h> #include <linux/uaccess.h> #include <asm/pgtable.h> #include <asm/processor.h> #include <asm/cacheflush.h> #include <asm/fpu.h> #include <asm/asm-offsets.h> /* * translate ptrace register IDs into struct pt_regs offsets */ static const u8 ptrace_regid_to_frame[] = { [PT_A3 << 2] = REG_A3, [PT_A2 << 2] = REG_A2, [PT_D3 << 2] = REG_D3, [PT_D2 << 2] = REG_D2, [PT_MCVF << 2] = REG_MCVF, [PT_MCRL << 2] = REG_MCRL, [PT_MCRH << 2] = REG_MCRH, [PT_MDRQ << 2] = REG_MDRQ, [PT_E1 << 2] = REG_E1, [PT_E0 << 2] = REG_E0, [PT_E7 << 2] = REG_E7, [PT_E6 << 2] = REG_E6, [PT_E5 << 2] = REG_E5, [PT_E4 << 2] = REG_E4, [PT_E3 << 2] = REG_E3, [PT_E2 << 2] = REG_E2, [PT_SP << 2] = REG_SP, [PT_LAR << 2] = REG_LAR, [PT_LIR << 2] = REG_LIR, [PT_MDR << 2] = REG_MDR, [PT_A1 << 2] = REG_A1, [PT_A0 << 2] = REG_A0, [PT_D1 << 2] = REG_D1, [PT_D0 << 2] = REG_D0, [PT_ORIG_D0 << 2] = REG_ORIG_D0, [PT_EPSW << 2] = REG_EPSW, [PT_PC << 2] = REG_PC, }; static inline int get_stack_long(struct task_struct *task, int offset) { return *(unsigned long *) ((unsigned long) task->thread.uregs + offset); } static inline int put_stack_long(struct task_struct *task, int offset, unsigned long data) { unsigned long stack; stack = (unsigned long) task->thread.uregs + offset; *(unsigned long *) stack = data; return 0; } /* * 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); } /* * update the contents of the MN10300 userspace general registers */ static int genregs_set(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, const void *kbuf, const void __user *ubuf) { struct pt_regs *regs = task_pt_regs(target); unsigned long tmp; int ret; /* we need to skip regs->next */ ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, regs, 0, PT_ORIG_D0 * sizeof(long)); if (ret < 0) return ret; ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s->orig_d0, PT_ORIG_D0 * sizeof(long), PT_EPSW * sizeof(long)); if (ret < 0) return ret; /* we need to mask off changes to EPSW */ tmp = regs->epsw; ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &tmp, PT_EPSW * sizeof(long), PT_PC * sizeof(long)); tmp &= EPSW_FLAG_V | EPSW_FLAG_C | EPSW_FLAG_N | EPSW_FLAG_Z; tmp |= regs->epsw & ~(EPSW_FLAG_V | EPSW_FLAG_C | EPSW_FLAG_N | EPSW_FLAG_Z); regs->epsw = tmp; if (ret < 0) return ret; /* and finally load the PC */ ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s->pc, PT_PC * sizeof(long), NR_PTREGS * sizeof(long)); if (ret < 0) return ret; return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, NR_PTREGS * sizeof(long), -1); } /* * 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); } /* * update the contents of the MN10300 userspace FPU registers */ static int fpuregs_set(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, const void *kbuf, const void __user *ubuf) { struct fpu_state_struct fpu_state = target->thread.fpu_state; int ret; ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &fpu_state, 0, sizeof(fpu_state)); if (ret < 0) return ret; fpu_kill_state(target); target->thread.fpu_state = fpu_state; set_using_fpu(target); return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, sizeof(fpu_state), -1); } /* * determine if the FPU registers have actually been used */ static int fpuregs_active(struct task_struct *target, const struct user_regset *regset) { return is_using_fpu(target) ? regset->n : 0; } /* * Define the register sets available on the MN10300 under Linux */ enum mn10300_regset { REGSET_GENERAL, REGSET_FPU, }; static const struct user_regset mn10300_regsets[] = { /* * General register format is: * A3, A2, D3, D2, MCVF, MCRL, MCRH, MDRQ * E1, E0, E7...E2, SP, LAR, LIR, MDR * A1, A0, D1, D0, ORIG_D0, EPSW, PC */ [REGSET_GENERAL] = { .core_note_type = NT_PRSTATUS, .n = ELF_NGREG, .size = sizeof(long), .align = sizeof(long), .get = genregs_get, .set = genregs_set, }, /* * FPU register format is: * FS0-31, FPCR */ [REGSET_FPU] = { .core_note_type = NT_PRFPREG, .n = sizeof(struct fpu_state_struct) / sizeof(long), .size = sizeof(long), .align = sizeof(long), .get = fpuregs_get, .set = fpuregs_set, .active = fpuregs_active, }, }; static const struct user_regset_view user_mn10300_native_view = { .name = "mn10300", .e_machine = EM_MN10300, .regsets = mn10300_regsets, .n = ARRAY_SIZE(mn10300_regsets), }; const struct user_regset_view *task_user_regset_view(struct task_struct *task) { return &user_mn10300_native_view; } /* * set the single-step bit */ void user_enable_single_step(struct task_struct *child) { #ifndef CONFIG_MN10300_USING_JTAG struct user *dummy = NULL; long tmp; tmp = get_stack_long(child, (unsigned long) &dummy->regs.epsw); tmp |= EPSW_T; put_stack_long(child, (unsigned long) &dummy->regs.epsw, tmp); #endif } /* * make sure the single-step bit is not set */ void user_disable_single_step(struct task_struct *child) { #ifndef CONFIG_MN10300_USING_JTAG struct user *dummy = NULL; long tmp; tmp = get_stack_long(child, (unsigned long) &dummy->regs.epsw); tmp &= ~EPSW_T; put_stack_long(child, (unsigned long) &dummy->regs.epsw, tmp); #endif } void ptrace_disable(struct task_struct *child) { user_disable_single_step(child); } /* * handle the arch-specific side of process tracing */ long arch_ptrace(struct task_struct *child, long request, unsigned long addr, unsigned long data) { unsigned long tmp; int ret; unsigned long __user *datap = (unsigned long __user *) data; switch (request) { /* read the word at location addr in the USER area. */ case PTRACE_PEEKUSR: ret = -EIO; if ((addr & 3) || addr > sizeof(struct user) - 3) break; tmp = 0; /* Default return condition */ if (addr < NR_PTREGS << 2) tmp = get_stack_long(child, ptrace_regid_to_frame[addr]); ret = put_user(tmp, datap); break; /* write the word at location addr in the USER area */ case PTRACE_POKEUSR: ret = -EIO; if ((addr & 3) || addr > sizeof(struct user) - 3) break; ret = 0; if (addr < NR_PTREGS << 2) ret = put_stack_long(child, ptrace_regid_to_frame[addr], data); break; case PTRACE_GETREGS: /* Get all integer regs from the child. */ return copy_regset_to_user(child, &user_mn10300_native_view, REGSET_GENERAL, 0, NR_PTREGS * sizeof(long), datap); case PTRACE_SETREGS: /* Set all integer regs in the child. */ return copy_regset_from_user(child, &user_mn10300_native_view, REGSET_GENERAL, 0, NR_PTREGS * sizeof(long), datap); case PTRACE_GETFPREGS: /* Get the child FPU state. */ return copy_regset_to_user(child, &user_mn10300_native_view, REGSET_FPU, 0, sizeof(struct fpu_state_struct), datap); case PTRACE_SETFPREGS: /* Set the child FPU state. */ return copy_regset_from_user(child, &user_mn10300_native_view, REGSET_FPU, 0, sizeof(struct fpu_state_struct), datap); default: ret = ptrace_request(child, request, addr, data); break; } return ret; } /* * handle tracing of system call entry * - return the revised system call number or ULONG_MAX to cause ENOSYS */ asmlinkage unsigned long syscall_trace_entry(struct pt_regs *regs) { if (tracehook_report_syscall_entry(regs)) /* tracing decided this syscall should not happen, so * We'll return a bogus call number to get an ENOSYS * error, but leave the original number in * regs->orig_d0 */ return ULONG_MAX; return regs->orig_d0; } /* * handle tracing of system call exit */ asmlinkage void syscall_trace_exit(struct pt_regs *regs) { tracehook_report_syscall_exit(regs, 0); }