a11db009d0ea0d907e41a089eaac9157cd87bf51
[releases.git] / ptrace.c
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
24 extern 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). */
29 static 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 */
39 long 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
54 int 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
88 static int regs_get(struct task_struct *target,
89                     const struct user_regset *regset,
90                     struct membuf to)
91 {
92         int r;
93
94         BUILD_BUG_ON(sizeof(struct user_regs_struct) % sizeof(long) != 0);
95         for (r = 0; r < ELF_NGREG; r++)
96                 membuf_store(&to, h8300_get_reg(target, r));
97
98         return 0;
99 }
100
101 static int regs_set(struct task_struct *target,
102                     const struct user_regset *regset,
103                     unsigned int pos, unsigned int count,
104                     const void *kbuf, const void __user *ubuf)
105 {
106         int r;
107         int ret;
108         struct user_regs_struct regs;
109         long *reg;
110
111         /* build user regs in buffer */
112         BUILD_BUG_ON(sizeof(regs) % sizeof(long) != 0);
113         for (reg = (long *)&regs, r = 0; r < sizeof(regs) / sizeof(long); r++)
114                 *reg++ = h8300_get_reg(target, r);
115
116         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
117                                  &regs, 0, sizeof(regs));
118         if (ret)
119                 return ret;
120
121         /* write back to pt_regs */
122         for (reg = (long *)&regs, r = 0; r < sizeof(regs) / sizeof(long); r++)
123                 h8300_put_reg(target, r, *reg++);
124         return 0;
125 }
126
127 enum h8300_regset {
128         REGSET_GENERAL,
129 };
130
131 static const struct user_regset h8300_regsets[] = {
132         [REGSET_GENERAL] = {
133                 .core_note_type = NT_PRSTATUS,
134                 .n              = ELF_NGREG,
135                 .size           = sizeof(long),
136                 .align          = sizeof(long),
137                 .regset_get             = regs_get,
138                 .set            = regs_set,
139         },
140 };
141
142 static const struct user_regset_view user_h8300_native_view = {
143         .name = "h8300",
144         .e_machine = EM_H8_300,
145         .regsets = h8300_regsets,
146         .n = ARRAY_SIZE(h8300_regsets),
147 };
148
149 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
150 {
151         return &user_h8300_native_view;
152 }
153
154 void ptrace_disable(struct task_struct *child)
155 {
156         user_disable_single_step(child);
157 }
158
159 long arch_ptrace(struct task_struct *child, long request,
160                  unsigned long addr, unsigned long data)
161 {
162         int ret;
163
164         switch (request) {
165         default:
166                 ret = ptrace_request(child, request, addr, data);
167                 break;
168         }
169         return ret;
170 }
171
172 asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
173 {
174         long ret = 0;
175
176         if (test_thread_flag(TIF_SYSCALL_TRACE) &&
177             tracehook_report_syscall_entry(regs))
178                 /*
179                  * Tracing decided this syscall should not happen.
180                  * We'll return a bogus call number to get an ENOSYS
181                  * error, but leave the original number in regs->regs[0].
182                  */
183                 ret = -1L;
184
185         audit_syscall_entry(regs->er1, regs->er2, regs->er3,
186                             regs->er4, regs->er5);
187
188         return ret ?: regs->er0;
189 }
190
191 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs)
192 {
193         int step;
194
195         audit_syscall_exit(regs);
196
197         step = test_thread_flag(TIF_SINGLESTEP);
198         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
199                 tracehook_report_syscall_exit(regs, step);
200 }