home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / ptrace.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.2 KB  |  323 lines
  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.  
  19. #define PTRACE_ATTACH          16
  20. #define PTRACE_DETACH          17
  21.  
  22. #define PTRACE_SYSCALL          24
  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.  
  30. /* options set using PTRACE_SETOPTIONS */
  31. #define PTRACE_O_TRACESYSGOOD    0x00000001
  32. #define PTRACE_O_TRACEFORK    0x00000002
  33. #define PTRACE_O_TRACEVFORK    0x00000004
  34. #define PTRACE_O_TRACECLONE    0x00000008
  35. #define PTRACE_O_TRACEEXEC    0x00000010
  36. #define PTRACE_O_TRACEVFORKDONE    0x00000020
  37. #define PTRACE_O_TRACEEXIT    0x00000040
  38.  
  39. #define PTRACE_O_MASK        0x0000007f
  40.  
  41. /* Wait extended result codes for the above trace options.  */
  42. #define PTRACE_EVENT_FORK    1
  43. #define PTRACE_EVENT_VFORK    2
  44. #define PTRACE_EVENT_CLONE    3
  45. #define PTRACE_EVENT_EXEC    4
  46. #define PTRACE_EVENT_VFORK_DONE    5
  47. #define PTRACE_EVENT_EXIT    6
  48.  
  49. #include <asm/ptrace.h>
  50.  
  51. #ifdef __KERNEL__
  52. /*
  53.  * Ptrace flags
  54.  *
  55.  * The owner ship rules for task->ptrace which holds the ptrace
  56.  * flags is simple.  When a task is running it owns it's task->ptrace
  57.  * flags.  When the a task is stopped the ptracer owns task->ptrace.
  58.  */
  59.  
  60. #define PT_PTRACED    0x00000001
  61. #define PT_DTRACE    0x00000002    /* delayed trace (used on m68k, i386) */
  62. #define PT_TRACESYSGOOD    0x00000004
  63. #define PT_PTRACE_CAP    0x00000008    /* ptracer can follow suid-exec */
  64. #define PT_TRACE_FORK    0x00000010
  65. #define PT_TRACE_VFORK    0x00000020
  66. #define PT_TRACE_CLONE    0x00000040
  67. #define PT_TRACE_EXEC    0x00000080
  68. #define PT_TRACE_VFORK_DONE    0x00000100
  69. #define PT_TRACE_EXIT    0x00000200
  70.  
  71. #define PT_TRACE_MASK    0x000003f4
  72.  
  73. /* single stepping state bits (used on ARM and PA-RISC) */
  74. #define PT_SINGLESTEP_BIT    31
  75. #define PT_SINGLESTEP        (1<<PT_SINGLESTEP_BIT)
  76. #define PT_BLOCKSTEP_BIT    30
  77. #define PT_BLOCKSTEP        (1<<PT_BLOCKSTEP_BIT)
  78.  
  79. #include <linux/compiler.h>        /* For unlikely.  */
  80. #include <linux/sched.h>        /* For struct task_struct.  */
  81.  
  82.  
  83. extern long arch_ptrace(struct task_struct *child, long request, long addr, long data);
  84. extern struct task_struct *ptrace_get_task_struct(pid_t pid);
  85. extern int ptrace_traceme(void);
  86. extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
  87. extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
  88. extern int ptrace_attach(struct task_struct *tsk);
  89. extern int ptrace_detach(struct task_struct *, unsigned int);
  90. extern void ptrace_disable(struct task_struct *);
  91. extern int ptrace_check_attach(struct task_struct *task, int kill);
  92. extern int ptrace_request(struct task_struct *child, long request, long addr, long data);
  93. extern void ptrace_notify(int exit_code);
  94. extern void __ptrace_link(struct task_struct *child,
  95.               struct task_struct *new_parent);
  96. extern void __ptrace_unlink(struct task_struct *child);
  97. #define PTRACE_MODE_READ   1
  98. #define PTRACE_MODE_ATTACH 2
  99. /* Returns 0 on success, -errno on denial. */
  100. extern int __ptrace_may_access(struct task_struct *task, unsigned int mode);
  101. /* Returns true on success, false on denial. */
  102. extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
  103.  
  104. static inline int ptrace_reparented(struct task_struct *child)
  105. {
  106.     return child->real_parent != child->parent;
  107. }
  108. static inline void ptrace_link(struct task_struct *child,
  109.                    struct task_struct *new_parent)
  110. {
  111.     if (unlikely(child->ptrace))
  112.         __ptrace_link(child, new_parent);
  113. }
  114. static inline void ptrace_unlink(struct task_struct *child)
  115. {
  116.     if (unlikely(child->ptrace))
  117.         __ptrace_unlink(child);
  118. }
  119.  
  120. int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data);
  121. int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data);
  122.  
  123. /**
  124.  * task_ptrace - return %PT_* flags that apply to a task
  125.  * @task:    pointer to &task_struct in question
  126.  *
  127.  * Returns the %PT_* flags that apply to @task.
  128.  */
  129. static inline int task_ptrace(struct task_struct *task)
  130. {
  131.     return task->ptrace;
  132. }
  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. /**
  157.  * ptrace_init_task - initialize ptrace state for a new child
  158.  * @child:        new child task
  159.  * @ptrace:        true if child should be ptrace'd by parent's tracer
  160.  *
  161.  * This is called immediately after adding @child to its parent's children
  162.  * list.  @ptrace is false in the normal case, and true to ptrace @child.
  163.  *
  164.  * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
  165.  */
  166. static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
  167. {
  168.     INIT_LIST_HEAD(&child->ptrace_entry);
  169.     INIT_LIST_HEAD(&child->ptraced);
  170.     child->parent = child->real_parent;
  171.     child->ptrace = 0;
  172.     if (unlikely(ptrace)) {
  173.         child->ptrace = current->ptrace;
  174.         ptrace_link(child, current->parent);
  175.     }
  176. }
  177.  
  178. /**
  179.  * ptrace_release_task - final ptrace-related cleanup of a zombie being reaped
  180.  * @task:    task in %EXIT_DEAD state
  181.  *
  182.  * Called with write_lock(&tasklist_lock) held.
  183.  */
  184. static inline void ptrace_release_task(struct task_struct *task)
  185. {
  186.     BUG_ON(!list_empty(&task->ptraced));
  187.     ptrace_unlink(task);
  188.     BUG_ON(!list_empty(&task->ptrace_entry));
  189. }
  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. /*
  207.  * <asm/ptrace.h> should define the following things inside #ifdef __KERNEL__.
  208.  *
  209.  * These do-nothing inlines are used when the arch does not
  210.  * implement single-step.  The kerneldoc comments are here
  211.  * to document the interface for all arch definitions.
  212.  */
  213.  
  214. #ifndef arch_has_single_step
  215. /**
  216.  * arch_has_single_step - does this CPU support user-mode single-step?
  217.  *
  218.  * If this is defined, then there must be function declarations or
  219.  * inlines for user_enable_single_step() and user_disable_single_step().
  220.  * arch_has_single_step() should evaluate to nonzero iff the machine
  221.  * supports instruction single-step for user mode.
  222.  * It can be a constant or it can test a CPU feature bit.
  223.  */
  224. #define arch_has_single_step()        (0)
  225.  
  226. /**
  227.  * user_enable_single_step - single-step in user-mode task
  228.  * @task: either current or a task stopped in %TASK_TRACED
  229.  *
  230.  * This can only be called when arch_has_single_step() has returned nonzero.
  231.  * Set @task so that when it returns to user mode, it will trap after the
  232.  * next single instruction executes.  If arch_has_block_step() is defined,
  233.  * this must clear the effects of user_enable_block_step() too.
  234.  */
  235. static inline void user_enable_single_step(struct task_struct *task)
  236. {
  237.     BUG();            /* This can never be called.  */
  238. }
  239.  
  240. /**
  241.  * user_disable_single_step - cancel user-mode single-step
  242.  * @task: either current or a task stopped in %TASK_TRACED
  243.  *
  244.  * Clear @task of the effects of user_enable_single_step() and
  245.  * user_enable_block_step().  This can be called whether or not either
  246.  * of those was ever called on @task, and even if arch_has_single_step()
  247.  * returned zero.
  248.  */
  249. static inline void user_disable_single_step(struct task_struct *task)
  250. {
  251. }
  252. #endif    /* arch_has_single_step */
  253.  
  254. #ifndef arch_has_block_step
  255. /**
  256.  * arch_has_block_step - does this CPU support user-mode block-step?
  257.  *
  258.  * If this is defined, then there must be a function declaration or inline
  259.  * for user_enable_block_step(), and arch_has_single_step() must be defined
  260.  * too.  arch_has_block_step() should evaluate to nonzero iff the machine
  261.  * supports step-until-branch for user mode.  It can be a constant or it
  262.  * can test a CPU feature bit.
  263.  */
  264. #define arch_has_block_step()        (0)
  265.  
  266. /**
  267.  * user_enable_block_step - step until branch in user-mode task
  268.  * @task: either current or a task stopped in %TASK_TRACED
  269.  *
  270.  * This can only be called when arch_has_block_step() has returned nonzero,
  271.  * and will never be called when single-instruction stepping is being used.
  272.  * Set @task so that when it returns to user mode, it will trap after the
  273.  * next branch or trap taken.
  274.  */
  275. static inline void user_enable_block_step(struct task_struct *task)
  276. {
  277.     BUG();            /* This can never be called.  */
  278. }
  279. #endif    /* arch_has_block_step */
  280.  
  281. #ifndef arch_ptrace_stop_needed
  282. /**
  283.  * arch_ptrace_stop_needed - Decide whether arch_ptrace_stop() should be called
  284.  * @code:    current->exit_code value ptrace will stop with
  285.  * @info:    siginfo_t pointer (or %NULL) for signal ptrace will stop with
  286.  *
  287.  * This is called with the siglock held, to decide whether or not it's
  288.  * necessary to release the siglock and call arch_ptrace_stop() with the
  289.  * same @code and @info arguments.  It can be defined to a constant if
  290.  * arch_ptrace_stop() is never required, or always is.  On machines where
  291.  * this makes sense, it should be defined to a quick test to optimize out
  292.  * calling arch_ptrace_stop() when it would be superfluous.  For example,
  293.  * if the thread has not been back to user mode since the last stop, the
  294.  * thread state might indicate that nothing needs to be done.
  295.  */
  296. #define arch_ptrace_stop_needed(code, info)    (0)
  297. #endif
  298.  
  299. #ifndef arch_ptrace_stop
  300. /**
  301.  * arch_ptrace_stop - Do machine-specific work before stopping for ptrace
  302.  * @code:    current->exit_code value ptrace will stop with
  303.  * @info:    siginfo_t pointer (or %NULL) for signal ptrace will stop with
  304.  *
  305.  * This is called with no locks held when arch_ptrace_stop_needed() has
  306.  * just returned nonzero.  It is allowed to block, e.g. for user memory
  307.  * access.  The arch can have machine-specific work to be done before
  308.  * ptrace stops.  On ia64, register backing store gets written back to user
  309.  * memory here.  Since this can be costly (requires dropping the siglock),
  310.  * we only do it when the arch requires it for this particular stop, as
  311.  * indicated by arch_ptrace_stop_needed().
  312.  */
  313. #define arch_ptrace_stop(code, info)        do { } while (0)
  314. #endif
  315.  
  316. extern int task_current_syscall(struct task_struct *target, long *callno,
  317.                 unsigned long args[6], unsigned int maxargs,
  318.                 unsigned long *sp, unsigned long *pc);
  319.  
  320. #endif
  321.  
  322. #endif
  323.