Loading...
1/*
2 * linux/arch/h8300/kernel/ptrace.c
3 *
4 * Copyright 2015 Yoshinori Sato <ysato@users.sourceforge.jp>
5 *
6 * This file is subject to the terms and conditions of the GNU General
7 * Public License. See the file COPYING in the main directory of
8 * this archive for more details.
9 */
10
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/ptrace.h>
14#include <linux/audit.h>
15#include <linux/tracehook.h>
16#include <linux/regset.h>
17#include <linux/elf.h>
18
19#define CCR_MASK 0x6f /* mode/imask not set */
20#define EXR_MASK 0x80 /* modify only T */
21
22#define PT_REG(r) offsetof(struct pt_regs, r)
23
24extern void user_disable_single_step(struct task_struct *child);
25
26/* Mapping from PT_xxx to the stack offset at which the register is
27 saved. Notice that usp has no stack-slot and needs to be treated
28 specially (see get_reg/put_reg below). */
29static const int register_offset[] = {
30 PT_REG(er1), PT_REG(er2), PT_REG(er3), PT_REG(er4),
31 PT_REG(er5), PT_REG(er6), PT_REG(er0), -1,
32 PT_REG(orig_er0), PT_REG(ccr), PT_REG(pc),
33#if defined(CONFIG_CPU_H8S)
34 PT_REG(exr),
35#endif
36};
37
38/* read register */
39long h8300_get_reg(struct task_struct *task, int regno)
40{
41 switch (regno) {
42 case PT_USP:
43 return task->thread.usp + sizeof(long)*2;
44 case PT_CCR:
45 case PT_EXR:
46 return *(unsigned short *)(task->thread.esp0 +
47 register_offset[regno]);
48 default:
49 return *(unsigned long *)(task->thread.esp0 +
50 register_offset[regno]);
51 }
52}
53
54int h8300_put_reg(struct task_struct *task, int regno, unsigned long data)
55{
56 unsigned short oldccr;
57 unsigned short oldexr;
58
59 switch (regno) {
60 case PT_USP:
61 task->thread.usp = data - sizeof(long)*2;
62 case PT_CCR:
63 oldccr = *(unsigned short *)(task->thread.esp0 +
64 register_offset[regno]);
65 oldccr &= ~CCR_MASK;
66 data &= CCR_MASK;
67 data |= oldccr;
68 *(unsigned short *)(task->thread.esp0 +
69 register_offset[regno]) = data;
70 break;
71 case PT_EXR:
72 oldexr = *(unsigned short *)(task->thread.esp0 +
73 register_offset[regno]);
74 oldccr &= ~EXR_MASK;
75 data &= EXR_MASK;
76 data |= oldexr;
77 *(unsigned short *)(task->thread.esp0 +
78 register_offset[regno]) = data;
79 break;
80 default:
81 *(unsigned long *)(task->thread.esp0 +
82 register_offset[regno]) = data;
83 break;
84 }
85 return 0;
86}
87
88static int regs_get(struct task_struct *target,
89 const struct user_regset *regset,
90 unsigned int pos, unsigned int count,
91 void *kbuf, void __user *ubuf)
92{
93 int r;
94 struct user_regs_struct regs;
95 long *reg = (long *)®s;
96
97 /* build user regs in buffer */
98 for (r = 0; r < ARRAY_SIZE(register_offset); r++)
99 *reg++ = h8300_get_reg(target, r);
100
101 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
102 ®s, 0, sizeof(regs));
103}
104
105static int regs_set(struct task_struct *target,
106 const struct user_regset *regset,
107 unsigned int pos, unsigned int count,
108 const void *kbuf, const void __user *ubuf)
109{
110 int r;
111 int ret;
112 struct user_regs_struct regs;
113 long *reg;
114
115 /* build user regs in buffer */
116 for (reg = (long *)®s, r = 0; r < ARRAY_SIZE(register_offset); r++)
117 *reg++ = h8300_get_reg(target, r);
118
119 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
120 ®s, 0, sizeof(regs));
121 if (ret)
122 return ret;
123
124 /* write back to pt_regs */
125 for (reg = (long *)®s, r = 0; r < ARRAY_SIZE(register_offset); r++)
126 h8300_put_reg(target, r, *reg++);
127 return 0;
128}
129
130enum h8300_regset {
131 REGSET_GENERAL,
132};
133
134static const struct user_regset h8300_regsets[] = {
135 [REGSET_GENERAL] = {
136 .core_note_type = NT_PRSTATUS,
137 .n = ELF_NGREG,
138 .size = sizeof(long),
139 .align = sizeof(long),
140 .get = regs_get,
141 .set = regs_set,
142 },
143};
144
145static const struct user_regset_view user_h8300_native_view = {
146 .name = "h8300",
147 .e_machine = EM_H8_300,
148 .regsets = h8300_regsets,
149 .n = ARRAY_SIZE(h8300_regsets),
150};
151
152const struct user_regset_view *task_user_regset_view(struct task_struct *task)
153{
154 return &user_h8300_native_view;
155}
156
157void ptrace_disable(struct task_struct *child)
158{
159 user_disable_single_step(child);
160}
161
162long arch_ptrace(struct task_struct *child, long request,
163 unsigned long addr, unsigned long data)
164{
165 int ret;
166
167 switch (request) {
168 default:
169 ret = ptrace_request(child, request, addr, data);
170 break;
171 }
172 return ret;
173}
174
175asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
176{
177 long ret = 0;
178
179 if (test_thread_flag(TIF_SYSCALL_TRACE) &&
180 tracehook_report_syscall_entry(regs))
181 /*
182 * Tracing decided this syscall should not happen.
183 * We'll return a bogus call number to get an ENOSYS
184 * error, but leave the original number in regs->regs[0].
185 */
186 ret = -1L;
187
188 audit_syscall_entry(regs->er1, regs->er2, regs->er3,
189 regs->er4, regs->er5);
190
191 return ret ?: regs->er0;
192}
193
194asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
195{
196 int step;
197
198 audit_syscall_exit(regs);
199
200 step = test_thread_flag(TIF_SINGLESTEP);
201 if (step || test_thread_flag(TIF_SYSCALL_TRACE))
202 tracehook_report_syscall_exit(regs, step);
203}
1/*
2 * linux/arch/h8300/kernel/ptrace.c
3 *
4 * Yoshinori Sato <ysato@users.sourceforge.jp>
5 *
6 * Based on:
7 * linux/arch/m68k/kernel/ptrace.c
8 *
9 * Copyright (C) 1994 by Hamish Macdonald
10 * Taken from linux/kernel/ptrace.c and modified for M680x0.
11 * linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
12 *
13 * This file is subject to the terms and conditions of the GNU General
14 * Public License. See the file COPYING in the main directory of
15 * this archive for more details.
16 */
17
18#include <linux/kernel.h>
19#include <linux/sched.h>
20#include <linux/mm.h>
21#include <linux/smp.h>
22#include <linux/errno.h>
23#include <linux/ptrace.h>
24#include <linux/user.h>
25#include <linux/signal.h>
26
27#include <asm/uaccess.h>
28#include <asm/page.h>
29#include <asm/pgtable.h>
30#include <asm/processor.h>
31#include <asm/signal.h>
32
33/* cpu depend functions */
34extern long h8300_get_reg(struct task_struct *task, int regno);
35extern int h8300_put_reg(struct task_struct *task, int regno, unsigned long data);
36
37
38void user_disable_single_step(struct task_struct *child)
39{
40}
41
42/*
43 * does not yet catch signals sent when the child dies.
44 * in exit.c or in signal.c.
45 */
46
47void ptrace_disable(struct task_struct *child)
48{
49 user_disable_single_step(child);
50}
51
52long arch_ptrace(struct task_struct *child, long request,
53 unsigned long addr, unsigned long data)
54{
55 int ret;
56 int regno = addr >> 2;
57 unsigned long __user *datap = (unsigned long __user *) data;
58
59 switch (request) {
60 /* read the word at location addr in the USER area. */
61 case PTRACE_PEEKUSR: {
62 unsigned long tmp = 0;
63
64 if ((addr & 3) || addr >= sizeof(struct user)) {
65 ret = -EIO;
66 break ;
67 }
68
69 ret = 0; /* Default return condition */
70
71 if (regno < H8300_REGS_NO)
72 tmp = h8300_get_reg(child, regno);
73 else {
74 switch (regno) {
75 case 49:
76 tmp = child->mm->start_code;
77 break ;
78 case 50:
79 tmp = child->mm->start_data;
80 break ;
81 case 51:
82 tmp = child->mm->end_code;
83 break ;
84 case 52:
85 tmp = child->mm->end_data;
86 break ;
87 default:
88 ret = -EIO;
89 }
90 }
91 if (!ret)
92 ret = put_user(tmp, datap);
93 break ;
94 }
95
96 /* when I and D space are separate, this will have to be fixed. */
97 case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
98 if ((addr & 3) || addr >= sizeof(struct user)) {
99 ret = -EIO;
100 break ;
101 }
102
103 if (regno == PT_ORIG_ER0) {
104 ret = -EIO;
105 break ;
106 }
107 if (regno < H8300_REGS_NO) {
108 ret = h8300_put_reg(child, regno, data);
109 break ;
110 }
111 ret = -EIO;
112 break ;
113
114 case PTRACE_GETREGS: { /* Get all gp regs from the child. */
115 int i;
116 unsigned long tmp;
117 for (i = 0; i < H8300_REGS_NO; i++) {
118 tmp = h8300_get_reg(child, i);
119 if (put_user(tmp, datap)) {
120 ret = -EFAULT;
121 break;
122 }
123 datap++;
124 }
125 ret = 0;
126 break;
127 }
128
129 case PTRACE_SETREGS: { /* Set all gp regs in the child. */
130 int i;
131 unsigned long tmp;
132 for (i = 0; i < H8300_REGS_NO; i++) {
133 if (get_user(tmp, datap)) {
134 ret = -EFAULT;
135 break;
136 }
137 h8300_put_reg(child, i, tmp);
138 datap++;
139 }
140 ret = 0;
141 break;
142 }
143
144 default:
145 ret = ptrace_request(child, request, addr, data);
146 break;
147 }
148 return ret;
149}
150
151asmlinkage void do_syscall_trace(void)
152{
153 if (!test_thread_flag(TIF_SYSCALL_TRACE))
154 return;
155 if (!(current->ptrace & PT_PTRACED))
156 return;
157 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
158 ? 0x80 : 0));
159 /*
160 * this isn't the same as continuing with a signal, but it will do
161 * for normal use. strace only continues with a signal if the
162 * stopping signal is not SIGTRAP. -brl
163 */
164 if (current->exit_code) {
165 send_sig(current->exit_code, current, 1);
166 current->exit_code = 0;
167 }
168}