2 * arch/s390/kernel/ptrace.c
5 * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 * Based on PowerPC version
10 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
12 * Derived from "arch/m68k/kernel/ptrace.c"
13 * Copyright (C) 1994 by Hamish Macdonald
14 * Taken from linux/kernel/ptrace.c and modified for M680x0.
15 * linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
17 * Modified by Cort Dougan (cort@cs.nmt.edu)
20 * This file is subject to the terms and conditions of the GNU General
21 * Public License. See the file README.legal in the main directory of
22 * this archive for more details.
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
28 #include <linux/smp.h>
29 #include <linux/smp_lock.h>
30 #include <linux/errno.h>
31 #include <linux/ptrace.h>
32 #include <linux/user.h>
33 #include <linux/security.h>
34 #include <linux/audit.h>
35 #include <linux/signal.h>
37 #include <asm/segment.h>
39 #include <asm/pgtable.h>
40 #include <asm/pgalloc.h>
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
43 #include <asm/unistd.h>
46 #include "compat_ptrace.h"
50 FixPerRegisters(struct task_struct
*task
)
55 regs
= task_pt_regs(task
);
56 per_info
= (per_struct
*) &task
->thread
.per_info
;
57 per_info
->control_regs
.bits
.em_instruction_fetch
=
58 per_info
->single_step
| per_info
->instruction_fetch
;
60 if (per_info
->single_step
) {
61 per_info
->control_regs
.bits
.starting_addr
= 0;
63 if (test_thread_flag(TIF_31BIT
))
64 per_info
->control_regs
.bits
.ending_addr
= 0x7fffffffUL
;
67 per_info
->control_regs
.bits
.ending_addr
= PSW_ADDR_INSN
;
69 per_info
->control_regs
.bits
.starting_addr
=
70 per_info
->starting_addr
;
71 per_info
->control_regs
.bits
.ending_addr
=
72 per_info
->ending_addr
;
75 * if any of the control reg tracing bits are on
76 * we switch on per in the psw
78 if (per_info
->control_regs
.words
.cr
[0] & PER_EM_MASK
)
79 regs
->psw
.mask
|= PSW_MASK_PER
;
81 regs
->psw
.mask
&= ~PSW_MASK_PER
;
83 if (per_info
->control_regs
.bits
.em_storage_alteration
)
84 per_info
->control_regs
.bits
.storage_alt_space_ctl
= 1;
86 per_info
->control_regs
.bits
.storage_alt_space_ctl
= 0;
89 static void set_single_step(struct task_struct
*task
)
91 task
->thread
.per_info
.single_step
= 1;
92 FixPerRegisters(task
);
95 static void clear_single_step(struct task_struct
*task
)
97 task
->thread
.per_info
.single_step
= 0;
98 FixPerRegisters(task
);
102 * Called by kernel/ptrace.c when detaching..
104 * Make sure single step bits etc are not set.
107 ptrace_disable(struct task_struct
*child
)
109 /* make sure the single step bit is not set. */
110 clear_single_step(child
);
114 # define __ADDR_MASK 3
116 # define __ADDR_MASK 7
120 * Read the word at offset addr from the user area of a process. The
121 * trouble here is that the information is littered over different
122 * locations. The process registers are found on the kernel stack,
123 * the floating point stuff and the trace settings are stored in
124 * the task structure. In addition the different structures in
125 * struct user contain pad bytes that should be read as zeroes.
129 peek_user(struct task_struct
*child
, addr_t addr
, addr_t data
)
131 struct user
*dummy
= NULL
;
132 addr_t offset
, tmp
, mask
;
135 * Stupid gdb peeks/pokes the access registers in 64 bit with
136 * an alignment of 4. Programmers from hell...
140 if (addr
>= (addr_t
) &dummy
->regs
.acrs
&&
141 addr
< (addr_t
) &dummy
->regs
.orig_gpr2
)
144 if ((addr
& mask
) || addr
> sizeof(struct user
) - __ADDR_MASK
)
147 if (addr
< (addr_t
) &dummy
->regs
.acrs
) {
149 * psw and gprs are stored on the stack
151 tmp
= *(addr_t
*)((addr_t
) &task_pt_regs(child
)->psw
+ addr
);
152 if (addr
== (addr_t
) &dummy
->regs
.psw
.mask
)
153 /* Remove per bit from user psw. */
154 tmp
&= ~PSW_MASK_PER
;
156 } else if (addr
< (addr_t
) &dummy
->regs
.orig_gpr2
) {
158 * access registers are stored in the thread structure
160 offset
= addr
- (addr_t
) &dummy
->regs
.acrs
;
163 * Very special case: old & broken 64 bit gdb reading
164 * from acrs[15]. Result is a 64 bit value. Read the
165 * 32 bit acrs[15] value and shift it by 32. Sick...
167 if (addr
== (addr_t
) &dummy
->regs
.acrs
[15])
168 tmp
= ((unsigned long) child
->thread
.acrs
[15]) << 32;
171 tmp
= *(addr_t
*)((addr_t
) &child
->thread
.acrs
+ offset
);
173 } else if (addr
== (addr_t
) &dummy
->regs
.orig_gpr2
) {
175 * orig_gpr2 is stored on the kernel stack
177 tmp
= (addr_t
) task_pt_regs(child
)->orig_gpr2
;
179 } else if (addr
< (addr_t
) (&dummy
->regs
.fp_regs
+ 1)) {
181 * floating point regs. are stored in the thread structure
183 offset
= addr
- (addr_t
) &dummy
->regs
.fp_regs
;
184 tmp
= *(addr_t
*)((addr_t
) &child
->thread
.fp_regs
+ offset
);
185 if (addr
== (addr_t
) &dummy
->regs
.fp_regs
.fpc
)
186 tmp
&= (unsigned long) FPC_VALID_MASK
187 << (BITS_PER_LONG
- 32);
189 } else if (addr
< (addr_t
) (&dummy
->regs
.per_info
+ 1)) {
191 * per_info is found in the thread structure
193 offset
= addr
- (addr_t
) &dummy
->regs
.per_info
;
194 tmp
= *(addr_t
*)((addr_t
) &child
->thread
.per_info
+ offset
);
199 return put_user(tmp
, (addr_t __user
*) data
);
203 * Write a word to the user area of a process at location addr. This
204 * operation does have an additional problem compared to peek_user.
205 * Stores to the program status word and on the floating point
206 * control register needs to get checked for validity.
209 poke_user(struct task_struct
*child
, addr_t addr
, addr_t data
)
211 struct user
*dummy
= NULL
;
215 * Stupid gdb peeks/pokes the access registers in 64 bit with
216 * an alignment of 4. Programmers from hell indeed...
220 if (addr
>= (addr_t
) &dummy
->regs
.acrs
&&
221 addr
< (addr_t
) &dummy
->regs
.orig_gpr2
)
224 if ((addr
& mask
) || addr
> sizeof(struct user
) - __ADDR_MASK
)
227 if (addr
< (addr_t
) &dummy
->regs
.acrs
) {
229 * psw and gprs are stored on the stack
231 if (addr
== (addr_t
) &dummy
->regs
.psw
.mask
&&
233 data
!= PSW_MASK_MERGE(psw_user32_bits
, data
) &&
235 data
!= PSW_MASK_MERGE(psw_user_bits
, data
))
236 /* Invalid psw mask. */
239 if (addr
== (addr_t
) &dummy
->regs
.psw
.addr
)
240 /* I'd like to reject addresses without the
241 high order bit but older gdb's rely on it */
242 data
|= PSW_ADDR_AMODE
;
244 *(addr_t
*)((addr_t
) &task_pt_regs(child
)->psw
+ addr
) = data
;
246 } else if (addr
< (addr_t
) (&dummy
->regs
.orig_gpr2
)) {
248 * access registers are stored in the thread structure
250 offset
= addr
- (addr_t
) &dummy
->regs
.acrs
;
253 * Very special case: old & broken 64 bit gdb writing
254 * to acrs[15] with a 64 bit value. Ignore the lower
255 * half of the value and write the upper 32 bit to
258 if (addr
== (addr_t
) &dummy
->regs
.acrs
[15])
259 child
->thread
.acrs
[15] = (unsigned int) (data
>> 32);
262 *(addr_t
*)((addr_t
) &child
->thread
.acrs
+ offset
) = data
;
264 } else if (addr
== (addr_t
) &dummy
->regs
.orig_gpr2
) {
266 * orig_gpr2 is stored on the kernel stack
268 task_pt_regs(child
)->orig_gpr2
= data
;
270 } else if (addr
< (addr_t
) (&dummy
->regs
.fp_regs
+ 1)) {
272 * floating point regs. are stored in the thread structure
274 if (addr
== (addr_t
) &dummy
->regs
.fp_regs
.fpc
&&
275 (data
& ~((unsigned long) FPC_VALID_MASK
276 << (BITS_PER_LONG
- 32))) != 0)
278 offset
= addr
- (addr_t
) &dummy
->regs
.fp_regs
;
279 *(addr_t
*)((addr_t
) &child
->thread
.fp_regs
+ offset
) = data
;
281 } else if (addr
< (addr_t
) (&dummy
->regs
.per_info
+ 1)) {
283 * per_info is found in the thread structure
285 offset
= addr
- (addr_t
) &dummy
->regs
.per_info
;
286 *(addr_t
*)((addr_t
) &child
->thread
.per_info
+ offset
) = data
;
290 FixPerRegisters(child
);
295 do_ptrace_normal(struct task_struct
*child
, long request
, long addr
, long data
)
301 case PTRACE_PEEKTEXT
:
302 case PTRACE_PEEKDATA
:
303 /* Remove high order bit from address (only for 31 bit). */
304 addr
&= PSW_ADDR_INSN
;
305 /* read word at location addr. */
306 return generic_ptrace_peekdata(child
, addr
, data
);
309 /* read the word at location addr in the USER area. */
310 return peek_user(child
, addr
, data
);
312 case PTRACE_POKETEXT
:
313 case PTRACE_POKEDATA
:
314 /* Remove high order bit from address (only for 31 bit). */
315 addr
&= PSW_ADDR_INSN
;
316 /* write the word at location addr. */
317 copied
= access_process_vm(child
, addr
, &data
, sizeof(data
),1);
318 if (copied
!= sizeof(data
))
323 /* write the word at location addr in the USER area */
324 return poke_user(child
, addr
, data
);
326 case PTRACE_PEEKUSR_AREA
:
327 case PTRACE_POKEUSR_AREA
:
328 if (copy_from_user(&parea
, (void __force __user
*) addr
,
331 addr
= parea
.kernel_addr
;
332 data
= parea
.process_addr
;
334 while (copied
< parea
.len
) {
335 if (request
== PTRACE_PEEKUSR_AREA
)
336 ret
= peek_user(child
, addr
, data
);
340 (addr_t __force __user
*) data
))
342 ret
= poke_user(child
, addr
, utmp
);
346 addr
+= sizeof(unsigned long);
347 data
+= sizeof(unsigned long);
348 copied
+= sizeof(unsigned long);
352 return ptrace_request(child
, request
, addr
, data
);
357 * Now the fun part starts... a 31 bit program running in the
358 * 31 bit emulation tracing another program. PTRACE_PEEKTEXT,
359 * PTRACE_PEEKDATA, PTRACE_POKETEXT and PTRACE_POKEDATA are easy
360 * to handle, the difference to the 64 bit versions of the requests
361 * is that the access is done in multiples of 4 byte instead of
362 * 8 bytes (sizeof(unsigned long) on 31/64 bit).
363 * The ugly part are PTRACE_PEEKUSR, PTRACE_PEEKUSR_AREA,
364 * PTRACE_POKEUSR and PTRACE_POKEUSR_AREA. If the traced program
365 * is a 31 bit program too, the content of struct user can be
366 * emulated. A 31 bit program peeking into the struct user of
367 * a 64 bit program is a no-no.
371 * Same as peek_user but for a 31 bit program.
374 peek_user_emu31(struct task_struct
*child
, addr_t addr
, addr_t data
)
376 struct user32
*dummy32
= NULL
;
377 per_struct32
*dummy_per32
= NULL
;
381 if (!test_thread_flag(TIF_31BIT
) ||
382 (addr
& 3) || addr
> sizeof(struct user
) - 3)
385 if (addr
< (addr_t
) &dummy32
->regs
.acrs
) {
387 * psw and gprs are stored on the stack
389 if (addr
== (addr_t
) &dummy32
->regs
.psw
.mask
) {
390 /* Fake a 31 bit psw mask. */
391 tmp
= (__u32
)(task_pt_regs(child
)->psw
.mask
>> 32);
392 tmp
= PSW32_MASK_MERGE(psw32_user_bits
, tmp
);
393 } else if (addr
== (addr_t
) &dummy32
->regs
.psw
.addr
) {
394 /* Fake a 31 bit psw address. */
395 tmp
= (__u32
) task_pt_regs(child
)->psw
.addr
|
399 tmp
= *(__u32
*)((addr_t
) &task_pt_regs(child
)->psw
+
402 } else if (addr
< (addr_t
) (&dummy32
->regs
.orig_gpr2
)) {
404 * access registers are stored in the thread structure
406 offset
= addr
- (addr_t
) &dummy32
->regs
.acrs
;
407 tmp
= *(__u32
*)((addr_t
) &child
->thread
.acrs
+ offset
);
409 } else if (addr
== (addr_t
) (&dummy32
->regs
.orig_gpr2
)) {
411 * orig_gpr2 is stored on the kernel stack
413 tmp
= *(__u32
*)((addr_t
) &task_pt_regs(child
)->orig_gpr2
+ 4);
415 } else if (addr
< (addr_t
) (&dummy32
->regs
.fp_regs
+ 1)) {
417 * floating point regs. are stored in the thread structure
419 offset
= addr
- (addr_t
) &dummy32
->regs
.fp_regs
;
420 tmp
= *(__u32
*)((addr_t
) &child
->thread
.fp_regs
+ offset
);
422 } else if (addr
< (addr_t
) (&dummy32
->regs
.per_info
+ 1)) {
424 * per_info is found in the thread structure
426 offset
= addr
- (addr_t
) &dummy32
->regs
.per_info
;
427 /* This is magic. See per_struct and per_struct32. */
428 if ((offset
>= (addr_t
) &dummy_per32
->control_regs
&&
429 offset
< (addr_t
) (&dummy_per32
->control_regs
+ 1)) ||
430 (offset
>= (addr_t
) &dummy_per32
->starting_addr
&&
431 offset
<= (addr_t
) &dummy_per32
->ending_addr
) ||
432 offset
== (addr_t
) &dummy_per32
->lowcore
.words
.address
)
433 offset
= offset
*2 + 4;
436 tmp
= *(__u32
*)((addr_t
) &child
->thread
.per_info
+ offset
);
441 return put_user(tmp
, (__u32 __user
*) data
);
445 * Same as poke_user but for a 31 bit program.
448 poke_user_emu31(struct task_struct
*child
, addr_t addr
, addr_t data
)
450 struct user32
*dummy32
= NULL
;
451 per_struct32
*dummy_per32
= NULL
;
455 if (!test_thread_flag(TIF_31BIT
) ||
456 (addr
& 3) || addr
> sizeof(struct user32
) - 3)
461 if (addr
< (addr_t
) &dummy32
->regs
.acrs
) {
463 * psw, gprs, acrs and orig_gpr2 are stored on the stack
465 if (addr
== (addr_t
) &dummy32
->regs
.psw
.mask
) {
466 /* Build a 64 bit psw mask from 31 bit mask. */
467 if (tmp
!= PSW32_MASK_MERGE(psw32_user_bits
, tmp
))
468 /* Invalid psw mask. */
470 task_pt_regs(child
)->psw
.mask
=
471 PSW_MASK_MERGE(psw_user32_bits
, (__u64
) tmp
<< 32);
472 } else if (addr
== (addr_t
) &dummy32
->regs
.psw
.addr
) {
473 /* Build a 64 bit psw address from 31 bit address. */
474 task_pt_regs(child
)->psw
.addr
=
475 (__u64
) tmp
& PSW32_ADDR_INSN
;
478 *(__u32
*)((addr_t
) &task_pt_regs(child
)->psw
481 } else if (addr
< (addr_t
) (&dummy32
->regs
.orig_gpr2
)) {
483 * access registers are stored in the thread structure
485 offset
= addr
- (addr_t
) &dummy32
->regs
.acrs
;
486 *(__u32
*)((addr_t
) &child
->thread
.acrs
+ offset
) = tmp
;
488 } else if (addr
== (addr_t
) (&dummy32
->regs
.orig_gpr2
)) {
490 * orig_gpr2 is stored on the kernel stack
492 *(__u32
*)((addr_t
) &task_pt_regs(child
)->orig_gpr2
+ 4) = tmp
;
494 } else if (addr
< (addr_t
) (&dummy32
->regs
.fp_regs
+ 1)) {
496 * floating point regs. are stored in the thread structure
498 if (addr
== (addr_t
) &dummy32
->regs
.fp_regs
.fpc
&&
499 (tmp
& ~FPC_VALID_MASK
) != 0)
500 /* Invalid floating point control. */
502 offset
= addr
- (addr_t
) &dummy32
->regs
.fp_regs
;
503 *(__u32
*)((addr_t
) &child
->thread
.fp_regs
+ offset
) = tmp
;
505 } else if (addr
< (addr_t
) (&dummy32
->regs
.per_info
+ 1)) {
507 * per_info is found in the thread structure.
509 offset
= addr
- (addr_t
) &dummy32
->regs
.per_info
;
511 * This is magic. See per_struct and per_struct32.
512 * By incident the offsets in per_struct are exactly
513 * twice the offsets in per_struct32 for all fields.
514 * The 8 byte fields need special handling though,
515 * because the second half (bytes 4-7) is needed and
516 * not the first half.
518 if ((offset
>= (addr_t
) &dummy_per32
->control_regs
&&
519 offset
< (addr_t
) (&dummy_per32
->control_regs
+ 1)) ||
520 (offset
>= (addr_t
) &dummy_per32
->starting_addr
&&
521 offset
<= (addr_t
) &dummy_per32
->ending_addr
) ||
522 offset
== (addr_t
) &dummy_per32
->lowcore
.words
.address
)
523 offset
= offset
*2 + 4;
526 *(__u32
*)((addr_t
) &child
->thread
.per_info
+ offset
) = tmp
;
530 FixPerRegisters(child
);
535 do_ptrace_emu31(struct task_struct
*child
, long request
, long addr
, long data
)
537 unsigned int tmp
; /* 4 bytes !! */
538 ptrace_area_emu31 parea
;
542 case PTRACE_PEEKTEXT
:
543 case PTRACE_PEEKDATA
:
544 /* read word at location addr. */
545 copied
= access_process_vm(child
, addr
, &tmp
, sizeof(tmp
), 0);
546 if (copied
!= sizeof(tmp
))
548 return put_user(tmp
, (unsigned int __force __user
*) data
);
551 /* read the word at location addr in the USER area. */
552 return peek_user_emu31(child
, addr
, data
);
554 case PTRACE_POKETEXT
:
555 case PTRACE_POKEDATA
:
556 /* write the word at location addr. */
558 copied
= access_process_vm(child
, addr
, &tmp
, sizeof(tmp
), 1);
559 if (copied
!= sizeof(tmp
))
564 /* write the word at location addr in the USER area */
565 return poke_user_emu31(child
, addr
, data
);
567 case PTRACE_PEEKUSR_AREA
:
568 case PTRACE_POKEUSR_AREA
:
569 if (copy_from_user(&parea
, (void __force __user
*) addr
,
572 addr
= parea
.kernel_addr
;
573 data
= parea
.process_addr
;
575 while (copied
< parea
.len
) {
576 if (request
== PTRACE_PEEKUSR_AREA
)
577 ret
= peek_user_emu31(child
, addr
, data
);
581 (__u32 __force __user
*) data
))
583 ret
= poke_user_emu31(child
, addr
, utmp
);
587 addr
+= sizeof(unsigned int);
588 data
+= sizeof(unsigned int);
589 copied
+= sizeof(unsigned int);
592 case PTRACE_GETEVENTMSG
:
593 return put_user((__u32
) child
->ptrace_message
,
594 (unsigned int __force __user
*) data
);
595 case PTRACE_GETSIGINFO
:
596 if (child
->last_siginfo
== NULL
)
598 return copy_siginfo_to_user32((compat_siginfo_t
599 __force __user
*) data
,
600 child
->last_siginfo
);
601 case PTRACE_SETSIGINFO
:
602 if (child
->last_siginfo
== NULL
)
604 return copy_siginfo_from_user32(child
->last_siginfo
,
606 __force __user
*) data
);
608 return ptrace_request(child
, request
, addr
, data
);
612 #define PT32_IEEE_IP 0x13c
615 do_ptrace(struct task_struct
*child
, long request
, long addr
, long data
)
619 if (request
== PTRACE_ATTACH
)
620 return ptrace_attach(child
);
623 * Special cases to get/store the ieee instructions pointer.
625 if (child
== current
) {
626 if (request
== PTRACE_PEEKUSR
&& addr
== PT_IEEE_IP
)
627 return peek_user(child
, addr
, data
);
628 if (request
== PTRACE_POKEUSR
&& addr
== PT_IEEE_IP
)
629 return poke_user(child
, addr
, data
);
631 if (request
== PTRACE_PEEKUSR
&&
632 addr
== PT32_IEEE_IP
&& test_thread_flag(TIF_31BIT
))
633 return peek_user_emu31(child
, addr
, data
);
634 if (request
== PTRACE_POKEUSR
&&
635 addr
== PT32_IEEE_IP
&& test_thread_flag(TIF_31BIT
))
636 return poke_user_emu31(child
, addr
, data
);
640 ret
= ptrace_check_attach(child
, request
== PTRACE_KILL
);
646 /* continue and stop at next (return from) syscall */
648 /* restart after signal. */
649 if (!valid_signal(data
))
651 if (request
== PTRACE_SYSCALL
)
652 set_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
654 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
655 child
->exit_code
= data
;
656 /* make sure the single step bit is not set. */
657 clear_single_step(child
);
658 wake_up_process(child
);
663 * make the child exit. Best I can do is send it a sigkill.
664 * perhaps it should be put in the status that it wants to
667 if (child
->exit_state
== EXIT_ZOMBIE
) /* already dead */
669 child
->exit_code
= SIGKILL
;
670 /* make sure the single step bit is not set. */
671 clear_single_step(child
);
672 wake_up_process(child
);
675 case PTRACE_SINGLESTEP
:
676 /* set the trap flag. */
677 if (!valid_signal(data
))
679 clear_tsk_thread_flag(child
, TIF_SYSCALL_TRACE
);
680 child
->exit_code
= data
;
682 set_tsk_thread_flag(child
, TIF_SINGLE_STEP
);
684 set_single_step(child
);
685 /* give it a chance to run. */
686 wake_up_process(child
);
690 /* detach a process that was attached. */
691 return ptrace_detach(child
, data
);
694 /* Do requests that differ for 31/64 bit */
697 if (test_thread_flag(TIF_31BIT
))
698 return do_ptrace_emu31(child
, request
, addr
, data
);
700 return do_ptrace_normal(child
, request
, addr
, data
);
707 sys_ptrace(long request
, long pid
, long addr
, long data
)
709 struct task_struct
*child
;
713 if (request
== PTRACE_TRACEME
) {
714 ret
= ptrace_traceme();
718 child
= ptrace_get_task_struct(pid
);
720 ret
= PTR_ERR(child
);
724 ret
= do_ptrace(child
, request
, addr
, data
);
725 put_task_struct(child
);
732 syscall_trace(struct pt_regs
*regs
, int entryexit
)
734 if (unlikely(current
->audit_context
) && entryexit
)
735 audit_syscall_exit(AUDITSC_RESULT(regs
->gprs
[2]), regs
->gprs
[2]);
737 if (!test_thread_flag(TIF_SYSCALL_TRACE
))
739 if (!(current
->ptrace
& PT_PTRACED
))
741 ptrace_notify(SIGTRAP
| ((current
->ptrace
& PT_TRACESYSGOOD
)
745 * If the debuffer has set an invalid system call number,
746 * we prepare to skip the system call restart handling.
748 if (!entryexit
&& regs
->gprs
[2] >= NR_syscalls
)
752 * this isn't the same as continuing with a signal, but it will do
753 * for normal use. strace only continues with a signal if the
754 * stopping signal is not SIGTRAP. -brl
756 if (current
->exit_code
) {
757 send_sig(current
->exit_code
, current
, 1);
758 current
->exit_code
= 0;
761 if (unlikely(current
->audit_context
) && !entryexit
)
762 audit_syscall_entry(test_thread_flag(TIF_31BIT
)?AUDIT_ARCH_S390
:AUDIT_ARCH_S390X
,
763 regs
->gprs
[2], regs
->orig_gpr2
, regs
->gprs
[3],
764 regs
->gprs
[4], regs
->gprs
[5]);