Loading...
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1992 Ross Biro
7 * Copyright (C) Linus Torvalds
8 * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
9 * Copyright (C) 1996 David S. Miller
10 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
11 * Copyright (C) 1999 MIPS Technologies, Inc.
12 * Copyright (C) 2000 Ulf Carlsson
13 *
14 * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit
15 * binaries.
16 */
17#include <linux/compiler.h>
18#include <linux/compat.h>
19#include <linux/kernel.h>
20#include <linux/sched.h>
21#include <linux/sched/task_stack.h>
22#include <linux/mm.h>
23#include <linux/errno.h>
24#include <linux/ptrace.h>
25#include <linux/smp.h>
26#include <linux/security.h>
27
28#include <asm/cpu.h>
29#include <asm/dsp.h>
30#include <asm/fpu.h>
31#include <asm/mipsregs.h>
32#include <asm/mipsmtregs.h>
33#include <asm/pgtable.h>
34#include <asm/page.h>
35#include <asm/reg.h>
36#include <asm/syscall.h>
37#include <linux/uaccess.h>
38#include <asm/bootinfo.h>
39
40/*
41 * Tracing a 32-bit process with a 64-bit strace and vice versa will not
42 * work. I don't know how to fix this.
43 */
44long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
45 compat_ulong_t caddr, compat_ulong_t cdata)
46{
47 int addr = caddr;
48 int data = cdata;
49 int ret;
50
51 switch (request) {
52
53 /*
54 * Read 4 bytes of the other process' storage
55 * data is a pointer specifying where the user wants the
56 * 4 bytes copied into
57 * addr is a pointer in the user's storage that contains an 8 byte
58 * address in the other process of the 4 bytes that is to be read
59 * (this is run in a 32-bit process looking at a 64-bit process)
60 * when I and D space are separate, these will need to be fixed.
61 */
62 case PTRACE_PEEKTEXT_3264:
63 case PTRACE_PEEKDATA_3264: {
64 u32 tmp;
65 int copied;
66 u32 __user * addrOthers;
67
68 ret = -EIO;
69
70 /* Get the addr in the other process that we want to read */
71 if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
72 break;
73
74 copied = ptrace_access_vm(child, (u64)addrOthers, &tmp,
75 sizeof(tmp), FOLL_FORCE);
76 if (copied != sizeof(tmp))
77 break;
78 ret = put_user(tmp, (u32 __user *) (unsigned long) data);
79 break;
80 }
81
82 /* Read the word at location addr in the USER area. */
83 case PTRACE_PEEKUSR: {
84 struct pt_regs *regs;
85 union fpureg *fregs;
86 unsigned int tmp;
87
88 regs = task_pt_regs(child);
89 ret = 0; /* Default return value. */
90
91 switch (addr) {
92 case 0 ... 31:
93 tmp = regs->regs[addr];
94 break;
95 case FPR_BASE ... FPR_BASE + 31:
96 if (!tsk_used_math(child)) {
97 /* FP not yet used */
98 tmp = -1;
99 break;
100 }
101 fregs = get_fpu_regs(child);
102 if (test_tsk_thread_flag(child, TIF_32BIT_FPREGS)) {
103 /*
104 * The odd registers are actually the high
105 * order bits of the values stored in the even
106 * registers - unless we're using r2k_switch.S.
107 */
108 tmp = get_fpr32(&fregs[(addr & ~1) - FPR_BASE],
109 addr & 1);
110 break;
111 }
112 tmp = get_fpr64(&fregs[addr - FPR_BASE], 0);
113 break;
114 case PC:
115 tmp = regs->cp0_epc;
116 break;
117 case CAUSE:
118 tmp = regs->cp0_cause;
119 break;
120 case BADVADDR:
121 tmp = regs->cp0_badvaddr;
122 break;
123 case MMHI:
124 tmp = regs->hi;
125 break;
126 case MMLO:
127 tmp = regs->lo;
128 break;
129 case FPC_CSR:
130 tmp = child->thread.fpu.fcr31;
131 break;
132 case FPC_EIR:
133 /* implementation / version register */
134 tmp = boot_cpu_data.fpu_id;
135 break;
136 case DSP_BASE ... DSP_BASE + 5: {
137 dspreg_t *dregs;
138
139 if (!cpu_has_dsp) {
140 tmp = 0;
141 ret = -EIO;
142 goto out;
143 }
144 dregs = __get_dsp_regs(child);
145 tmp = (unsigned long) (dregs[addr - DSP_BASE]);
146 break;
147 }
148 case DSP_CONTROL:
149 if (!cpu_has_dsp) {
150 tmp = 0;
151 ret = -EIO;
152 goto out;
153 }
154 tmp = child->thread.dsp.dspcontrol;
155 break;
156 default:
157 tmp = 0;
158 ret = -EIO;
159 goto out;
160 }
161 ret = put_user(tmp, (unsigned __user *) (unsigned long) data);
162 break;
163 }
164
165 /*
166 * Write 4 bytes into the other process' storage
167 * data is the 4 bytes that the user wants written
168 * addr is a pointer in the user's storage that contains an
169 * 8 byte address in the other process where the 4 bytes
170 * that is to be written
171 * (this is run in a 32-bit process looking at a 64-bit process)
172 * when I and D space are separate, these will need to be fixed.
173 */
174 case PTRACE_POKETEXT_3264:
175 case PTRACE_POKEDATA_3264: {
176 u32 __user * addrOthers;
177
178 /* Get the addr in the other process that we want to write into */
179 ret = -EIO;
180 if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
181 break;
182 ret = 0;
183 if (ptrace_access_vm(child, (u64)addrOthers, &data,
184 sizeof(data),
185 FOLL_FORCE | FOLL_WRITE) == sizeof(data))
186 break;
187 ret = -EIO;
188 break;
189 }
190
191 case PTRACE_POKEUSR: {
192 struct pt_regs *regs;
193 ret = 0;
194 regs = task_pt_regs(child);
195
196 switch (addr) {
197 case 0 ... 31:
198 regs->regs[addr] = data;
199 /* System call number may have been changed */
200 if (addr == 2)
201 mips_syscall_update_nr(child, regs);
202 else if (addr == 4 &&
203 mips_syscall_is_indirect(child, regs))
204 mips_syscall_update_nr(child, regs);
205 break;
206 case FPR_BASE ... FPR_BASE + 31: {
207 union fpureg *fregs = get_fpu_regs(child);
208
209 if (!tsk_used_math(child)) {
210 /* FP not yet used */
211 memset(&child->thread.fpu, ~0,
212 sizeof(child->thread.fpu));
213 child->thread.fpu.fcr31 = 0;
214 }
215 if (test_tsk_thread_flag(child, TIF_32BIT_FPREGS)) {
216 /*
217 * The odd registers are actually the high
218 * order bits of the values stored in the even
219 * registers - unless we're using r2k_switch.S.
220 */
221 set_fpr32(&fregs[(addr & ~1) - FPR_BASE],
222 addr & 1, data);
223 break;
224 }
225 set_fpr64(&fregs[addr - FPR_BASE], 0, data);
226 break;
227 }
228 case PC:
229 regs->cp0_epc = data;
230 break;
231 case MMHI:
232 regs->hi = data;
233 break;
234 case MMLO:
235 regs->lo = data;
236 break;
237 case FPC_CSR:
238 child->thread.fpu.fcr31 = data;
239 break;
240 case DSP_BASE ... DSP_BASE + 5: {
241 dspreg_t *dregs;
242
243 if (!cpu_has_dsp) {
244 ret = -EIO;
245 break;
246 }
247
248 dregs = __get_dsp_regs(child);
249 dregs[addr - DSP_BASE] = data;
250 break;
251 }
252 case DSP_CONTROL:
253 if (!cpu_has_dsp) {
254 ret = -EIO;
255 break;
256 }
257 child->thread.dsp.dspcontrol = data;
258 break;
259 default:
260 /* The rest are not allowed. */
261 ret = -EIO;
262 break;
263 }
264 break;
265 }
266
267 case PTRACE_GETREGS:
268 ret = ptrace_getregs(child,
269 (struct user_pt_regs __user *) (__u64) data);
270 break;
271
272 case PTRACE_SETREGS:
273 ret = ptrace_setregs(child,
274 (struct user_pt_regs __user *) (__u64) data);
275 break;
276
277 case PTRACE_GETFPREGS:
278 ret = ptrace_getfpregs(child, (__u32 __user *) (__u64) data);
279 break;
280
281 case PTRACE_SETFPREGS:
282 ret = ptrace_setfpregs(child, (__u32 __user *) (__u64) data);
283 break;
284
285 case PTRACE_GET_THREAD_AREA:
286 ret = put_user(task_thread_info(child)->tp_value,
287 (unsigned int __user *) (unsigned long) data);
288 break;
289
290 case PTRACE_GET_THREAD_AREA_3264:
291 ret = put_user(task_thread_info(child)->tp_value,
292 (unsigned long __user *) (unsigned long) data);
293 break;
294
295 case PTRACE_GET_WATCH_REGS:
296 ret = ptrace_get_watch_regs(child,
297 (struct pt_watch_regs __user *) (unsigned long) addr);
298 break;
299
300 case PTRACE_SET_WATCH_REGS:
301 ret = ptrace_set_watch_regs(child,
302 (struct pt_watch_regs __user *) (unsigned long) addr);
303 break;
304
305 default:
306 ret = compat_ptrace_request(child, request, addr, data);
307 break;
308 }
309out:
310 return ret;
311}
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1992 Ross Biro
7 * Copyright (C) Linus Torvalds
8 * Copyright (C) 1994, 95, 96, 97, 98, 2000 Ralf Baechle
9 * Copyright (C) 1996 David S. Miller
10 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
11 * Copyright (C) 1999 MIPS Technologies, Inc.
12 * Copyright (C) 2000 Ulf Carlsson
13 *
14 * At this time Linux/MIPS64 only supports syscall tracing, even for 32-bit
15 * binaries.
16 */
17#include <linux/compiler.h>
18#include <linux/compat.h>
19#include <linux/kernel.h>
20#include <linux/sched.h>
21#include <linux/mm.h>
22#include <linux/errno.h>
23#include <linux/ptrace.h>
24#include <linux/smp.h>
25#include <linux/security.h>
26
27#include <asm/cpu.h>
28#include <asm/dsp.h>
29#include <asm/fpu.h>
30#include <asm/mipsregs.h>
31#include <asm/mipsmtregs.h>
32#include <asm/pgtable.h>
33#include <asm/page.h>
34#include <asm/reg.h>
35#include <linux/uaccess.h>
36#include <asm/bootinfo.h>
37
38/*
39 * Tracing a 32-bit process with a 64-bit strace and vice versa will not
40 * work. I don't know how to fix this.
41 */
42long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
43 compat_ulong_t caddr, compat_ulong_t cdata)
44{
45 int addr = caddr;
46 int data = cdata;
47 int ret;
48
49 switch (request) {
50
51 /*
52 * Read 4 bytes of the other process' storage
53 * data is a pointer specifying where the user wants the
54 * 4 bytes copied into
55 * addr is a pointer in the user's storage that contains an 8 byte
56 * address in the other process of the 4 bytes that is to be read
57 * (this is run in a 32-bit process looking at a 64-bit process)
58 * when I and D space are separate, these will need to be fixed.
59 */
60 case PTRACE_PEEKTEXT_3264:
61 case PTRACE_PEEKDATA_3264: {
62 u32 tmp;
63 int copied;
64 u32 __user * addrOthers;
65
66 ret = -EIO;
67
68 /* Get the addr in the other process that we want to read */
69 if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
70 break;
71
72 copied = ptrace_access_vm(child, (u64)addrOthers, &tmp,
73 sizeof(tmp), FOLL_FORCE);
74 if (copied != sizeof(tmp))
75 break;
76 ret = put_user(tmp, (u32 __user *) (unsigned long) data);
77 break;
78 }
79
80 /* Read the word at location addr in the USER area. */
81 case PTRACE_PEEKUSR: {
82 struct pt_regs *regs;
83 union fpureg *fregs;
84 unsigned int tmp;
85
86 regs = task_pt_regs(child);
87 ret = 0; /* Default return value. */
88
89 switch (addr) {
90 case 0 ... 31:
91 tmp = regs->regs[addr];
92 break;
93 case FPR_BASE ... FPR_BASE + 31:
94 if (!tsk_used_math(child)) {
95 /* FP not yet used */
96 tmp = -1;
97 break;
98 }
99 fregs = get_fpu_regs(child);
100 if (test_thread_flag(TIF_32BIT_FPREGS)) {
101 /*
102 * The odd registers are actually the high
103 * order bits of the values stored in the even
104 * registers - unless we're using r2k_switch.S.
105 */
106 tmp = get_fpr32(&fregs[(addr & ~1) - FPR_BASE],
107 addr & 1);
108 break;
109 }
110 tmp = get_fpr32(&fregs[addr - FPR_BASE], 0);
111 break;
112 case PC:
113 tmp = regs->cp0_epc;
114 break;
115 case CAUSE:
116 tmp = regs->cp0_cause;
117 break;
118 case BADVADDR:
119 tmp = regs->cp0_badvaddr;
120 break;
121 case MMHI:
122 tmp = regs->hi;
123 break;
124 case MMLO:
125 tmp = regs->lo;
126 break;
127 case FPC_CSR:
128 tmp = child->thread.fpu.fcr31;
129 break;
130 case FPC_EIR:
131 /* implementation / version register */
132 tmp = boot_cpu_data.fpu_id;
133 break;
134 case DSP_BASE ... DSP_BASE + 5: {
135 dspreg_t *dregs;
136
137 if (!cpu_has_dsp) {
138 tmp = 0;
139 ret = -EIO;
140 goto out;
141 }
142 dregs = __get_dsp_regs(child);
143 tmp = (unsigned long) (dregs[addr - DSP_BASE]);
144 break;
145 }
146 case DSP_CONTROL:
147 if (!cpu_has_dsp) {
148 tmp = 0;
149 ret = -EIO;
150 goto out;
151 }
152 tmp = child->thread.dsp.dspcontrol;
153 break;
154 default:
155 tmp = 0;
156 ret = -EIO;
157 goto out;
158 }
159 ret = put_user(tmp, (unsigned __user *) (unsigned long) data);
160 break;
161 }
162
163 /*
164 * Write 4 bytes into the other process' storage
165 * data is the 4 bytes that the user wants written
166 * addr is a pointer in the user's storage that contains an
167 * 8 byte address in the other process where the 4 bytes
168 * that is to be written
169 * (this is run in a 32-bit process looking at a 64-bit process)
170 * when I and D space are separate, these will need to be fixed.
171 */
172 case PTRACE_POKETEXT_3264:
173 case PTRACE_POKEDATA_3264: {
174 u32 __user * addrOthers;
175
176 /* Get the addr in the other process that we want to write into */
177 ret = -EIO;
178 if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
179 break;
180 ret = 0;
181 if (ptrace_access_vm(child, (u64)addrOthers, &data,
182 sizeof(data),
183 FOLL_FORCE | FOLL_WRITE) == sizeof(data))
184 break;
185 ret = -EIO;
186 break;
187 }
188
189 case PTRACE_POKEUSR: {
190 struct pt_regs *regs;
191 ret = 0;
192 regs = task_pt_regs(child);
193
194 switch (addr) {
195 case 0 ... 31:
196 regs->regs[addr] = data;
197 break;
198 case FPR_BASE ... FPR_BASE + 31: {
199 union fpureg *fregs = get_fpu_regs(child);
200
201 if (!tsk_used_math(child)) {
202 /* FP not yet used */
203 memset(&child->thread.fpu, ~0,
204 sizeof(child->thread.fpu));
205 child->thread.fpu.fcr31 = 0;
206 }
207 if (test_thread_flag(TIF_32BIT_FPREGS)) {
208 /*
209 * The odd registers are actually the high
210 * order bits of the values stored in the even
211 * registers - unless we're using r2k_switch.S.
212 */
213 set_fpr32(&fregs[(addr & ~1) - FPR_BASE],
214 addr & 1, data);
215 break;
216 }
217 set_fpr64(&fregs[addr - FPR_BASE], 0, data);
218 break;
219 }
220 case PC:
221 regs->cp0_epc = data;
222 break;
223 case MMHI:
224 regs->hi = data;
225 break;
226 case MMLO:
227 regs->lo = data;
228 break;
229 case FPC_CSR:
230 child->thread.fpu.fcr31 = data;
231 break;
232 case DSP_BASE ... DSP_BASE + 5: {
233 dspreg_t *dregs;
234
235 if (!cpu_has_dsp) {
236 ret = -EIO;
237 break;
238 }
239
240 dregs = __get_dsp_regs(child);
241 dregs[addr - DSP_BASE] = data;
242 break;
243 }
244 case DSP_CONTROL:
245 if (!cpu_has_dsp) {
246 ret = -EIO;
247 break;
248 }
249 child->thread.dsp.dspcontrol = data;
250 break;
251 default:
252 /* The rest are not allowed. */
253 ret = -EIO;
254 break;
255 }
256 break;
257 }
258
259 case PTRACE_GETREGS:
260 ret = ptrace_getregs(child,
261 (struct user_pt_regs __user *) (__u64) data);
262 break;
263
264 case PTRACE_SETREGS:
265 ret = ptrace_setregs(child,
266 (struct user_pt_regs __user *) (__u64) data);
267 break;
268
269 case PTRACE_GETFPREGS:
270 ret = ptrace_getfpregs(child, (__u32 __user *) (__u64) data);
271 break;
272
273 case PTRACE_SETFPREGS:
274 ret = ptrace_setfpregs(child, (__u32 __user *) (__u64) data);
275 break;
276
277 case PTRACE_GET_THREAD_AREA:
278 ret = put_user(task_thread_info(child)->tp_value,
279 (unsigned int __user *) (unsigned long) data);
280 break;
281
282 case PTRACE_GET_THREAD_AREA_3264:
283 ret = put_user(task_thread_info(child)->tp_value,
284 (unsigned long __user *) (unsigned long) data);
285 break;
286
287 case PTRACE_GET_WATCH_REGS:
288 ret = ptrace_get_watch_regs(child,
289 (struct pt_watch_regs __user *) (unsigned long) addr);
290 break;
291
292 case PTRACE_SET_WATCH_REGS:
293 ret = ptrace_set_watch_regs(child,
294 (struct pt_watch_regs __user *) (unsigned long) addr);
295 break;
296
297 default:
298 ret = compat_ptrace_request(child, request, addr, data);
299 break;
300 }
301out:
302 return ret;
303}