mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 10:29:37 +00:00
![David Howells](/assets/img/avatar_default.png)
Disintegrate asm/system.h for MN10300. Signed-off-by: David Howells <dhowells@redhat.com> cc: linux-am33-list@redhat.com
385 lines
9.6 KiB
C
385 lines
9.6 KiB
C
/* 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/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 <asm/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);
|
|
}
|