446b6cb8de
Signed-off-by: Richard Kuo <rkuo@codeaurora.org>
206 lines
5.4 KiB
C
206 lines
5.4 KiB
C
/*
|
|
* Ptrace support for Hexagon
|
|
*
|
|
* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 and
|
|
* only version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*/
|
|
|
|
#include <generated/compile.h>
|
|
|
|
#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/regset.h>
|
|
#include <linux/user.h>
|
|
#include <linux/elf.h>
|
|
|
|
#include <asm/user.h>
|
|
|
|
#if arch_has_single_step()
|
|
/* Both called from ptrace_resume */
|
|
void user_enable_single_step(struct task_struct *child)
|
|
{
|
|
pt_set_singlestep(task_pt_regs(child));
|
|
set_tsk_thread_flag(child, TIF_SINGLESTEP);
|
|
}
|
|
|
|
void user_disable_single_step(struct task_struct *child)
|
|
{
|
|
pt_clr_singlestep(task_pt_regs(child));
|
|
clear_tsk_thread_flag(child, TIF_SINGLESTEP);
|
|
}
|
|
#endif
|
|
|
|
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);
|
|
#if CONFIG_HEXAGON_ARCH_VERSION >=4
|
|
ONEXT(®s->cs0, cs0);
|
|
ONEXT(®s->cs1, cs1);
|
|
#endif
|
|
|
|
/* 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 genregs_set(struct task_struct *target,
|
|
const struct user_regset *regset,
|
|
unsigned int pos, unsigned int count,
|
|
const void *kbuf, const void __user *ubuf)
|
|
{
|
|
int ret;
|
|
unsigned long bucket;
|
|
struct pt_regs *regs = task_pt_regs(target);
|
|
|
|
if (!regs)
|
|
return -EIO;
|
|
|
|
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
|
|
®s->r00, 0, 32*sizeof(unsigned long));
|
|
|
|
#define INEXT(KPT_REG, USR_REG) \
|
|
if (!ret) \
|
|
ret = user_regset_copyin(&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 */
|
|
INEXT(®s->sa0, sa0);
|
|
INEXT(®s->lc0, lc0);
|
|
INEXT(®s->sa1, sa1);
|
|
INEXT(®s->lc1, lc1);
|
|
INEXT(®s->m0, m0);
|
|
INEXT(®s->m1, m1);
|
|
INEXT(®s->usr, usr);
|
|
INEXT(®s->preds, p3_0);
|
|
INEXT(®s->gp, gp);
|
|
INEXT(®s->ugp, ugp);
|
|
INEXT(&pt_elr(regs), pc);
|
|
|
|
/* CAUSE and BADVA aren't writeable. */
|
|
INEXT(&bucket, cause);
|
|
INEXT(&bucket, badva);
|
|
|
|
#if CONFIG_HEXAGON_ARCH_VERSION >=4
|
|
INEXT(®s->cs0, cs0);
|
|
INEXT(®s->cs1, cs1);
|
|
#endif
|
|
|
|
/* Ignore the rest, if needed */
|
|
if (!ret)
|
|
ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
|
|
offsetof(struct user_regs_struct, pad1), -1);
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* This is special; SP is actually restored by the VM via the
|
|
* special event record which is set by the special trap.
|
|
*/
|
|
regs->hvmer.vmpsp = regs->r29;
|
|
return 0;
|
|
}
|
|
|
|
enum hexagon_regset {
|
|
REGSET_GENERAL,
|
|
};
|
|
|
|
static const struct user_regset hexagon_regsets[] = {
|
|
[REGSET_GENERAL] = {
|
|
.core_note_type = NT_PRSTATUS,
|
|
.n = ELF_NGREG,
|
|
.size = sizeof(unsigned long),
|
|
.align = sizeof(unsigned long),
|
|
.get = genregs_get,
|
|
.set = genregs_set,
|
|
},
|
|
};
|
|
|
|
static const struct user_regset_view hexagon_user_view = {
|
|
.name = UTS_MACHINE,
|
|
.e_machine = ELF_ARCH,
|
|
.ei_osabi = ELF_OSABI,
|
|
.regsets = hexagon_regsets,
|
|
.e_flags = ELF_CORE_EFLAGS,
|
|
.n = ARRAY_SIZE(hexagon_regsets)
|
|
};
|
|
|
|
const struct user_regset_view *task_user_regset_view(struct task_struct *task)
|
|
{
|
|
return &hexagon_user_view;
|
|
}
|
|
|
|
void ptrace_disable(struct task_struct *child)
|
|
{
|
|
/* Boilerplate - resolves to null inline if no HW single-step */
|
|
user_disable_single_step(child);
|
|
}
|
|
|
|
long arch_ptrace(struct task_struct *child, long request,
|
|
unsigned long addr, unsigned long data)
|
|
{
|
|
return ptrace_request(child, request, addr, data);
|
|
}
|