blob: a3b017815eff0bc3e8e918276de132b2fc336f84 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +020018#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/user.h>
26#include <linux/security.h>
27
28#include <asm/cpu.h>
Ralf Baechlee50c0a82005-05-31 11:49:19 +000029#include <asm/dsp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/fpu.h>
31#include <asm/mipsregs.h>
Ralf Baechle101b3532005-10-06 17:39:32 +010032#include <asm/mipsmtregs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/pgtable.h>
34#include <asm/page.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/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 */
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +020042long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
43 compat_ulong_t caddr, compat_ulong_t cdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +020045 int addr = caddr;
46 int data = cdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 int ret;
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 switch (request) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -040051 /*
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 = access_process_vm(child, (u64)addrOthers, &tmp,
73 sizeof(tmp), 0);
74 if (copied != sizeof(tmp))
75 break;
76 ret = put_user(tmp, (u32 __user *) (unsigned long) data);
77 break;
78 }
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 /* Read the word at location addr in the USER area. */
81 case PTRACE_PEEKUSR: {
82 struct pt_regs *regs;
83 unsigned int tmp;
84
Al Viro40bc9c62006-01-12 01:06:07 -080085 regs = task_pt_regs(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 ret = 0; /* Default return value. */
87
88 switch (addr) {
89 case 0 ... 31:
90 tmp = regs->regs[addr];
91 break;
92 case FPR_BASE ... FPR_BASE + 31:
93 if (tsk_used_math(child)) {
94 fpureg_t *fregs = get_fpu_regs(child);
95
96 /*
97 * The odd registers are actually the high
98 * order bits of the values stored in the even
99 * registers - unless we're using r2k_switch.S.
100 */
101 if (addr & 1)
102 tmp = (unsigned long) (fregs[((addr & ~1) - 32)] >> 32);
103 else
104 tmp = (unsigned long) (fregs[(addr - 32)] & 0xffffffff);
105 } else {
106 tmp = -1; /* FP not yet used */
107 }
108 break;
109 case PC:
110 tmp = regs->cp0_epc;
111 break;
112 case CAUSE:
113 tmp = regs->cp0_cause;
114 break;
115 case BADVADDR:
116 tmp = regs->cp0_badvaddr;
117 break;
118 case MMHI:
119 tmp = regs->hi;
120 break;
121 case MMLO:
122 tmp = regs->lo;
123 break;
124 case FPC_CSR:
Atsushi Nemotoeae89072006-05-16 01:26:03 +0900125 tmp = child->thread.fpu.fcr31;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 break;
127 case FPC_EIR: { /* implementation / version register */
128 unsigned int flags;
Ralf Baechle41c594a2006-04-05 09:45:45 +0100129#ifdef CONFIG_MIPS_MT_SMTC
130 unsigned int irqflags;
131 unsigned int mtflags;
132#endif /* CONFIG_MIPS_MT_SMTC */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Atsushi Nemotoe04582b2006-10-09 00:10:01 +0900134 preempt_disable();
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900135 if (!cpu_has_fpu) {
Atsushi Nemotoe04582b2006-10-09 00:10:01 +0900136 preempt_enable();
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900137 tmp = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 break;
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900139 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Ralf Baechle41c594a2006-04-05 09:45:45 +0100141#ifdef CONFIG_MIPS_MT_SMTC
142 /* Read-modify-write of Status must be atomic */
143 local_irq_save(irqflags);
144 mtflags = dmt();
145#endif /* CONFIG_MIPS_MT_SMTC */
146
Ralf Baechle101b3532005-10-06 17:39:32 +0100147 if (cpu_has_mipsmt) {
148 unsigned int vpflags = dvpe();
149 flags = read_c0_status();
150 __enable_fpu();
151 __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
152 write_c0_status(flags);
153 evpe(vpflags);
154 } else {
155 flags = read_c0_status();
156 __enable_fpu();
157 __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
158 write_c0_status(flags);
159 }
Ralf Baechle41c594a2006-04-05 09:45:45 +0100160#ifdef CONFIG_MIPS_MT_SMTC
161 emt(mtflags);
162 local_irq_restore(irqflags);
163#endif /* CONFIG_MIPS_MT_SMTC */
Ralf Baechle101b3532005-10-06 17:39:32 +0100164 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 break;
166 }
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900167 case DSP_BASE ... DSP_BASE + 5: {
168 dspreg_t *dregs;
169
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000170 if (!cpu_has_dsp) {
171 tmp = 0;
172 ret = -EIO;
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +0200173 goto out;
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000174 }
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900175 dregs = __get_dsp_regs(child);
Ralf Baechle6c355852005-12-05 13:47:25 +0000176 tmp = (unsigned long) (dregs[addr - DSP_BASE]);
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000177 break;
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900178 }
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000179 case DSP_CONTROL:
180 if (!cpu_has_dsp) {
181 tmp = 0;
182 ret = -EIO;
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +0200183 goto out;
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000184 }
185 tmp = child->thread.dsp.dspcontrol;
186 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 default:
188 tmp = 0;
189 ret = -EIO;
Thomas Bogendoerfer5d9a76c2008-08-17 16:49:25 +0200190 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900192 ret = put_user(tmp, (unsigned __user *) (unsigned long) data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 break;
194 }
195
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400196 /*
197 * Write 4 bytes into the other process' storage
198 * data is the 4 bytes that the user wants written
199 * addr is a pointer in the user's storage that contains an
200 * 8 byte address in the other process where the 4 bytes
201 * that is to be written
202 * (this is run in a 32-bit process looking at a 64-bit process)
203 * when I and D space are separate, these will need to be fixed.
204 */
205 case PTRACE_POKETEXT_3264:
206 case PTRACE_POKEDATA_3264: {
207 u32 __user * addrOthers;
208
209 /* Get the addr in the other process that we want to write into */
210 ret = -EIO;
211 if (get_user(addrOthers, (u32 __user * __user *) (unsigned long) addr) != 0)
212 break;
213 ret = 0;
214 if (access_process_vm(child, (u64)addrOthers, &data,
215 sizeof(data), 1) == sizeof(data))
216 break;
217 ret = -EIO;
218 break;
219 }
220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 case PTRACE_POKEUSR: {
222 struct pt_regs *regs;
223 ret = 0;
Al Viro40bc9c62006-01-12 01:06:07 -0800224 regs = task_pt_regs(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 switch (addr) {
227 case 0 ... 31:
228 regs->regs[addr] = data;
229 break;
230 case FPR_BASE ... FPR_BASE + 31: {
231 fpureg_t *fregs = get_fpu_regs(child);
232
233 if (!tsk_used_math(child)) {
234 /* FP not yet used */
Atsushi Nemotoeae89072006-05-16 01:26:03 +0900235 memset(&child->thread.fpu, ~0,
236 sizeof(child->thread.fpu));
237 child->thread.fpu.fcr31 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
239 /*
240 * The odd registers are actually the high order bits
241 * of the values stored in the even registers - unless
242 * we're using r2k_switch.S.
243 */
244 if (addr & 1) {
245 fregs[(addr & ~1) - FPR_BASE] &= 0xffffffff;
246 fregs[(addr & ~1) - FPR_BASE] |= ((unsigned long long) data) << 32;
247 } else {
248 fregs[addr - FPR_BASE] &= ~0xffffffffLL;
249 /* Must cast, lest sign extension fill upper
250 bits! */
251 fregs[addr - FPR_BASE] |= (unsigned int)data;
252 }
253 break;
254 }
255 case PC:
256 regs->cp0_epc = data;
257 break;
258 case MMHI:
259 regs->hi = data;
260 break;
261 case MMLO:
262 regs->lo = data;
263 break;
264 case FPC_CSR:
Atsushi Nemotoeae89072006-05-16 01:26:03 +0900265 child->thread.fpu.fcr31 = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 break;
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900267 case DSP_BASE ... DSP_BASE + 5: {
268 dspreg_t *dregs;
269
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000270 if (!cpu_has_dsp) {
271 ret = -EIO;
272 break;
273 }
274
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900275 dregs = __get_dsp_regs(child);
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000276 dregs[addr - DSP_BASE] = data;
277 break;
Atsushi Nemoto3055acb2006-01-29 22:34:32 +0900278 }
Ralf Baechlee50c0a82005-05-31 11:49:19 +0000279 case DSP_CONTROL:
280 if (!cpu_has_dsp) {
281 ret = -EIO;
282 break;
283 }
284 child->thread.dsp.dspcontrol = data;
285 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 default:
287 /* The rest are not allowed. */
288 ret = -EIO;
289 break;
290 }
291 break;
292 }
293
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400294 case PTRACE_GETREGS:
Atsushi Nemoto62b14c22007-10-26 00:53:02 +0900295 ret = ptrace_getregs(child, (__s64 __user *) (__u64) data);
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400296 break;
297
298 case PTRACE_SETREGS:
Atsushi Nemoto62b14c22007-10-26 00:53:02 +0900299 ret = ptrace_setregs(child, (__s64 __user *) (__u64) data);
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400300 break;
301
302 case PTRACE_GETFPREGS:
Ralf Baechle49a89ef2007-10-11 23:46:15 +0100303 ret = ptrace_getfpregs(child, (__u32 __user *) (__u64) data);
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400304 break;
305
306 case PTRACE_SETFPREGS:
Ralf Baechle49a89ef2007-10-11 23:46:15 +0100307 ret = ptrace_setfpregs(child, (__u32 __user *) (__u64) data);
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400308 break;
309
Ralf Baechle3c370262005-04-13 17:43:59 +0000310 case PTRACE_GET_THREAD_AREA:
Al Virodc8f6022006-01-12 01:06:07 -0800311 ret = put_user(task_thread_info(child)->tp_value,
Ralf Baechle3c370262005-04-13 17:43:59 +0000312 (unsigned int __user *) (unsigned long) data);
313 break;
314
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400315 case PTRACE_GET_THREAD_AREA_3264:
Al Virodc8f6022006-01-12 01:06:07 -0800316 ret = put_user(task_thread_info(child)->tp_value,
Daniel Jacobowitzea3d7102005-09-28 18:11:15 -0400317 (unsigned long __user *) (unsigned long) data);
318 break;
319
David Daney0926bf92008-09-23 00:11:26 -0700320 case PTRACE_GET_WATCH_REGS:
321 ret = ptrace_get_watch_regs(child,
322 (struct pt_watch_regs __user *) (unsigned long) addr);
323 break;
324
325 case PTRACE_SET_WATCH_REGS:
326 ret = ptrace_set_watch_regs(child,
327 (struct pt_watch_regs __user *) (unsigned long) addr);
328 break;
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 default:
Anirban Sinha797c3f32008-11-13 11:50:12 -0800331 ret = compat_ptrace_request(child, request, addr, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 break;
333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return ret;
336}