blob: a87b6cebe80fc45e3fced915120c619215e5e87a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070021#include <linux/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
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/* determines which flags the user has access to. */
40/* 1 = access 0 = no access */
41#define FLAG_MASK 0x44dd5UL
42
43/* set's the trap flag. */
44#define TRAP_FLAG 0x100UL
45
46/*
47 * eflags and offset of eflags on child stack..
48 */
49#define EFLAGS offsetof(struct pt_regs, eflags)
50#define EFL_OFFSET ((int)(EFLAGS-sizeof(struct pt_regs)))
51
52/*
53 * this routine will get a word off of the processes privileged stack.
54 * the offset is how far from the base addr as stored in the TSS.
55 * this routine assumes that all the privileged stacks are in our
56 * data space.
57 */
58static inline unsigned long get_stack_long(struct task_struct *task, int offset)
59{
60 unsigned char *stack;
61
62 stack = (unsigned char *)task->thread.rsp0;
63 stack += offset;
64 return (*((unsigned long *)stack));
65}
66
Andi Kleenaa85b9a2005-04-16 15:24:56 -070067static inline struct pt_regs *get_child_regs(struct task_struct *task)
68{
69 struct pt_regs *regs = (void *)task->thread.rsp0;
70 return regs - 1;
71}
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/*
74 * this routine will put a word on the processes privileged stack.
75 * the offset is how far from the base addr as stored in the TSS.
76 * this routine assumes that all the privileged stacks are in our
77 * data space.
78 */
79static inline long put_stack_long(struct task_struct *task, int offset,
80 unsigned long data)
81{
82 unsigned char * stack;
83
84 stack = (unsigned char *) task->thread.rsp0;
85 stack += offset;
86 *(unsigned long *) stack = data;
87 return 0;
88}
89
Andi Kleene502cdd2005-04-16 15:24:58 -070090#define LDT_SEGMENT 4
91
92unsigned long convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs)
93{
94 unsigned long addr, seg;
95
96 addr = regs->rip;
97 seg = regs->cs & 0xffff;
98
99 /*
100 * We'll assume that the code segments in the GDT
101 * are all zero-based. That is largely true: the
102 * TLS segments are used for data, and the PNPBIOS
103 * and APM bios ones we just ignore here.
104 */
105 if (seg & LDT_SEGMENT) {
106 u32 *desc;
107 unsigned long base;
108
109 down(&child->mm->context.sem);
110 desc = child->mm->context.ldt + (seg & ~7);
111 base = (desc[0] >> 16) | ((desc[1] & 0xff) << 16) | (desc[1] & 0xff000000);
112
113 /* 16-bit code segment? */
114 if (!((desc[1] >> 22) & 1))
115 addr &= 0xffff;
116 addr += base;
117 up(&child->mm->context.sem);
118 }
119 return addr;
120}
121
122static int is_at_popf(struct task_struct *child, struct pt_regs *regs)
123{
124 int i, copied;
125 unsigned char opcode[16];
126 unsigned long addr = convert_rip_to_linear(child, regs);
127
128 copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
129 for (i = 0; i < copied; i++) {
130 switch (opcode[i]) {
131 /* popf */
132 case 0x9d:
133 return 1;
134
135 /* CHECKME: 64 65 */
136
137 /* opcode and address size prefixes */
138 case 0x66: case 0x67:
139 continue;
140 /* irrelevant prefixes (segment overrides and repeats) */
141 case 0x26: case 0x2e:
142 case 0x36: case 0x3e:
143 case 0x64: case 0x65:
144 case 0xf0: case 0xf2: case 0xf3:
145 continue;
146
147 /* REX prefixes */
148 case 0x40 ... 0x4f:
149 continue;
150
151 /* CHECKME: f0, f2, f3 */
152
153 /*
154 * pushf: NOTE! We should probably not let
155 * the user see the TF bit being set. But
156 * it's more pain than it's worth to avoid
157 * it, and a debugger could emulate this
158 * all in user space if it _really_ cares.
159 */
160 case 0x9c:
161 default:
162 return 0;
163 }
164 }
165 return 0;
166}
167
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700168static void set_singlestep(struct task_struct *child)
169{
170 struct pt_regs *regs = get_child_regs(child);
171
172 /*
173 * Always set TIF_SINGLESTEP - this guarantees that
174 * we single-step system calls etc.. This will also
175 * cause us to set TF when returning to user mode.
176 */
177 set_tsk_thread_flag(child, TIF_SINGLESTEP);
178
179 /*
180 * If TF was already set, don't do anything else
181 */
182 if (regs->eflags & TRAP_FLAG)
183 return;
184
185 /* Set TF on the kernel stack.. */
186 regs->eflags |= TRAP_FLAG;
187
Andi Kleene502cdd2005-04-16 15:24:58 -0700188 /*
189 * ..but if TF is changed by the instruction we will trace,
190 * don't mark it as being "us" that set it, so that we
191 * won't clear it by hand later.
192 *
193 * AK: this is not enough, LAHF and IRET can change TF in user space too.
194 */
195 if (is_at_popf(child, regs))
196 return;
197
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700198 child->ptrace |= PT_DTRACE;
199}
200
201static void clear_singlestep(struct task_struct *child)
202{
203 /* Always clear TIF_SINGLESTEP... */
204 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
205
206 /* But touch TF only if it was set by us.. */
207 if (child->ptrace & PT_DTRACE) {
208 struct pt_regs *regs = get_child_regs(child);
209 regs->eflags &= ~TRAP_FLAG;
210 child->ptrace &= ~PT_DTRACE;
211 }
212}
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214/*
215 * Called by kernel/ptrace.c when detaching..
216 *
217 * Make sure the single step bit is not set.
218 */
219void ptrace_disable(struct task_struct *child)
220{
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700221 clear_singlestep(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
223
224static int putreg(struct task_struct *child,
225 unsigned long regno, unsigned long value)
226{
227 unsigned long tmp;
228
229 /* Some code in the 64bit emulation may not be 64bit clean.
230 Don't take any chances. */
231 if (test_tsk_thread_flag(child, TIF_IA32))
232 value &= 0xffffffff;
233 switch (regno) {
234 case offsetof(struct user_regs_struct,fs):
235 if (value && (value & 3) != 3)
236 return -EIO;
237 child->thread.fsindex = value & 0xffff;
238 return 0;
239 case offsetof(struct user_regs_struct,gs):
240 if (value && (value & 3) != 3)
241 return -EIO;
242 child->thread.gsindex = value & 0xffff;
243 return 0;
244 case offsetof(struct user_regs_struct,ds):
245 if (value && (value & 3) != 3)
246 return -EIO;
247 child->thread.ds = value & 0xffff;
248 return 0;
249 case offsetof(struct user_regs_struct,es):
250 if (value && (value & 3) != 3)
251 return -EIO;
252 child->thread.es = value & 0xffff;
253 return 0;
254 case offsetof(struct user_regs_struct,ss):
255 if ((value & 3) != 3)
256 return -EIO;
257 value &= 0xffff;
258 return 0;
259 case offsetof(struct user_regs_struct,fs_base):
Suresh Siddha84929802005-06-21 17:14:32 -0700260 if (value >= TASK_SIZE_OF(child))
Andi Kleenf6b8d472005-05-16 21:53:30 -0700261 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 child->thread.fs = value;
263 return 0;
264 case offsetof(struct user_regs_struct,gs_base):
Suresh Siddha84929802005-06-21 17:14:32 -0700265 if (value >= TASK_SIZE_OF(child))
Andi Kleenf6b8d472005-05-16 21:53:30 -0700266 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 child->thread.gs = value;
268 return 0;
269 case offsetof(struct user_regs_struct, eflags):
270 value &= FLAG_MASK;
271 tmp = get_stack_long(child, EFL_OFFSET);
272 tmp &= ~FLAG_MASK;
273 value |= tmp;
274 break;
275 case offsetof(struct user_regs_struct,cs):
276 if ((value & 3) != 3)
277 return -EIO;
278 value &= 0xffff;
279 break;
Andi Kleend1099e82005-05-16 21:53:29 -0700280 case offsetof(struct user_regs_struct, rip):
281 /* Check if the new RIP address is canonical */
Suresh Siddha84929802005-06-21 17:14:32 -0700282 if (value >= TASK_SIZE_OF(child))
Andi Kleend1099e82005-05-16 21:53:29 -0700283 return -EIO;
284 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
286 put_stack_long(child, regno - sizeof(struct pt_regs), value);
287 return 0;
288}
289
290static unsigned long getreg(struct task_struct *child, unsigned long regno)
291{
292 unsigned long val;
293 switch (regno) {
294 case offsetof(struct user_regs_struct, fs):
295 return child->thread.fsindex;
296 case offsetof(struct user_regs_struct, gs):
297 return child->thread.gsindex;
298 case offsetof(struct user_regs_struct, ds):
299 return child->thread.ds;
300 case offsetof(struct user_regs_struct, es):
301 return child->thread.es;
302 case offsetof(struct user_regs_struct, fs_base):
303 return child->thread.fs;
304 case offsetof(struct user_regs_struct, gs_base):
305 return child->thread.gs;
306 default:
307 regno = regno - sizeof(struct pt_regs);
308 val = get_stack_long(child, regno);
309 if (test_tsk_thread_flag(child, TIF_IA32))
310 val &= 0xffffffff;
311 return val;
312 }
313
314}
315
Christoph Hellwig481bed42005-11-07 00:59:47 -0800316long arch_ptrace(struct task_struct *child, long request, long addr, long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 long i, ret;
319 unsigned ui;
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 switch (request) {
322 /* when I and D space are separate, these will need to be fixed. */
323 case PTRACE_PEEKTEXT: /* read word at location addr. */
324 case PTRACE_PEEKDATA: {
325 unsigned long tmp;
326 int copied;
327
328 copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
329 ret = -EIO;
330 if (copied != sizeof(tmp))
331 break;
332 ret = put_user(tmp,(unsigned long __user *) data);
333 break;
334 }
335
336 /* read the word at location addr in the USER area. */
337 case PTRACE_PEEKUSR: {
338 unsigned long tmp;
339
340 ret = -EIO;
341 if ((addr & 7) ||
342 addr > sizeof(struct user) - 7)
343 break;
344
345 switch (addr) {
Andi Kleenc4d1fcf2005-05-20 14:27:56 -0700346 case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 tmp = getreg(child, addr);
348 break;
349 case offsetof(struct user, u_debugreg[0]):
350 tmp = child->thread.debugreg0;
351 break;
352 case offsetof(struct user, u_debugreg[1]):
353 tmp = child->thread.debugreg1;
354 break;
355 case offsetof(struct user, u_debugreg[2]):
356 tmp = child->thread.debugreg2;
357 break;
358 case offsetof(struct user, u_debugreg[3]):
359 tmp = child->thread.debugreg3;
360 break;
361 case offsetof(struct user, u_debugreg[6]):
362 tmp = child->thread.debugreg6;
363 break;
364 case offsetof(struct user, u_debugreg[7]):
365 tmp = child->thread.debugreg7;
366 break;
367 default:
368 tmp = 0;
369 break;
370 }
371 ret = put_user(tmp,(unsigned long __user *) data);
372 break;
373 }
374
375 /* when I and D space are separate, this will have to be fixed. */
376 case PTRACE_POKETEXT: /* write the word at location addr. */
377 case PTRACE_POKEDATA:
378 ret = 0;
379 if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
380 break;
381 ret = -EIO;
382 break;
383
384 case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
Suresh Siddha84929802005-06-21 17:14:32 -0700385 {
386 int dsize = test_tsk_thread_flag(child, TIF_IA32) ? 3 : 7;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 ret = -EIO;
388 if ((addr & 7) ||
389 addr > sizeof(struct user) - 7)
390 break;
391
392 switch (addr) {
Andi Kleenc4d1fcf2005-05-20 14:27:56 -0700393 case 0 ... sizeof(struct user_regs_struct) - sizeof(long):
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 ret = putreg(child, addr, data);
395 break;
396 /* Disallows to set a breakpoint into the vsyscall */
397 case offsetof(struct user, u_debugreg[0]):
Suresh Siddha84929802005-06-21 17:14:32 -0700398 if (data >= TASK_SIZE_OF(child) - dsize) break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 child->thread.debugreg0 = data;
400 ret = 0;
401 break;
402 case offsetof(struct user, u_debugreg[1]):
Suresh Siddha84929802005-06-21 17:14:32 -0700403 if (data >= TASK_SIZE_OF(child) - dsize) break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 child->thread.debugreg1 = data;
405 ret = 0;
406 break;
407 case offsetof(struct user, u_debugreg[2]):
Suresh Siddha84929802005-06-21 17:14:32 -0700408 if (data >= TASK_SIZE_OF(child) - dsize) break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 child->thread.debugreg2 = data;
410 ret = 0;
411 break;
412 case offsetof(struct user, u_debugreg[3]):
Suresh Siddha84929802005-06-21 17:14:32 -0700413 if (data >= TASK_SIZE_OF(child) - dsize) break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 child->thread.debugreg3 = data;
415 ret = 0;
416 break;
417 case offsetof(struct user, u_debugreg[6]):
418 if (data >> 32)
419 break;
420 child->thread.debugreg6 = data;
421 ret = 0;
422 break;
423 case offsetof(struct user, u_debugreg[7]):
424 /* See arch/i386/kernel/ptrace.c for an explanation of
425 * this awkward check.*/
426 data &= ~DR_CONTROL_RESERVED;
427 for(i=0; i<4; i++)
428 if ((0x5454 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
429 break;
430 if (i == 4) {
431 child->thread.debugreg7 = data;
432 ret = 0;
433 }
434 break;
435 }
436 break;
Suresh Siddha84929802005-06-21 17:14:32 -0700437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700439 case PTRACE_CONT: /* restart after signal. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
441 ret = -EIO;
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700442 if (!valid_signal(data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 break;
444 if (request == PTRACE_SYSCALL)
445 set_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
446 else
447 clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
448 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
449 child->exit_code = data;
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700450 /* make sure the single step bit is not set. */
451 clear_singlestep(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 wake_up_process(child);
453 ret = 0;
454 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456#ifdef CONFIG_IA32_EMULATION
457 /* This makes only sense with 32bit programs. Allow a
458 64bit debugger to fully examine them too. Better
459 don't use it against 64bit processes, use
460 PTRACE_ARCH_PRCTL instead. */
461 case PTRACE_SET_THREAD_AREA: {
462 struct user_desc __user *p;
463 int old;
464 p = (struct user_desc __user *)data;
465 get_user(old, &p->entry_number);
466 put_user(addr, &p->entry_number);
467 ret = do_set_thread_area(&child->thread, p);
468 put_user(old, &p->entry_number);
469 break;
470 case PTRACE_GET_THREAD_AREA:
471 p = (struct user_desc __user *)data;
472 get_user(old, &p->entry_number);
473 put_user(addr, &p->entry_number);
474 ret = do_get_thread_area(&child->thread, p);
475 put_user(old, &p->entry_number);
476 break;
477 }
478#endif
479 /* normal 64bit interface to access TLS data.
480 Works just like arch_prctl, except that the arguments
481 are reversed. */
482 case PTRACE_ARCH_PRCTL:
483 ret = do_arch_prctl(child, data, addr);
484 break;
485
486/*
487 * make the child exit. Best I can do is send it a sigkill.
488 * perhaps it should be put in the status that it wants to
489 * exit.
490 */
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700491 case PTRACE_KILL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 ret = 0;
493 if (child->exit_state == EXIT_ZOMBIE) /* already dead */
494 break;
495 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
496 child->exit_code = SIGKILL;
497 /* make sure the single step bit is not set. */
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700498 clear_singlestep(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 wake_up_process(child);
500 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700502 case PTRACE_SINGLESTEP: /* set the trap flag. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 ret = -EIO;
Jesper Juhl7ed20e12005-05-01 08:59:14 -0700504 if (!valid_signal(data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 break;
506 clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE);
Andi Kleenaa85b9a2005-04-16 15:24:56 -0700507 set_singlestep(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 child->exit_code = data;
509 /* give it a chance to run. */
510 wake_up_process(child);
511 ret = 0;
512 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 case PTRACE_DETACH:
515 /* detach a process that was attached. */
516 ret = ptrace_detach(child, data);
517 break;
518
519 case PTRACE_GETREGS: { /* Get all gp regs from the child. */
520 if (!access_ok(VERIFY_WRITE, (unsigned __user *)data,
521 sizeof(struct user_regs_struct))) {
522 ret = -EIO;
523 break;
524 }
525 ret = 0;
526 for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) {
527 ret |= __put_user(getreg(child, ui),(unsigned long __user *) data);
528 data += sizeof(long);
529 }
530 break;
531 }
532
533 case PTRACE_SETREGS: { /* Set all gp regs in the child. */
534 unsigned long tmp;
535 if (!access_ok(VERIFY_READ, (unsigned __user *)data,
536 sizeof(struct user_regs_struct))) {
537 ret = -EIO;
538 break;
539 }
540 ret = 0;
541 for (ui = 0; ui < sizeof(struct user_regs_struct); ui += sizeof(long)) {
542 ret |= __get_user(tmp, (unsigned long __user *) data);
543 putreg(child, ui, tmp);
544 data += sizeof(long);
545 }
546 break;
547 }
548
549 case PTRACE_GETFPREGS: { /* Get the child extended FPU state. */
550 if (!access_ok(VERIFY_WRITE, (unsigned __user *)data,
551 sizeof(struct user_i387_struct))) {
552 ret = -EIO;
553 break;
554 }
555 ret = get_fpregs((struct user_i387_struct __user *)data, child);
556 break;
557 }
558
559 case PTRACE_SETFPREGS: { /* Set the child extended FPU state. */
560 if (!access_ok(VERIFY_READ, (unsigned __user *)data,
561 sizeof(struct user_i387_struct))) {
562 ret = -EIO;
563 break;
564 }
565 set_stopped_child_used_math(child);
566 ret = set_fpregs(child, (struct user_i387_struct __user *)data);
567 break;
568 }
569
570 default:
571 ret = ptrace_request(child, request, addr, data);
572 break;
573 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return ret;
575}
576
577static void syscall_trace(struct pt_regs *regs)
578{
579
580#if 0
581 printk("trace %s rip %lx rsp %lx rax %d origrax %d caller %lx tiflags %x ptrace %x\n",
582 current->comm,
583 regs->rip, regs->rsp, regs->rax, regs->orig_rax, __builtin_return_address(0),
584 current_thread_info()->flags, current->ptrace);
585#endif
586
587 ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
588 ? 0x80 : 0));
589 /*
590 * this isn't the same as continuing with a signal, but it will do
591 * for normal use. strace only continues with a signal if the
592 * stopping signal is not SIGTRAP. -brl
593 */
594 if (current->exit_code) {
595 send_sig(current->exit_code, current, 1);
596 current->exit_code = 0;
597 }
598}
599
600asmlinkage void syscall_trace_enter(struct pt_regs *regs)
601{
602 /* do the secure computing check first */
603 secure_computing(regs->orig_rax);
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if (test_thread_flag(TIF_SYSCALL_TRACE)
606 && (current->ptrace & PT_PTRACED))
607 syscall_trace(regs);
2fd6f582005-04-29 16:08:28 +0100608
David Woodhouse488f2ea2005-05-03 14:11:02 +0100609 if (unlikely(current->audit_context)) {
610 if (test_thread_flag(TIF_IA32)) {
611 audit_syscall_entry(current, AUDIT_ARCH_I386,
612 regs->orig_rax,
613 regs->rbx, regs->rcx,
614 regs->rdx, regs->rsi);
615 } else {
616 audit_syscall_entry(current, AUDIT_ARCH_X86_64,
617 regs->orig_rax,
618 regs->rdi, regs->rsi,
619 regs->rdx, regs->r10);
620 }
621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
623
624asmlinkage void syscall_trace_leave(struct pt_regs *regs)
625{
626 if (unlikely(current->audit_context))
2fd6f582005-04-29 16:08:28 +0100627 audit_syscall_exit(current, AUDITSC_RESULT(regs->rax), regs->rax);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 if ((test_thread_flag(TIF_SYSCALL_TRACE)
630 || test_thread_flag(TIF_SINGLESTEP))
631 && (current->ptrace & PT_PTRACED))
632 syscall_trace(regs);
633}