~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/kernel/ptrace32.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <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  */
 42 long 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 = 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 
 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 (access_process_vm(child, (u64)addrOthers, &data,
182                                         sizeof(data), 1) == sizeof(data))
183                         break;
184                 ret = -EIO;
185                 break;
186         }
187 
188         case PTRACE_POKEUSR: {
189                 struct pt_regs *regs;
190                 ret = 0;
191                 regs = task_pt_regs(child);
192 
193                 switch (addr) {
194                 case 0 ... 31:
195                         regs->regs[addr] = data;
196                         break;
197                 case FPR_BASE ... FPR_BASE + 31: {
198                         union fpureg *fregs = get_fpu_regs(child);
199 
200                         if (!tsk_used_math(child)) {
201                                 /* FP not yet used  */
202                                 memset(&child->thread.fpu, ~0,
203                                        sizeof(child->thread.fpu));
204                                 child->thread.fpu.fcr31 = 0;
205                         }
206                         if (test_thread_flag(TIF_32BIT_FPREGS)) {
207                                 /*
208                                  * The odd registers are actually the high
209                                  * order bits of the values stored in the even
210                                  * registers - unless we're using r2k_switch.S.
211                                  */
212                                 set_fpr32(&fregs[(addr & ~1) - FPR_BASE],
213                                           addr & 1, data);
214                                 break;
215                         }
216                         set_fpr64(&fregs[addr - FPR_BASE], 0, data);
217                         break;
218                 }
219                 case PC:
220                         regs->cp0_epc = data;
221                         break;
222                 case MMHI:
223                         regs->hi = data;
224                         break;
225                 case MMLO:
226                         regs->lo = data;
227                         break;
228                 case FPC_CSR:
229                         child->thread.fpu.fcr31 = data;
230                         break;
231                 case DSP_BASE ... DSP_BASE + 5: {
232                         dspreg_t *dregs;
233 
234                         if (!cpu_has_dsp) {
235                                 ret = -EIO;
236                                 break;
237                         }
238 
239                         dregs = __get_dsp_regs(child);
240                         dregs[addr - DSP_BASE] = data;
241                         break;
242                 }
243                 case DSP_CONTROL:
244                         if (!cpu_has_dsp) {
245                                 ret = -EIO;
246                                 break;
247                         }
248                         child->thread.dsp.dspcontrol = data;
249                         break;
250                 default:
251                         /* The rest are not allowed. */
252                         ret = -EIO;
253                         break;
254                 }
255                 break;
256                 }
257 
258         case PTRACE_GETREGS:
259                 ret = ptrace_getregs(child,
260                                 (struct user_pt_regs __user *) (__u64) data);
261                 break;
262 
263         case PTRACE_SETREGS:
264                 ret = ptrace_setregs(child,
265                                 (struct user_pt_regs __user *) (__u64) data);
266                 break;
267 
268         case PTRACE_GETFPREGS:
269                 ret = ptrace_getfpregs(child, (__u32 __user *) (__u64) data);
270                 break;
271 
272         case PTRACE_SETFPREGS:
273                 ret = ptrace_setfpregs(child, (__u32 __user *) (__u64) data);
274                 break;
275 
276         case PTRACE_GET_THREAD_AREA:
277                 ret = put_user(task_thread_info(child)->tp_value,
278                                 (unsigned int __user *) (unsigned long) data);
279                 break;
280 
281         case PTRACE_GET_THREAD_AREA_3264:
282                 ret = put_user(task_thread_info(child)->tp_value,
283                                 (unsigned long __user *) (unsigned long) data);
284                 break;
285 
286         case PTRACE_GET_WATCH_REGS:
287                 ret = ptrace_get_watch_regs(child,
288                         (struct pt_watch_regs __user *) (unsigned long) addr);
289                 break;
290 
291         case PTRACE_SET_WATCH_REGS:
292                 ret = ptrace_set_watch_regs(child,
293                         (struct pt_watch_regs __user *) (unsigned long) addr);
294                 break;
295 
296         default:
297                 ret = compat_ptrace_request(child, request, addr, data);
298                 break;
299         }
300 out:
301         return ret;
302 }
303 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp