gdb/linux-nat.h

   1 /* Native debugging support for GNU/Linux (LWP layer).
   2
   3    Copyright (C) 2000-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "nat/linux-nat.h"
  21 #include "target.h"
  22 #include <signal.h>
  23
  24 struct arch_lwp_info;
  25
  26 /* Structure describing an LWP.  This is public only for the purposes
  27    of ALL_LWPS; target-specific code should generally not access it
  28    directly.  */
  29
  30 struct lwp_info
  31 {
  32   /* The process id of the LWP.  This is a combination of the LWP id
  33      and overall process id.  */
  34   ptid_t ptid;
  35
  36   /* If this flag is set, we need to set the event request flags the
  37      next time we see this LWP stop.  */
  38   int must_set_ptrace_flags;
  39
  40   /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
  41      it back yet).  */
  42   int signalled;
  43
  44   /* Non-zero if this LWP is stopped.  */
  45   int stopped;
  46
  47   /* Non-zero if this LWP will be/has been resumed.  Note that an LWP
  48      can be marked both as stopped and resumed at the same time.  This
  49      happens if we try to resume an LWP that has a wait status
  50      pending.  We shouldn't let the LWP run until that wait status has
  51      been processed, but we should not report that wait status if GDB
  52      didn't try to let the LWP run.  */
  53   int resumed;
  54
  55   /* The last resume GDB requested on this thread.  */
  56   enum resume_kind last_resume_kind;
  57
  58   /* If non-zero, a pending wait status.  */
  59   int status;
  60
  61   /* When 'stopped' is set, this is where the lwp last stopped, with
  62      decr_pc_after_break already accounted for.  If the LWP is
  63      running, and stepping, this is the address at which the lwp was
  64      resumed (that is, it's the previous stop PC).  If the LWP is
  65      running and not stepping, this is 0.  */
  66   CORE_ADDR stop_pc;
  67
  68   /* Non-zero if we were stepping this LWP.  */
  69   int step;
  70
  71   /* The reason the LWP last stopped, if we need to track it
  72      (breakpoint, watchpoint, etc.)  */
  73   enum target_stop_reason stop_reason;
  74
  75   /* On architectures where it is possible to know the data address of
  76      a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and
  77      STOPPED_DATA_ADDRESS contains such data address.  Otherwise,
  78      STOPPED_DATA_ADDRESS_P is false, and STOPPED_DATA_ADDRESS is
  79      undefined.  Only valid if STOPPED_BY_WATCHPOINT is true.  */
  80   int stopped_data_address_p;
  81   CORE_ADDR stopped_data_address;
  82
  83   /* Non-zero if we expect a duplicated SIGINT.  */
  84   int ignore_sigint;
  85
  86   /* If WAITSTATUS->KIND != TARGET_WAITKIND_SPURIOUS, the waitstatus
  87      for this LWP's last event.  This may correspond to STATUS above,
  88      or to a local variable in lin_lwp_wait.  */
  89   struct target_waitstatus waitstatus;
  90
  91   /* Signal wether we are in a SYSCALL_ENTRY or
  92      in a SYSCALL_RETURN event.
  93      Values:
  94      - TARGET_WAITKIND_SYSCALL_ENTRY
  95      - TARGET_WAITKIND_SYSCALL_RETURN */
  96   enum target_waitkind syscall_state;
  97
  98   /* The processor core this LWP was last seen on.  */
  99   int core;
 100
 101   /* Arch-specific additions.  */
 102   struct arch_lwp_info *arch_private;
 103
 104   /* Next LWP in list.  */
 105   struct lwp_info *next;
 106 };
 107
 108 /* The global list of LWPs, for ALL_LWPS.  Unlike the threads list,
 109    there is always at least one LWP on the list while the GNU/Linux
 110    native target is active.  */
 111 extern struct lwp_info *lwp_list;
 112
 113 /* Does the current host support PTRACE_GETREGSET?  */
 114 extern enum tribool have_ptrace_getregset;
 115
 116 /* Iterate over each active thread (light-weight process).  */
 117 #define ALL_LWPS(LP)                                                    \
 118   for ((LP) = lwp_list;                                                 \
 119        (LP) != NULL;                                                    \
 120        (LP) = (LP)->next)
 121
 122 /* Attempt to initialize libthread_db.  */
 123 void check_for_thread_db (void);
 124
 125 /* Called from the LWP layer to inform the thread_db layer that PARENT
 126    spawned CHILD.  Both LWPs are currently stopped.  This function
 127    does whatever is required to have the child LWP under the
 128    thread_db's control --- e.g., enabling event reporting.  Returns
 129    true on success, false if the process isn't using libpthread.  */
 130 extern int thread_db_notice_clone (ptid_t parent, ptid_t child);
 131
 132 /* Return the set of signals used by the threads library.  */
 133 extern void lin_thread_get_thread_signals (sigset_t *mask);
 134
 135 /* Find process PID's pending signal set from /proc/pid/status.  */
 136 void linux_proc_pending_signals (int pid, sigset_t *pending,
 137                                  sigset_t *blocked, sigset_t *ignored);
 138
 139 /* For linux_stop_lwp see nat/linux-nat.h.  */
 140
 141 /* Stop all LWPs, synchronously.  (Any events that trigger while LWPs
 142    are being stopped are left pending.)  */
 143 extern void linux_stop_and_wait_all_lwps (void);
 144
 145 /* Set resumed LWPs running again, as they were before being stopped
 146    with linux_stop_and_wait_all_lwps.  (LWPS with pending events are
 147    left stopped.)  */
 148 extern void linux_unstop_all_lwps (void);
 149
 150 /* Create a prototype generic GNU/Linux target.  The client can
 151    override it with local methods.  */
 152 struct target_ops * linux_target (void);
 153
 154 /* Create a generic GNU/Linux target using traditional
 155    ptrace register access.  */
 156 struct target_ops *
 157 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int));
 158
 159 /* Register the customized GNU/Linux target.  This should be used
 160    instead of calling add_target directly.  */
 161 void linux_nat_add_target (struct target_ops *);
 162
 163 /* Register a method to call whenever a new thread is attached.  */
 164 void linux_nat_set_new_thread (struct target_ops *, void (*) (struct lwp_info *));
 165
 166
 167 /* Register a method to call whenever a new fork is attached.  */
 168 typedef void (linux_nat_new_fork_ftype) (struct lwp_info *parent,
 169                                          pid_t child_pid);
 170 void linux_nat_set_new_fork (struct target_ops *ops,
 171                              linux_nat_new_fork_ftype *fn);
 172
 173 /* Register a method to call whenever a process is killed or
 174    detached.  */
 175 typedef void (linux_nat_forget_process_ftype) (pid_t pid);
 176 void linux_nat_set_forget_process (struct target_ops *ops,
 177                                    linux_nat_forget_process_ftype *fn);
 178
 179 /* Call the method registered with the function above.  PID is the
 180    process to forget about.  */
 181 void linux_nat_forget_process (pid_t pid);
 182
 183 /* Register a method that converts a siginfo object between the layout
 184    that ptrace returns, and the layout in the architecture of the
 185    inferior.  */
 186 void linux_nat_set_siginfo_fixup (struct target_ops *,
 187                                   int (*) (siginfo_t *,
 188                                            gdb_byte *,
 189                                            int));
 190
 191 /* Register a method to call prior to resuming a thread.  */
 192
 193 void linux_nat_set_prepare_to_resume (struct target_ops *,
 194                                       void (*) (struct lwp_info *));
 195
 196 /* Update linux-nat internal state when changing from one fork
 197    to another.  */
 198 void linux_nat_switch_fork (ptid_t new_ptid);
 199
 200 /* Store the saved siginfo associated with PTID in *SIGINFO.
 201    Return 1 if it was retrieved successfully, 0 otherwise (*SIGINFO is
 202    uninitialized in such case).  */
 203 int linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo);
 204
 205 /* Set alternative SIGTRAP-like events recognizer.  */
 206 void linux_nat_set_status_is_event (struct target_ops *t,
 207                                     int (*status_is_event) (int status));