ptrace.h 13 KB

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