Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / arch / mips / kernel / ptrace.c
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/kernel.h>
19 #include <linux/sched.h>
20 #include <linux/mm.h>
21 #include <linux/errno.h>
22 #include <linux/ptrace.h>
23 #include <linux/smp.h>
24 #include <linux/user.h>
25 #include <linux/security.h>
26 #include <linux/audit.h>
27 #include <linux/seccomp.h>
28
29 #include <asm/byteorder.h>
30 #include <asm/cpu.h>
31 #include <asm/dsp.h>
32 #include <asm/fpu.h>
33 #include <asm/mipsregs.h>
34 #include <asm/mipsmtregs.h>
35 #include <asm/pgtable.h>
36 #include <asm/page.h>
37 #include <asm/system.h>
38 #include <asm/uaccess.h>
39 #include <asm/bootinfo.h>
40 #include <asm/reg.h>
41
42 /*
43  * Called by kernel/ptrace.c when detaching..
44  *
45  * Make sure single step bits etc are not set.
46  */
47 void ptrace_disable(struct task_struct *child)
48 {
49         /* Don't load the watchpoint registers for the ex-child. */
50         clear_tsk_thread_flag(child, TIF_LOAD_WATCH);
51 }
52
53 /*
54  * Read a general register set.  We always use the 64-bit format, even
55  * for 32-bit kernels and for 32-bit processes on a 64-bit kernel.
56  * Registers are sign extended to fill the available space.
57  */
58 int ptrace_getregs(struct task_struct *child, __s64 __user *data)
59 {
60         struct pt_regs *regs;
61         int i;
62
63         if (!access_ok(VERIFY_WRITE, data, 38 * 8))
64                 return -EIO;
65
66         regs = task_pt_regs(child);
67
68         for (i = 0; i < 32; i++)
69                 __put_user((long)regs->regs[i], data + i);
70         __put_user((long)regs->lo, data + EF_LO - EF_R0);
71         __put_user((long)regs->hi, data + EF_HI - EF_R0);
72         __put_user((long)regs->cp0_epc, data + EF_CP0_EPC - EF_R0);
73         __put_user((long)regs->cp0_badvaddr, data + EF_CP0_BADVADDR - EF_R0);
74         __put_user((long)regs->cp0_status, data + EF_CP0_STATUS - EF_R0);
75         __put_user((long)regs->cp0_cause, data + EF_CP0_CAUSE - EF_R0);
76
77         return 0;
78 }
79
80 /*
81  * Write a general register set.  As for PTRACE_GETREGS, we always use
82  * the 64-bit format.  On a 32-bit kernel only the lower order half
83  * (according to endianness) will be used.
84  */
85 int ptrace_setregs(struct task_struct *child, __s64 __user *data)
86 {
87         struct pt_regs *regs;
88         int i;
89
90         if (!access_ok(VERIFY_READ, data, 38 * 8))
91                 return -EIO;
92
93         regs = task_pt_regs(child);
94
95         for (i = 0; i < 32; i++)
96                 __get_user(regs->regs[i], data + i);
97         __get_user(regs->lo, data + EF_LO - EF_R0);
98         __get_user(regs->hi, data + EF_HI - EF_R0);
99         __get_user(regs->cp0_epc, data + EF_CP0_EPC - EF_R0);
100
101         /* badvaddr, status, and cause may not be written.  */
102
103         return 0;
104 }
105
106 int ptrace_getfpregs(struct task_struct *child, __u32 __user *data)
107 {
108         int i;
109         unsigned int tmp;
110
111         if (!access_ok(VERIFY_WRITE, data, 33 * 8))
112                 return -EIO;
113
114         if (tsk_used_math(child)) {
115                 fpureg_t *fregs = get_fpu_regs(child);
116                 for (i = 0; i < 32; i++)
117                         __put_user(fregs[i], i + (__u64 __user *) data);
118         } else {
119                 for (i = 0; i < 32; i++)
120                         __put_user((__u64) -1, i + (__u64 __user *) data);
121         }
122
123         __put_user(child->thread.fpu.fcr31, data + 64);
124
125         preempt_disable();
126         if (cpu_has_fpu) {
127                 unsigned int flags;
128
129                 if (cpu_has_mipsmt) {
130                         unsigned int vpflags = dvpe();
131                         flags = read_c0_status();
132                         __enable_fpu();
133                         __asm__ __volatile__("cfc1\t%0,$0" : "=r" (tmp));
134                         write_c0_status(flags);
135                         evpe(vpflags);
136                 } else {
137                         flags = read_c0_status();
138                         __enable_fpu();
139                         __asm__ __volatile__("cfc1\t%0,$0" : "=r" (tmp));
140                         write_c0_status(flags);
141                 }
142         } else {
143                 tmp = 0;
144         }
145         preempt_enable();
146         __put_user(tmp, data + 65);
147
148         return 0;
149 }
150
151 int ptrace_setfpregs(struct task_struct *child, __u32 __user *data)
152 {
153         fpureg_t *fregs;
154         int i;
155
156         if (!access_ok(VERIFY_READ, data, 33 * 8))
157                 return -EIO;
158
159         fregs = get_fpu_regs(child);
160
161         for (i = 0; i < 32; i++)
162                 __get_user(fregs[i], i + (__u64 __user *) data);
163
164         __get_user(child->thread.fpu.fcr31, data + 64);
165
166         /* FIR may not be written.  */
167
168         return 0;
169 }
170
171 int ptrace_get_watch_regs(struct task_struct *child,
172                           struct pt_watch_regs __user *addr)
173 {
174         enum pt_watch_style style;
175         int i;
176
177         if (!cpu_has_watch || current_cpu_data.watch_reg_use_cnt == 0)
178                 return -EIO;
179         if (!access_ok(VERIFY_WRITE, addr, sizeof(struct pt_watch_regs)))
180                 return -EIO;
181
182 #ifdef CONFIG_32BIT
183         style = pt_watch_style_mips32;
184 #define WATCH_STYLE mips32
185 #else
186         style = pt_watch_style_mips64;
187 #define WATCH_STYLE mips64
188 #endif
189
190         __put_user(style, &addr->style);
191         __put_user(current_cpu_data.watch_reg_use_cnt,
192                    &addr->WATCH_STYLE.num_valid);
193         for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
194                 __put_user(child->thread.watch.mips3264.watchlo[i],
195                            &addr->WATCH_STYLE.watchlo[i]);
196                 __put_user(child->thread.watch.mips3264.watchhi[i] & 0xfff,
197                            &addr->WATCH_STYLE.watchhi[i]);
198                 __put_user(current_cpu_data.watch_reg_masks[i],
199                            &addr->WATCH_STYLE.watch_masks[i]);
200         }
201         for (; i < 8; i++) {
202                 __put_user(0, &addr->WATCH_STYLE.watchlo[i]);
203                 __put_user(0, &addr->WATCH_STYLE.watchhi[i]);
204                 __put_user(0, &addr->WATCH_STYLE.watch_masks[i]);
205         }
206
207         return 0;
208 }
209
210 int ptrace_set_watch_regs(struct task_struct *child,
211                           struct pt_watch_regs __user *addr)
212 {
213         int i;
214         int watch_active = 0;
215         unsigned long lt[NUM_WATCH_REGS];
216         u16 ht[NUM_WATCH_REGS];
217
218         if (!cpu_has_watch || current_cpu_data.watch_reg_use_cnt == 0)
219                 return -EIO;
220         if (!access_ok(VERIFY_READ, addr, sizeof(struct pt_watch_regs)))
221                 return -EIO;
222         /* Check the values. */
223         for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
224                 __get_user(lt[i], &addr->WATCH_STYLE.watchlo[i]);
225 #ifdef CONFIG_32BIT
226                 if (lt[i] & __UA_LIMIT)
227                         return -EINVAL;
228 #else
229                 if (test_tsk_thread_flag(child, TIF_32BIT_ADDR)) {
230                         if (lt[i] & 0xffffffff80000000UL)
231                                 return -EINVAL;
232                 } else {
233                         if (lt[i] & __UA_LIMIT)
234                                 return -EINVAL;
235                 }
236 #endif
237                 __get_user(ht[i], &addr->WATCH_STYLE.watchhi[i]);
238                 if (ht[i] & ~0xff8)
239                         return -EINVAL;
240         }
241         /* Install them. */
242         for (i = 0; i < current_cpu_data.watch_reg_use_cnt; i++) {
243                 if (lt[i] & 7)
244                         watch_active = 1;
245                 child->thread.watch.mips3264.watchlo[i] = lt[i];
246                 /* Set the G bit. */
247                 child->thread.watch.mips3264.watchhi[i] = ht[i];
248         }
249
250         if (watch_active)
251                 set_tsk_thread_flag(child, TIF_LOAD_WATCH);
252         else
253                 clear_tsk_thread_flag(child, TIF_LOAD_WATCH);
254
255         return 0;
256 }
257
258 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
259 {
260         int ret;
261
262         switch (request) {
263         /* when I and D space are separate, these will need to be fixed. */
264         case PTRACE_PEEKTEXT: /* read word at location addr. */
265         case PTRACE_PEEKDATA:
266                 ret = generic_ptrace_peekdata(child, addr, data);
267                 break;
268
269         /* Read the word at location addr in the USER area. */
270         case PTRACE_PEEKUSR: {
271                 struct pt_regs *regs;
272                 unsigned long tmp = 0;
273
274                 regs = task_pt_regs(child);
275                 ret = 0;  /* Default return value. */
276
277                 switch (addr) {
278                 case 0 ... 31:
279                         tmp = regs->regs[addr];
280                         break;
281                 case FPR_BASE ... FPR_BASE + 31:
282                         if (tsk_used_math(child)) {
283                                 fpureg_t *fregs = get_fpu_regs(child);
284
285 #ifdef CONFIG_32BIT
286                                 /*
287                                  * The odd registers are actually the high
288                                  * order bits of the values stored in the even
289                                  * registers - unless we're using r2k_switch.S.
290                                  */
291                                 if (addr & 1)
292                                         tmp = (unsigned long) (fregs[((addr & ~1) - 32)] >> 32);
293                                 else
294                                         tmp = (unsigned long) (fregs[(addr - 32)] & 0xffffffff);
295 #endif
296 #ifdef CONFIG_64BIT
297                                 tmp = fregs[addr - FPR_BASE];
298 #endif
299                         } else {
300                                 tmp = -1;       /* FP not yet used  */
301                         }
302                         break;
303                 case PC:
304                         tmp = regs->cp0_epc;
305                         break;
306                 case CAUSE:
307                         tmp = regs->cp0_cause;
308                         break;
309                 case BADVADDR:
310                         tmp = regs->cp0_badvaddr;
311                         break;
312                 case MMHI:
313                         tmp = regs->hi;
314                         break;
315                 case MMLO:
316                         tmp = regs->lo;
317                         break;
318 #ifdef CONFIG_CPU_HAS_SMARTMIPS
319                 case ACX:
320                         tmp = regs->acx;
321                         break;
322 #endif
323                 case FPC_CSR:
324                         tmp = child->thread.fpu.fcr31;
325                         break;
326                 case FPC_EIR: { /* implementation / version register */
327                         unsigned int flags;
328 #ifdef CONFIG_MIPS_MT_SMTC
329                         unsigned long irqflags;
330                         unsigned int mtflags;
331 #endif /* CONFIG_MIPS_MT_SMTC */
332
333                         preempt_disable();
334                         if (!cpu_has_fpu) {
335                                 preempt_enable();
336                                 break;
337                         }
338
339 #ifdef CONFIG_MIPS_MT_SMTC
340                         /* Read-modify-write of Status must be atomic */
341                         local_irq_save(irqflags);
342                         mtflags = dmt();
343 #endif /* CONFIG_MIPS_MT_SMTC */
344                         if (cpu_has_mipsmt) {
345                                 unsigned int vpflags = dvpe();
346                                 flags = read_c0_status();
347                                 __enable_fpu();
348                                 __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
349                                 write_c0_status(flags);
350                                 evpe(vpflags);
351                         } else {
352                                 flags = read_c0_status();
353                                 __enable_fpu();
354                                 __asm__ __volatile__("cfc1\t%0,$0": "=r" (tmp));
355                                 write_c0_status(flags);
356                         }
357 #ifdef CONFIG_MIPS_MT_SMTC
358                         emt(mtflags);
359                         local_irq_restore(irqflags);
360 #endif /* CONFIG_MIPS_MT_SMTC */
361                         preempt_enable();
362                         break;
363                 }
364                 case DSP_BASE ... DSP_BASE + 5: {
365                         dspreg_t *dregs;
366
367                         if (!cpu_has_dsp) {
368                                 tmp = 0;
369                                 ret = -EIO;
370                                 goto out;
371                         }
372                         dregs = __get_dsp_regs(child);
373                         tmp = (unsigned long) (dregs[addr - DSP_BASE]);
374                         break;
375                 }
376                 case DSP_CONTROL:
377                         if (!cpu_has_dsp) {
378                                 tmp = 0;
379                                 ret = -EIO;
380                                 goto out;
381                         }
382                         tmp = child->thread.dsp.dspcontrol;
383                         break;
384                 default:
385                         tmp = 0;
386                         ret = -EIO;
387                         goto out;
388                 }
389                 ret = put_user(tmp, (unsigned long __user *) data);
390                 break;
391         }
392
393         /* when I and D space are separate, this will have to be fixed. */
394         case PTRACE_POKETEXT: /* write the word at location addr. */
395         case PTRACE_POKEDATA:
396                 ret = generic_ptrace_pokedata(child, addr, data);
397                 break;
398
399         case PTRACE_POKEUSR: {
400                 struct pt_regs *regs;
401                 ret = 0;
402                 regs = task_pt_regs(child);
403
404                 switch (addr) {
405                 case 0 ... 31:
406                         regs->regs[addr] = data;
407                         break;
408                 case FPR_BASE ... FPR_BASE + 31: {
409                         fpureg_t *fregs = get_fpu_regs(child);
410
411                         if (!tsk_used_math(child)) {
412                                 /* FP not yet used  */
413                                 memset(&child->thread.fpu, ~0,
414                                        sizeof(child->thread.fpu));
415                                 child->thread.fpu.fcr31 = 0;
416                         }
417 #ifdef CONFIG_32BIT
418                         /*
419                          * The odd registers are actually the high order bits
420                          * of the values stored in the even registers - unless
421                          * we're using r2k_switch.S.
422                          */
423                         if (addr & 1) {
424                                 fregs[(addr & ~1) - FPR_BASE] &= 0xffffffff;
425                                 fregs[(addr & ~1) - FPR_BASE] |= ((unsigned long long) data) << 32;
426                         } else {
427                                 fregs[addr - FPR_BASE] &= ~0xffffffffLL;
428                                 fregs[addr - FPR_BASE] |= data;
429                         }
430 #endif
431 #ifdef CONFIG_64BIT
432                         fregs[addr - FPR_BASE] = data;
433 #endif
434                         break;
435                 }
436                 case PC:
437                         regs->cp0_epc = data;
438                         break;
439                 case MMHI:
440                         regs->hi = data;
441                         break;
442                 case MMLO:
443                         regs->lo = data;
444                         break;
445 #ifdef CONFIG_CPU_HAS_SMARTMIPS
446                 case ACX:
447                         regs->acx = data;
448                         break;
449 #endif
450                 case FPC_CSR:
451                         child->thread.fpu.fcr31 = data;
452                         break;
453                 case DSP_BASE ... DSP_BASE + 5: {
454                         dspreg_t *dregs;
455
456                         if (!cpu_has_dsp) {
457                                 ret = -EIO;
458                                 break;
459                         }
460
461                         dregs = __get_dsp_regs(child);
462                         dregs[addr - DSP_BASE] = data;
463                         break;
464                 }
465                 case DSP_CONTROL:
466                         if (!cpu_has_dsp) {
467                                 ret = -EIO;
468                                 break;
469                         }
470                         child->thread.dsp.dspcontrol = data;
471                         break;
472                 default:
473                         /* The rest are not allowed. */
474                         ret = -EIO;
475                         break;
476                 }
477                 break;
478                 }
479
480         case PTRACE_GETREGS:
481                 ret = ptrace_getregs(child, (__s64 __user *) data);
482                 break;
483
484         case PTRACE_SETREGS:
485                 ret = ptrace_setregs(child, (__s64 __user *) data);
486                 break;
487
488         case PTRACE_GETFPREGS:
489                 ret = ptrace_getfpregs(child, (__u32 __user *) data);
490                 break;
491
492         case PTRACE_SETFPREGS:
493                 ret = ptrace_setfpregs(child, (__u32 __user *) data);
494                 break;
495
496         case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
497         case PTRACE_CONT: { /* restart after signal. */
498                 ret = -EIO;
499                 if (!valid_signal(data))
500                         break;
501                 if (request == PTRACE_SYSCALL) {
502                         set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
503                 }
504                 else {
505                         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
506                 }
507                 child->exit_code = data;
508                 wake_up_process(child);
509                 ret = 0;
510                 break;
511         }
512
513         /*
514          * make the child exit.  Best I can do is send it a sigkill.
515          * perhaps it should be put in the status that it wants to
516          * exit.
517          */
518         case PTRACE_KILL:
519                 ret = 0;
520                 if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
521                         break;
522                 child->exit_code = SIGKILL;
523                 wake_up_process(child);
524                 break;
525
526         case PTRACE_GET_THREAD_AREA:
527                 ret = put_user(task_thread_info(child)->tp_value,
528                                 (unsigned long __user *) data);
529                 break;
530
531         case PTRACE_GET_WATCH_REGS:
532                 ret = ptrace_get_watch_regs(child,
533                                         (struct pt_watch_regs __user *) addr);
534                 break;
535
536         case PTRACE_SET_WATCH_REGS:
537                 ret = ptrace_set_watch_regs(child,
538                                         (struct pt_watch_regs __user *) addr);
539                 break;
540
541         default:
542                 ret = ptrace_request(child, request, addr, data);
543                 break;
544         }
545  out:
546         return ret;
547 }
548
549 static inline int audit_arch(void)
550 {
551         int arch = EM_MIPS;
552 #ifdef CONFIG_64BIT
553         arch |=  __AUDIT_ARCH_64BIT;
554 #endif
555 #if defined(__LITTLE_ENDIAN)
556         arch |=  __AUDIT_ARCH_LE;
557 #endif
558         return arch;
559 }
560
561 /*
562  * Notification of system call entry/exit
563  * - triggered by current->work.syscall_trace
564  */
565 asmlinkage void do_syscall_trace(struct pt_regs *regs, int entryexit)
566 {
567         /* do the secure computing check first */
568         if (!entryexit)
569                 secure_computing(regs->regs[0]);
570
571         if (unlikely(current->audit_context) && entryexit)
572                 audit_syscall_exit(AUDITSC_RESULT(regs->regs[2]),
573                                    regs->regs[2]);
574
575         if (!(current->ptrace & PT_PTRACED))
576                 goto out;
577
578         if (!test_thread_flag(TIF_SYSCALL_TRACE))
579                 goto out;
580
581         /* The 0x80 provides a way for the tracing parent to distinguish
582            between a syscall stop and SIGTRAP delivery */
583         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) ?
584                                  0x80 : 0));
585
586         /*
587          * this isn't the same as continuing with a signal, but it will do
588          * for normal use.  strace only continues with a signal if the
589          * stopping signal is not SIGTRAP.  -brl
590          */
591         if (current->exit_code) {
592                 send_sig(current->exit_code, current, 1);
593                 current->exit_code = 0;
594         }
595
596 out:
597         if (unlikely(current->audit_context) && !entryexit)
598                 audit_syscall_entry(audit_arch(), regs->regs[0],
599                                     regs->regs[4], regs->regs[5],
600                                     regs->regs[6], regs->regs[7]);
601 }