Merge git://git.infradead.org/~dwmw2/rbtree-2.6
[linux-2.6] / arch / x86_64 / kernel / ptrace.c
1 /* ptrace.c */
2 /* By Ross Biro 1/23/92 */
3 /*
4  * Pentium III FXSR, SSE support
5  *      Gareth Hughes <gareth@valinux.com>, May 2000
6  * 
7  * x86-64 port 2000-2002 Andi Kleen
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/smp_lock.h>
15 #include <linux/errno.h>
16 #include <linux/ptrace.h>
17 #include <linux/user.h>
18 #include <linux/security.h>
19 #include <linux/audit.h>
20 #include <linux/seccomp.h>
21 #include <linux/signal.h>
22
23 #include <asm/uaccess.h>
24 #include <asm/pgtable.h>
25 #include <asm/system.h>
26 #include <asm/processor.h>
27 #include <asm/i387.h>
28 #include <asm/debugreg.h>
29 #include <asm/ldt.h>
30 #include <asm/desc.h>
31 #include <asm/proto.h>
32 #include <asm/ia32.h>
33
34 /*
35  * does not yet catch signals sent when the child dies.
36  * in exit.c or in signal.c.
37  */
38
39 /*
40  * Determines which flags the user has access to [1 = access, 0 = no access].
41  * Prohibits changing ID(21), VIP(20), VIF(19), VM(17), IOPL(12-13), IF(9).
42  * Also masks reserved bits (63-22, 15, 5, 3, 1).
43  */
44 #define FLAG_MASK 0x54dd5UL
45
46 /* set's the trap flag. */
47 #define TRAP_FLAG 0x100UL
48
49 /*
50  * eflags and offset of eflags on child stack..
51  */
52 #define EFLAGS offsetof(struct pt_regs, eflags)
53 #define EFL_OFFSET ((int)(EFLAGS-sizeof(struct pt_regs)))
54
55 /*
56  * this routine will get a word off of the processes privileged stack. 
57  * the offset is how far from the base addr as stored in the TSS.  
58  * this routine assumes that all the privileged stacks are in our
59  * data space.
60  */   
61 static inline unsigned long get_stack_long(struct task_struct *task, int offset)
62 {
63         unsigned char *stack;
64
65         stack = (unsigned char *)task->thread.rsp0;
66         stack += offset;
67         return (*((unsigned long *)stack));
68 }
69
70 /*
71  * this routine will put a word on the processes privileged stack. 
72  * the offset is how far from the base addr as stored in the TSS.  
73  * this routine assumes that all the privileged stacks are in our
74  * data space.
75  */
76 static inline long put_stack_long(struct task_struct *task, int offset,
77         unsigned long data)
78 {
79         unsigned char * stack;
80
81         stack = (unsigned char *) task->thread.rsp0;
82         stack += offset;
83         *(unsigned long *) stack = data;
84         return 0;
85 }
86
87 #define LDT_SEGMENT 4
88
89 unsigned long convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs)
90 {
91         unsigned long addr, seg;
92
93         addr = regs->rip;
94         seg = regs->cs & 0xffff;
95
96         /*
97          * We'll assume that the code segments in the GDT
98          * are all zero-based. That is largely true: the
99          * TLS segments are used for data, and the PNPBIOS
100          * and APM bios ones we just ignore here.
101          */
102         if (seg & LDT_SEGMENT) {
103                 u32 *desc;
104                 unsigned long base;
105
106                 down(&child->mm->context.sem);
107                 desc = child->mm->context.ldt + (seg & ~7);
108                 base = (desc[0] >> 16) | ((desc[1] & 0xff) << 16) | (desc[1] & 0xff000000);
109
110                 /* 16-bit code segment? */
111                 if (!((desc[1] >> 22) & 1))
112                         addr &= 0xffff;
113                 addr += base;
114                 up(&child->mm->context.sem);
115         }
116         return addr;
117 }
118
119 static int is_at_popf(struct task_struct *child, struct pt_regs *regs)
120 {
121         int i, copied;
122         unsigned char opcode[16];
123         unsigned long addr = convert_rip_to_linear(child, regs);
124
125         copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
126         for (i = 0; i < copied; i++) {
127                 switch (opcode[i]) {
128                 /* popf */
129                 case 0x9d:
130                         return 1;
131
132                         /* CHECKME: 64 65 */
133
134                 /* opcode and address size prefixes */
135                 case 0x66: case 0x67:
136                         continue;
137                 /* irrelevant prefixes (segment overrides and repeats) */
138                 case 0x26: case 0x2e:
139                 case 0x36: case 0x3e:
140                 case 0x64: case 0x65:
141                 case 0xf0: case 0xf2: case 0xf3:
142                         continue;
143
144                 /* REX prefixes */
145                 case 0x40 ... 0x4f:
146                         continue;
147
148                         /* CHECKME: f0, f2, f3 */
149
150                 /*
151                  * pushf: NOTE! We should probably not let
152                  * the user see the TF bit being set. But
153                  * it's more pain than it's worth to avoid
154                  * it, and a debugger could emulate this
155                  * all in user space if it _really_ cares.
156                  */
157                 case 0x9c:
158                 default:
159                         return 0;
160                 }
161         }
162         return 0;
163 }
164
165 static void set_singlestep(struct task_struct *child)
166 {
167         struct pt_regs *regs = task_pt_regs(child);
168
169         /*
170          * Always set TIF_SINGLESTEP - this guarantees that
171          * we single-step system calls etc..  This will also
172          * cause us to set TF when returning to user mode.
173          */
174         set_tsk_thread_flag(child, TIF_SINGLESTEP);
175
176         /*
177          * If TF was already set, don't do anything else
178          */
179         if (regs->eflags & TRAP_FLAG)
180                 return;
181
182         /* Set TF on the kernel stack.. */
183         regs->eflags |= TRAP_FLAG;
184
185         /*
186          * ..but if TF is changed by the instruction we will trace,
187          * don't mark it as being "us" that set it, so that we
188          * won't clear it by hand later.
189          *
190          * AK: this is not enough, LAHF and IRET can change TF in user space too.
191          */
192         if (is_at_popf(child, regs))
193                 return;
194
195         child->ptrace |= PT_DTRACE;
196 }
197
198 static void clear_singlestep(struct task_struct *child)
199 {
200         /* Always clear TIF_SINGLESTEP... */
201         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
202
203         /* But touch TF only if it was set by us.. */
204         if (child->ptrace & PT_DTRACE) {
205                 struct pt_regs *regs = task_pt_regs(child);
206                 regs->eflags &= ~TRAP_FLAG;
207                 child->ptrace &= ~PT_DTRACE;
208         }
209 }
210
211 /*
212  * Called by kernel/ptrace.c when detaching..
213  *
214  * Make sure the single step bit is not set.
215  */
216 void ptrace_disable(struct task_struct *child)
217
218         clear_singlestep(child);
219 }
220
221 static int putreg(struct task_struct *child,
222         unsigned long regno, unsigned long value)
223 {
224         unsigned long tmp; 
225         
226         /* Some code in the 64bit emulation may not be 64bit clean.
227            Don't take any chances. */
228         if (test_tsk_thread_flag(child, TIF_IA32))
229                 value &= 0xffffffff;
230         switch (regno) {
231                 case offsetof(struct user_regs_struct,fs):
232                         if (value && (value & 3) != 3)
233                                 return -EIO;
234                         child->thread.fsindex = value & 0xffff; 
235                         return 0;
236                 case offsetof(struct user_regs_struct,gs):
237                         if (value && (value & 3) != 3)
238                                 return -EIO;
239                         child->thread.gsindex = value & 0xffff;
240                         return 0;
241                 case offsetof(struct user_regs_struct,ds):
242                         if (value && (value & 3) != 3)
243                                 return -EIO;
244                         child->thread.ds = value & 0xffff;
245                         return 0;
246                 case offsetof(struct user_regs_struct,es): 
247                         if (value && (value & 3) != 3)
248                                 return -EIO;
249                         child->thread.es = value & 0xffff;
250                         return 0;
251                 case offsetof(struct user_regs_struct,ss):
252                         if ((value & 3) != 3)
253                                 return -EIO;
254                         value &= 0xffff;
255                         return 0;
256                 case offsetof(struct user_regs_struct,fs_base):
257                         if (value >= TASK_SIZE_OF(child))
258                                 return -EIO;
259                         child->thread.fs = value;
260                         return 0;
261                 case offsetof(struct user_regs_struct,gs_base):
262                         if (value >= TASK_SIZE_OF(child))
263                                 return -EIO;
264                         child->thread.gs = value;
265                         return 0;
266                 case offsetof(struct user_regs_struct, eflags):
267                         value &= FLAG_MASK;
268                         tmp = get_stack_long(child, EFL_OFFSET); 
269                         tmp &= ~FLAG_MASK; 
270                         value |= tmp;
271                         break;
272                 case offsetof(struct user_regs_struct,cs): 
273                         if ((value & 3) != 3)
274                                 return -EIO;
275                         value &= 0xffff;
276                         break;
277         }
278         put_stack_long(child, regno - sizeof(struct pt_regs), value);
279         return 0;
280 }
281
282 static unsigned long getreg(struct task_struct *child, unsigned long regno)
283 {
284         unsigned long val;
285         switch (regno) {
286                 case offsetof(struct user_regs_struct, fs):
287                         return child->thread.fsindex;
288                 case offsetof(struct user_regs_struct, gs):
289                         return child->thread.gsindex;
290                 case offsetof(struct user_regs_struct, ds):
291                         return child->thread.ds;
292                 case offsetof(struct user_regs_struct, es):
293                         return child->thread.es; 
294                 case offsetof(struct user_regs_struct, fs_base):
295                         return child->thread.fs;
296                 case offsetof(struct user_regs_struct, gs_base):
297                         return child->thread.gs;
298                 default:
299                         regno = regno - sizeof(struct pt_regs);
300                         val = get_stack_long(child, regno);
301                         if (test_tsk_thread_flag(child, TIF_IA32))
302                                 val &= 0xffffffff;
303                         return val;
304         }
305
306 }
307
308 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
309 {
310         long i, ret;
311         unsigned ui;
312
313         switch (request) {
314         /* when I and D space are separate, these will need to be fixed. */
315         case PTRACE_PEEKTEXT: /* read word at location addr. */ 
316         case PTRACE_PEEKDATA: {
317                 unsigned long tmp;
318                 int copied;
319
320                 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
321                 ret = -EIO;
322                 if (copied != sizeof(tmp))
323                         break;
324                 ret = put_user(tmp,(unsigned long __user *) data);
325                 break;
326         }
327
328         /* read the word at location addr in the USER area. */
329         case PTRACE_PEEKUSR: {
330                 unsigned long tmp;
331
332                 ret = -EIO;
333                 if ((addr & 7) ||
334                     addr > sizeof(struct user) - 7)
335                         break;
336
337                 switch (addr) { 
338                 case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
339                         tmp = getreg(child, addr);
340                         break;
341                 case offsetof(struct user, u_debugreg[0]):
342                         tmp = child->thread.debugreg0;
343                         break;
344                 case offsetof(struct user, u_debugreg[1]):
345                         tmp = child->thread.debugreg1;
346                         break;
347                 case offsetof(struct user, u_debugreg[2]):
348                         tmp = child->thread.debugreg2;
349                         break;
350                 case offsetof(struct user, u_debugreg[3]):
351                         tmp = child->thread.debugreg3;
352                         break;
353                 case offsetof(struct user, u_debugreg[6]):
354                         tmp = child->thread.debugreg6;
355                         break;
356                 case offsetof(struct user, u_debugreg[7]):
357                         tmp = child->thread.debugreg7;
358                         break;
359                 default:
360                         tmp = 0;
361                         break;
362                 }
363                 ret = put_user(tmp,(unsigned long __user *) data);
364                 break;
365         }
366
367         /* when I and D space are separate, this will have to be fixed. */
368         case PTRACE_POKETEXT: /* write the word at location addr. */
369         case PTRACE_POKEDATA:
370                 ret = 0;
371                 if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
372                         break;
373                 ret = -EIO;
374                 break;
375
376         case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
377         {
378                 int dsize = test_tsk_thread_flag(child, TIF_IA32) ? 3 : 7;
379                 ret = -EIO;
380                 if ((addr & 7) ||
381                     addr > sizeof(struct user) - 7)
382                         break;
383
384                 switch (addr) { 
385                 case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
386                         ret = putreg(child, addr, data);
387                         break;
388                 /* Disallows to set a breakpoint into the vsyscall */
389                 case offsetof(struct user, u_debugreg[0]):
390                         if (data >= TASK_SIZE_OF(child) - dsize) break;
391                         child->thread.debugreg0 = data;
392                         ret = 0;
393                         break;
394                 case offsetof(struct user, u_debugreg[1]):
395                         if (data >= TASK_SIZE_OF(child) - dsize) break;
396                         child->thread.debugreg1 = data;
397                         ret = 0;
398                         break;
399                 case offsetof(struct user, u_debugreg[2]):
400                         if (data >= TASK_SIZE_OF(child) - dsize) break;
401                         child->thread.debugreg2 = data;
402                         ret = 0;
403                         break;
404                 case offsetof(struct user, u_debugreg[3]):
405                         if (data >= TASK_SIZE_OF(child) - dsize) break;
406                         child->thread.debugreg3 = data;
407                         ret = 0;
408                         break;
409                 case offsetof(struct user, u_debugreg[6]):
410                                   if (data >> 32)
411                                 break; 
412                         child->thread.debugreg6 = data;
413                         ret = 0;
414                         break;
415                 case offsetof(struct user, u_debugreg[7]):
416                         /* See arch/i386/kernel/ptrace.c for an explanation of
417                          * this awkward check.*/
418                         data &= ~DR_CONTROL_RESERVED;
419                         for(i=0; i<4; i++)
420                                 if ((0x5554 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
421                                         break;
422                         if (i == 4) {
423                                 child->thread.debugreg7 = data;
424                           ret = 0;
425                   }
426                   break;
427                 }
428                 break;
429         }
430         case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
431         case PTRACE_CONT:    /* restart after signal. */
432
433                 ret = -EIO;
434                 if (!valid_signal(data))
435                         break;
436                 if (request == PTRACE_SYSCALL)
437                         set_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
438                 else
439                         clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
440                 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
441                 child->exit_code = data;
442                 /* make sure the single step bit is not set. */
443                 clear_singlestep(child);
444                 wake_up_process(child);
445                 ret = 0;
446                 break;
447
448 #ifdef CONFIG_IA32_EMULATION
449                 /* This makes only sense with 32bit programs. Allow a
450                    64bit debugger to fully examine them too. Better
451                    don't use it against 64bit processes, use
452                    PTRACE_ARCH_PRCTL instead. */
453         case PTRACE_SET_THREAD_AREA: {
454                 struct user_desc __user *p;
455                 int old; 
456                 p = (struct user_desc __user *)data;
457                 get_user(old,  &p->entry_number); 
458                 put_user(addr, &p->entry_number);
459                 ret = do_set_thread_area(&child->thread, p);
460                 put_user(old,  &p->entry_number); 
461                 break;
462         case PTRACE_GET_THREAD_AREA:
463                 p = (struct user_desc __user *)data;
464                 get_user(old,  &p->entry_number); 
465                 put_user(addr, &p->entry_number);
466                 ret = do_get_thread_area(&child->thread, p);
467                 put_user(old,  &p->entry_number); 
468                 break;
469         } 
470 #endif
471                 /* normal 64bit interface to access TLS data. 
472                    Works just like arch_prctl, except that the arguments
473                    are reversed. */
474         case PTRACE_ARCH_PRCTL: 
475                 ret = do_arch_prctl(child, data, addr);
476                 break;
477
478 /*
479  * make the child exit.  Best I can do is send it a sigkill. 
480  * perhaps it should be put in the status that it wants to 
481  * exit.
482  */
483         case PTRACE_KILL:
484                 ret = 0;
485                 if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
486                         break;
487                 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
488                 child->exit_code = SIGKILL;
489                 /* make sure the single step bit is not set. */
490                 clear_singlestep(child);
491                 wake_up_process(child);
492                 break;
493
494         case PTRACE_SINGLESTEP:    /* set the trap flag. */
495                 ret = -EIO;
496                 if (!valid_signal(data))
497                         break;
498                 clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
499                 set_singlestep(child);
500                 child->exit_code = data;
501                 /* give it a chance to run. */
502                 wake_up_process(child);
503                 ret = 0;
504                 break;
505
506         case PTRACE_DETACH:
507                 /* detach a process that was attached. */
508                 ret = ptrace_detach(child, data);
509                 break;
510
511         case PTRACE_GETREGS: { /* Get all gp regs from the child. */
512                 if (!access_ok(VERIFY_WRITE, (unsigned __user *)data,
513                                sizeof(struct user_regs_struct))) {
514                         ret = -EIO;
515                         break;
516                 }
517                 ret = 0;
518                 for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) {
519                         ret |= __put_user(getreg(child, ui),(unsigned long __user *) data);
520                         data += sizeof(long);
521                 }
522                 break;
523         }
524
525         case PTRACE_SETREGS: { /* Set all gp regs in the child. */
526                 unsigned long tmp;
527                 if (!access_ok(VERIFY_READ, (unsigned __user *)data,
528                                sizeof(struct user_regs_struct))) {
529                         ret = -EIO;
530                         break;
531                 }
532                 ret = 0;
533                 for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) {
534                         ret |= __get_user(tmp, (unsigned long __user *) data);
535                         putreg(child, ui, tmp);
536                         data += sizeof(long);
537                 }
538                 break;
539         }
540
541         case PTRACE_GETFPREGS: { /* Get the child extended FPU state. */
542                 if (!access_ok(VERIFY_WRITE, (unsigned __user *)data,
543                                sizeof(struct user_i387_struct))) {
544                         ret = -EIO;
545                         break;
546                 }
547                 ret = get_fpregs((struct user_i387_struct __user *)data, child);
548                 break;
549         }
550
551         case PTRACE_SETFPREGS: { /* Set the child extended FPU state. */
552                 if (!access_ok(VERIFY_READ, (unsigned __user *)data,
553                                sizeof(struct user_i387_struct))) {
554                         ret = -EIO;
555                         break;
556                 }
557                 set_stopped_child_used_math(child);
558                 ret = set_fpregs(child, (struct user_i387_struct __user *)data);
559                 break;
560         }
561
562         default:
563                 ret = ptrace_request(child, request, addr, data);
564                 break;
565         }
566         return ret;
567 }
568
569 static void syscall_trace(struct pt_regs *regs)
570 {
571
572 #if 0
573         printk("trace %s rip %lx rsp %lx rax %d origrax %d caller %lx tiflags %x ptrace %x\n",
574                current->comm,
575                regs->rip, regs->rsp, regs->rax, regs->orig_rax, __builtin_return_address(0),
576                current_thread_info()->flags, current->ptrace); 
577 #endif
578
579         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
580                                 ? 0x80 : 0));
581         /*
582          * this isn't the same as continuing with a signal, but it will do
583          * for normal use.  strace only continues with a signal if the
584          * stopping signal is not SIGTRAP.  -brl
585          */
586         if (current->exit_code) {
587                 send_sig(current->exit_code, current, 1);
588                 current->exit_code = 0;
589         }
590 }
591
592 asmlinkage void syscall_trace_enter(struct pt_regs *regs)
593 {
594         /* do the secure computing check first */
595         secure_computing(regs->orig_rax);
596
597         if (test_thread_flag(TIF_SYSCALL_TRACE)
598             && (current->ptrace & PT_PTRACED))
599                 syscall_trace(regs);
600
601         if (unlikely(current->audit_context)) {
602                 if (test_thread_flag(TIF_IA32)) {
603                         audit_syscall_entry(AUDIT_ARCH_I386,
604                                             regs->orig_rax,
605                                             regs->rbx, regs->rcx,
606                                             regs->rdx, regs->rsi);
607                 } else {
608                         audit_syscall_entry(AUDIT_ARCH_X86_64,
609                                             regs->orig_rax,
610                                             regs->rdi, regs->rsi,
611                                             regs->rdx, regs->r10);
612                 }
613         }
614 }
615
616 asmlinkage void syscall_trace_leave(struct pt_regs *regs)
617 {
618         if (unlikely(current->audit_context))
619                 audit_syscall_exit(AUDITSC_RESULT(regs->rax), regs->rax);
620
621         if ((test_thread_flag(TIF_SYSCALL_TRACE)
622              || test_thread_flag(TIF_SINGLESTEP))
623             && (current->ptrace & PT_PTRACED))
624                 syscall_trace(regs);
625 }