Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _LINUX_PTRACE_H |
| 2 | #define _LINUX_PTRACE_H |
| 3 | /* ptrace.h */ |
| 4 | /* structs and defines to help the user use the ptrace system call. */ |
| 5 | |
| 6 | /* has the defines to get at the registers. */ |
| 7 | |
| 8 | #define PTRACE_TRACEME 0 |
| 9 | #define PTRACE_PEEKTEXT 1 |
| 10 | #define PTRACE_PEEKDATA 2 |
| 11 | #define PTRACE_PEEKUSR 3 |
| 12 | #define PTRACE_POKETEXT 4 |
| 13 | #define PTRACE_POKEDATA 5 |
| 14 | #define PTRACE_POKEUSR 6 |
| 15 | #define PTRACE_CONT 7 |
| 16 | #define PTRACE_KILL 8 |
| 17 | #define PTRACE_SINGLESTEP 9 |
| 18 | |
Roland McGrath | 416bc51 | 2006-09-29 02:00:45 -0700 | [diff] [blame] | 19 | #define PTRACE_ATTACH 16 |
| 20 | #define PTRACE_DETACH 17 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | |
| 22 | #define PTRACE_SYSCALL 24 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | |
| 24 | /* 0x4200-0x4300 are reserved for architecture-independent additions. */ |
| 25 | #define PTRACE_SETOPTIONS 0x4200 |
| 26 | #define PTRACE_GETEVENTMSG 0x4201 |
| 27 | #define PTRACE_GETSIGINFO 0x4202 |
| 28 | #define PTRACE_SETSIGINFO 0x4203 |
| 29 | |
Suresh Siddha | 2225a12 | 2010-02-11 11:51:00 -0800 | [diff] [blame] | 30 | /* |
| 31 | * Generic ptrace interface that exports the architecture specific regsets |
| 32 | * using the corresponding NT_* types (which are also used in the core dump). |
Suresh Siddha | c6a0dd7 | 2010-02-22 14:51:32 -0800 | [diff] [blame] | 33 | * Please note that the NT_PRSTATUS note type in a core dump contains a full |
| 34 | * 'struct elf_prstatus'. But the user_regset for NT_PRSTATUS contains just the |
| 35 | * elf_gregset_t that is the pr_reg field of 'struct elf_prstatus'. For all the |
| 36 | * other user_regset flavors, the user_regset layout and the ELF core dump note |
| 37 | * payload are exactly the same layout. |
Suresh Siddha | 2225a12 | 2010-02-11 11:51:00 -0800 | [diff] [blame] | 38 | * |
| 39 | * This interface usage is as follows: |
| 40 | * struct iovec iov = { buf, len}; |
| 41 | * |
| 42 | * ret = ptrace(PTRACE_GETREGSET/PTRACE_SETREGSET, pid, NT_XXX_TYPE, &iov); |
| 43 | * |
| 44 | * On the successful completion, iov.len will be updated by the kernel, |
| 45 | * specifying how much the kernel has written/read to/from the user's iov.buf. |
| 46 | */ |
| 47 | #define PTRACE_GETREGSET 0x4204 |
| 48 | #define PTRACE_SETREGSET 0x4205 |
| 49 | |
Tejun Heo | 3544d72 | 2011-06-14 11:20:15 +0200 | [diff] [blame] | 50 | #define PTRACE_SEIZE 0x4206 |
Tejun Heo | fca26f2 | 2011-06-14 11:20:16 +0200 | [diff] [blame] | 51 | #define PTRACE_INTERRUPT 0x4207 |
Tejun Heo | 544b2c9 | 2011-06-14 11:20:18 +0200 | [diff] [blame] | 52 | #define PTRACE_LISTEN 0x4208 |
Tejun Heo | 3544d72 | 2011-06-14 11:20:15 +0200 | [diff] [blame] | 53 | |
| 54 | /* flags in @data for PTRACE_SEIZE */ |
| 55 | #define PTRACE_SEIZE_DEVEL 0x80000000 /* temp flag for development */ |
| 56 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | /* options set using PTRACE_SETOPTIONS */ |
| 58 | #define PTRACE_O_TRACESYSGOOD 0x00000001 |
| 59 | #define PTRACE_O_TRACEFORK 0x00000002 |
| 60 | #define PTRACE_O_TRACEVFORK 0x00000004 |
| 61 | #define PTRACE_O_TRACECLONE 0x00000008 |
| 62 | #define PTRACE_O_TRACEEXEC 0x00000010 |
| 63 | #define PTRACE_O_TRACEVFORKDONE 0x00000020 |
| 64 | #define PTRACE_O_TRACEEXIT 0x00000040 |
| 65 | |
| 66 | #define PTRACE_O_MASK 0x0000007f |
| 67 | |
| 68 | /* Wait extended result codes for the above trace options. */ |
| 69 | #define PTRACE_EVENT_FORK 1 |
| 70 | #define PTRACE_EVENT_VFORK 2 |
| 71 | #define PTRACE_EVENT_CLONE 3 |
| 72 | #define PTRACE_EVENT_EXEC 4 |
| 73 | #define PTRACE_EVENT_VFORK_DONE 5 |
| 74 | #define PTRACE_EVENT_EXIT 6 |
Tejun Heo | 3544d72 | 2011-06-14 11:20:15 +0200 | [diff] [blame] | 75 | #define PTRACE_EVENT_STOP 7 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
| 77 | #include <asm/ptrace.h> |
| 78 | |
| 79 | #ifdef __KERNEL__ |
| 80 | /* |
| 81 | * Ptrace flags |
Eric W. Biederman | 260ea10 | 2006-06-23 02:05:18 -0700 | [diff] [blame] | 82 | * |
| 83 | * The owner ship rules for task->ptrace which holds the ptrace |
| 84 | * flags is simple. When a task is running it owns it's task->ptrace |
| 85 | * flags. When the a task is stopped the ptracer owns task->ptrace. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | */ |
| 87 | |
Tejun Heo | 3544d72 | 2011-06-14 11:20:15 +0200 | [diff] [blame] | 88 | #define PT_SEIZED 0x00010000 /* SEIZE used, enable new behavior */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | #define PT_PTRACED 0x00000001 |
| 90 | #define PT_DTRACE 0x00000002 /* delayed trace (used on m68k, i386) */ |
| 91 | #define PT_TRACESYSGOOD 0x00000004 |
| 92 | #define PT_PTRACE_CAP 0x00000008 /* ptracer can follow suid-exec */ |
Tejun Heo | 643ad83 | 2011-06-17 16:50:35 +0200 | [diff] [blame] | 93 | |
| 94 | /* PT_TRACE_* event enable flags */ |
| 95 | #define PT_EVENT_FLAG_SHIFT 4 |
| 96 | #define PT_EVENT_FLAG(event) (1 << (PT_EVENT_FLAG_SHIFT + (event) - 1)) |
| 97 | |
| 98 | #define PT_TRACE_FORK PT_EVENT_FLAG(PTRACE_EVENT_FORK) |
| 99 | #define PT_TRACE_VFORK PT_EVENT_FLAG(PTRACE_EVENT_VFORK) |
| 100 | #define PT_TRACE_CLONE PT_EVENT_FLAG(PTRACE_EVENT_CLONE) |
| 101 | #define PT_TRACE_EXEC PT_EVENT_FLAG(PTRACE_EVENT_EXEC) |
| 102 | #define PT_TRACE_VFORK_DONE PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE) |
| 103 | #define PT_TRACE_EXIT PT_EVENT_FLAG(PTRACE_EVENT_EXIT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | |
| 105 | #define PT_TRACE_MASK 0x000003f4 |
| 106 | |
| 107 | /* single stepping state bits (used on ARM and PA-RISC) */ |
| 108 | #define PT_SINGLESTEP_BIT 31 |
| 109 | #define PT_SINGLESTEP (1<<PT_SINGLESTEP_BIT) |
| 110 | #define PT_BLOCKSTEP_BIT 30 |
| 111 | #define PT_BLOCKSTEP (1<<PT_BLOCKSTEP_BIT) |
| 112 | |
| 113 | #include <linux/compiler.h> /* For unlikely. */ |
| 114 | #include <linux/sched.h> /* For struct task_struct. */ |
| 115 | |
Christoph Hellwig | 481bed4 | 2005-11-07 00:59:47 -0800 | [diff] [blame] | 116 | |
Namhyung Kim | 9b05a69 | 2010-10-27 15:33:47 -0700 | [diff] [blame] | 117 | extern long arch_ptrace(struct task_struct *child, long request, |
| 118 | unsigned long addr, unsigned long data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len); |
| 120 | extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | extern void ptrace_disable(struct task_struct *); |
Tejun Heo | 755e276 | 2011-06-02 11:13:59 +0200 | [diff] [blame] | 122 | extern int ptrace_check_attach(struct task_struct *task, bool ignore_state); |
Namhyung Kim | 4abf986 | 2010-10-27 15:33:45 -0700 | [diff] [blame] | 123 | extern int ptrace_request(struct task_struct *child, long request, |
| 124 | unsigned long addr, unsigned long data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | extern void ptrace_notify(int exit_code); |
| 126 | extern void __ptrace_link(struct task_struct *child, |
| 127 | struct task_struct *new_parent); |
| 128 | extern void __ptrace_unlink(struct task_struct *child); |
Oleg Nesterov | 39c626a | 2009-04-02 16:58:18 -0700 | [diff] [blame] | 129 | extern void exit_ptrace(struct task_struct *tracer); |
Stephen Smalley | 006ebb4 | 2008-05-19 08:32:49 -0400 | [diff] [blame] | 130 | #define PTRACE_MODE_READ 1 |
| 131 | #define PTRACE_MODE_ATTACH 2 |
| 132 | /* Returns 0 on success, -errno on denial. */ |
| 133 | extern int __ptrace_may_access(struct task_struct *task, unsigned int mode); |
| 134 | /* Returns true on success, false on denial. */ |
| 135 | extern bool ptrace_may_access(struct task_struct *task, unsigned int mode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | |
Oleg Nesterov | 53b6f9f | 2008-04-30 00:53:13 -0700 | [diff] [blame] | 137 | static inline int ptrace_reparented(struct task_struct *child) |
| 138 | { |
Oleg Nesterov | 0347e17 | 2011-06-24 17:34:06 +0200 | [diff] [blame] | 139 | return !same_thread_group(child->real_parent, child->parent); |
Oleg Nesterov | 53b6f9f | 2008-04-30 00:53:13 -0700 | [diff] [blame] | 140 | } |
Oleg Nesterov | c6a47cc | 2009-12-15 16:47:15 -0800 | [diff] [blame] | 141 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | static inline void ptrace_unlink(struct task_struct *child) |
| 143 | { |
| 144 | if (unlikely(child->ptrace)) |
| 145 | __ptrace_unlink(child); |
| 146 | } |
| 147 | |
Namhyung Kim | 4abf986 | 2010-10-27 15:33:45 -0700 | [diff] [blame] | 148 | int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr, |
| 149 | unsigned long data); |
| 150 | int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr, |
| 151 | unsigned long data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 153 | /** |
Tejun Heo | 06d9847 | 2011-06-17 16:50:40 +0200 | [diff] [blame] | 154 | * ptrace_parent - return the task that is tracing the given task |
| 155 | * @task: task to consider |
| 156 | * |
| 157 | * Returns %NULL if no one is tracing @task, or the &struct task_struct |
| 158 | * pointer to its tracer. |
| 159 | * |
| 160 | * Must called under rcu_read_lock(). The pointer returned might be kept |
| 161 | * live only by RCU. During exec, this may be called with task_lock() held |
| 162 | * on @task, still held from when check_unsafe_exec() was called. |
| 163 | */ |
| 164 | static inline struct task_struct *ptrace_parent(struct task_struct *task) |
| 165 | { |
| 166 | if (unlikely(task->ptrace)) |
| 167 | return rcu_dereference(task->parent); |
| 168 | return NULL; |
| 169 | } |
| 170 | |
| 171 | /** |
Tejun Heo | 643ad83 | 2011-06-17 16:50:35 +0200 | [diff] [blame] | 172 | * ptrace_event_enabled - test whether a ptrace event is enabled |
| 173 | * @task: ptracee of interest |
| 174 | * @event: %PTRACE_EVENT_* to test |
| 175 | * |
| 176 | * Test whether @event is enabled for ptracee @task. |
| 177 | * |
| 178 | * Returns %true if @event is enabled, %false otherwise. |
| 179 | */ |
| 180 | static inline bool ptrace_event_enabled(struct task_struct *task, int event) |
| 181 | { |
| 182 | return task->ptrace & PT_EVENT_FLAG(event); |
| 183 | } |
| 184 | |
| 185 | /** |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 186 | * ptrace_event - possibly stop for a ptrace event notification |
Tejun Heo | 643ad83 | 2011-06-17 16:50:35 +0200 | [diff] [blame] | 187 | * @event: %PTRACE_EVENT_* value to report |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 188 | * @message: value for %PTRACE_GETEVENTMSG to return |
| 189 | * |
Tejun Heo | 643ad83 | 2011-06-17 16:50:35 +0200 | [diff] [blame] | 190 | * Check whether @event is enabled and, if so, report @event and @message |
| 191 | * to the ptrace parent. |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 192 | * |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 193 | * Called without locks. |
| 194 | */ |
Tejun Heo | f3c04b9 | 2011-06-17 16:50:36 +0200 | [diff] [blame] | 195 | static inline void ptrace_event(int event, unsigned long message) |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 196 | { |
Tejun Heo | f3c04b9 | 2011-06-17 16:50:36 +0200 | [diff] [blame] | 197 | if (unlikely(ptrace_event_enabled(current, event))) { |
| 198 | current->ptrace_message = message; |
| 199 | ptrace_notify((event << 8) | SIGTRAP); |
| 200 | } else if (event == PTRACE_EVENT_EXEC && unlikely(current->ptrace)) { |
| 201 | /* legacy EXEC report via SIGTRAP */ |
| 202 | send_sig(SIGTRAP, current, 0); |
| 203 | } |
Roland McGrath | 88ac292 | 2008-07-25 19:45:43 -0700 | [diff] [blame] | 204 | } |
| 205 | |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 206 | /** |
| 207 | * ptrace_init_task - initialize ptrace state for a new child |
| 208 | * @child: new child task |
| 209 | * @ptrace: true if child should be ptrace'd by parent's tracer |
| 210 | * |
| 211 | * This is called immediately after adding @child to its parent's children |
| 212 | * list. @ptrace is false in the normal case, and true to ptrace @child. |
| 213 | * |
| 214 | * Called with current's siglock and write_lock_irq(&tasklist_lock) held. |
| 215 | */ |
| 216 | static inline void ptrace_init_task(struct task_struct *child, bool ptrace) |
| 217 | { |
| 218 | INIT_LIST_HEAD(&child->ptrace_entry); |
| 219 | INIT_LIST_HEAD(&child->ptraced); |
Frederic Weisbecker | bf26c01 | 2011-04-07 16:53:20 +0200 | [diff] [blame] | 220 | #ifdef CONFIG_HAVE_HW_BREAKPOINT |
| 221 | atomic_set(&child->ptrace_bp_refcnt, 1); |
| 222 | #endif |
Oleg Nesterov | 6634ae1 | 2011-07-08 19:13:39 +0200 | [diff] [blame^] | 223 | child->jobctl = 0; |
| 224 | child->ptrace = 0; |
| 225 | child->parent = child->real_parent; |
| 226 | |
| 227 | if (unlikely(ptrace) && current->ptrace) { |
| 228 | child->ptrace = current->ptrace; |
| 229 | __ptrace_link(child, current->parent); |
| 230 | } |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 231 | } |
| 232 | |
Roland McGrath | dae3357 | 2008-07-25 19:45:48 -0700 | [diff] [blame] | 233 | /** |
| 234 | * ptrace_release_task - final ptrace-related cleanup of a zombie being reaped |
| 235 | * @task: task in %EXIT_DEAD state |
| 236 | * |
| 237 | * Called with write_lock(&tasklist_lock) held. |
| 238 | */ |
| 239 | static inline void ptrace_release_task(struct task_struct *task) |
| 240 | { |
| 241 | BUG_ON(!list_empty(&task->ptraced)); |
| 242 | ptrace_unlink(task); |
| 243 | BUG_ON(!list_empty(&task->ptrace_entry)); |
| 244 | } |
| 245 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | #ifndef force_successful_syscall_return |
| 247 | /* |
| 248 | * System call handlers that, upon successful completion, need to return a |
| 249 | * negative value should call force_successful_syscall_return() right before |
| 250 | * returning. On architectures where the syscall convention provides for a |
| 251 | * separate error flag (e.g., alpha, ia64, ppc{,64}, sparc{,64}, possibly |
| 252 | * others), this macro can be used to ensure that the error flag will not get |
| 253 | * set. On architectures which do not support a separate error flag, the macro |
| 254 | * is a no-op and the spurious error condition needs to be filtered out by some |
| 255 | * other means (e.g., in user-level, by passing an extra argument to the |
| 256 | * syscall handler, or something along those lines). |
| 257 | */ |
| 258 | #define force_successful_syscall_return() do { } while (0) |
| 259 | #endif |
| 260 | |
Roland McGrath | fb7fa8f | 2008-01-30 13:30:47 +0100 | [diff] [blame] | 261 | /* |
| 262 | * <asm/ptrace.h> should define the following things inside #ifdef __KERNEL__. |
| 263 | * |
| 264 | * These do-nothing inlines are used when the arch does not |
| 265 | * implement single-step. The kerneldoc comments are here |
| 266 | * to document the interface for all arch definitions. |
| 267 | */ |
| 268 | |
| 269 | #ifndef arch_has_single_step |
| 270 | /** |
| 271 | * arch_has_single_step - does this CPU support user-mode single-step? |
| 272 | * |
| 273 | * If this is defined, then there must be function declarations or |
| 274 | * inlines for user_enable_single_step() and user_disable_single_step(). |
| 275 | * arch_has_single_step() should evaluate to nonzero iff the machine |
| 276 | * supports instruction single-step for user mode. |
| 277 | * It can be a constant or it can test a CPU feature bit. |
| 278 | */ |
| 279 | #define arch_has_single_step() (0) |
| 280 | |
| 281 | /** |
| 282 | * user_enable_single_step - single-step in user-mode task |
| 283 | * @task: either current or a task stopped in %TASK_TRACED |
| 284 | * |
| 285 | * This can only be called when arch_has_single_step() has returned nonzero. |
| 286 | * Set @task so that when it returns to user mode, it will trap after the |
Roland McGrath | dc802c2 | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 287 | * next single instruction executes. If arch_has_block_step() is defined, |
| 288 | * this must clear the effects of user_enable_block_step() too. |
Roland McGrath | fb7fa8f | 2008-01-30 13:30:47 +0100 | [diff] [blame] | 289 | */ |
| 290 | static inline void user_enable_single_step(struct task_struct *task) |
| 291 | { |
| 292 | BUG(); /* This can never be called. */ |
| 293 | } |
| 294 | |
| 295 | /** |
| 296 | * user_disable_single_step - cancel user-mode single-step |
| 297 | * @task: either current or a task stopped in %TASK_TRACED |
| 298 | * |
Roland McGrath | dc802c2 | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 299 | * Clear @task of the effects of user_enable_single_step() and |
| 300 | * user_enable_block_step(). This can be called whether or not either |
| 301 | * of those was ever called on @task, and even if arch_has_single_step() |
| 302 | * returned zero. |
Roland McGrath | fb7fa8f | 2008-01-30 13:30:47 +0100 | [diff] [blame] | 303 | */ |
| 304 | static inline void user_disable_single_step(struct task_struct *task) |
| 305 | { |
| 306 | } |
Christoph Hellwig | dacbe41 | 2010-03-10 15:22:46 -0800 | [diff] [blame] | 307 | #else |
| 308 | extern void user_enable_single_step(struct task_struct *); |
| 309 | extern void user_disable_single_step(struct task_struct *); |
Roland McGrath | fb7fa8f | 2008-01-30 13:30:47 +0100 | [diff] [blame] | 310 | #endif /* arch_has_single_step */ |
| 311 | |
Roland McGrath | dc802c2 | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 312 | #ifndef arch_has_block_step |
| 313 | /** |
| 314 | * arch_has_block_step - does this CPU support user-mode block-step? |
| 315 | * |
| 316 | * If this is defined, then there must be a function declaration or inline |
| 317 | * for user_enable_block_step(), and arch_has_single_step() must be defined |
| 318 | * too. arch_has_block_step() should evaluate to nonzero iff the machine |
| 319 | * supports step-until-branch for user mode. It can be a constant or it |
| 320 | * can test a CPU feature bit. |
| 321 | */ |
Roland McGrath | 5b88abb | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 322 | #define arch_has_block_step() (0) |
Roland McGrath | dc802c2 | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 323 | |
| 324 | /** |
| 325 | * user_enable_block_step - step until branch in user-mode task |
| 326 | * @task: either current or a task stopped in %TASK_TRACED |
| 327 | * |
| 328 | * This can only be called when arch_has_block_step() has returned nonzero, |
| 329 | * and will never be called when single-instruction stepping is being used. |
| 330 | * Set @task so that when it returns to user mode, it will trap after the |
| 331 | * next branch or trap taken. |
| 332 | */ |
| 333 | static inline void user_enable_block_step(struct task_struct *task) |
| 334 | { |
| 335 | BUG(); /* This can never be called. */ |
| 336 | } |
Christoph Hellwig | dacbe41 | 2010-03-10 15:22:46 -0800 | [diff] [blame] | 337 | #else |
| 338 | extern void user_enable_block_step(struct task_struct *); |
Roland McGrath | dc802c2 | 2008-01-30 13:30:53 +0100 | [diff] [blame] | 339 | #endif /* arch_has_block_step */ |
| 340 | |
Oleg Nesterov | 85ec7fd | 2009-12-15 16:47:17 -0800 | [diff] [blame] | 341 | #ifdef ARCH_HAS_USER_SINGLE_STEP_INFO |
| 342 | extern void user_single_step_siginfo(struct task_struct *tsk, |
| 343 | struct pt_regs *regs, siginfo_t *info); |
| 344 | #else |
| 345 | static inline void user_single_step_siginfo(struct task_struct *tsk, |
| 346 | struct pt_regs *regs, siginfo_t *info) |
| 347 | { |
| 348 | memset(info, 0, sizeof(*info)); |
| 349 | info->si_signo = SIGTRAP; |
| 350 | } |
| 351 | #endif |
| 352 | |
Roland McGrath | 1a669c2 | 2008-02-06 01:37:37 -0800 | [diff] [blame] | 353 | #ifndef arch_ptrace_stop_needed |
| 354 | /** |
| 355 | * arch_ptrace_stop_needed - Decide whether arch_ptrace_stop() should be called |
| 356 | * @code: current->exit_code value ptrace will stop with |
| 357 | * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with |
| 358 | * |
| 359 | * This is called with the siglock held, to decide whether or not it's |
| 360 | * necessary to release the siglock and call arch_ptrace_stop() with the |
| 361 | * same @code and @info arguments. It can be defined to a constant if |
| 362 | * arch_ptrace_stop() is never required, or always is. On machines where |
| 363 | * this makes sense, it should be defined to a quick test to optimize out |
| 364 | * calling arch_ptrace_stop() when it would be superfluous. For example, |
| 365 | * if the thread has not been back to user mode since the last stop, the |
| 366 | * thread state might indicate that nothing needs to be done. |
| 367 | */ |
| 368 | #define arch_ptrace_stop_needed(code, info) (0) |
| 369 | #endif |
| 370 | |
| 371 | #ifndef arch_ptrace_stop |
| 372 | /** |
| 373 | * arch_ptrace_stop - Do machine-specific work before stopping for ptrace |
| 374 | * @code: current->exit_code value ptrace will stop with |
| 375 | * @info: siginfo_t pointer (or %NULL) for signal ptrace will stop with |
| 376 | * |
| 377 | * This is called with no locks held when arch_ptrace_stop_needed() has |
| 378 | * just returned nonzero. It is allowed to block, e.g. for user memory |
| 379 | * access. The arch can have machine-specific work to be done before |
| 380 | * ptrace stops. On ia64, register backing store gets written back to user |
| 381 | * memory here. Since this can be costly (requires dropping the siglock), |
| 382 | * we only do it when the arch requires it for this particular stop, as |
| 383 | * indicated by arch_ptrace_stop_needed(). |
| 384 | */ |
| 385 | #define arch_ptrace_stop(code, info) do { } while (0) |
| 386 | #endif |
| 387 | |
Roland McGrath | bbc6986 | 2008-07-25 19:45:59 -0700 | [diff] [blame] | 388 | extern int task_current_syscall(struct task_struct *target, long *callno, |
| 389 | unsigned long args[6], unsigned int maxargs, |
| 390 | unsigned long *sp, unsigned long *pc); |
| 391 | |
Frederic Weisbecker | bf26c01 | 2011-04-07 16:53:20 +0200 | [diff] [blame] | 392 | #ifdef CONFIG_HAVE_HW_BREAKPOINT |
| 393 | extern int ptrace_get_breakpoints(struct task_struct *tsk); |
| 394 | extern void ptrace_put_breakpoints(struct task_struct *tsk); |
| 395 | #else |
| 396 | static inline void ptrace_put_breakpoints(struct task_struct *tsk) { } |
| 397 | #endif /* CONFIG_HAVE_HW_BREAKPOINT */ |
| 398 | |
| 399 | #endif /* __KERNEL */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
| 401 | #endif |