gdb/x86-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
   2
   3    Copyright (C) 1999-2022 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 "defs.h"
  21 #include "inferior.h"
  22 #include "elf/common.h"
  23 #include "gdb_proc_service.h"
  24 #include "nat/gdb_ptrace.h"
  25 #include <sys/user.h>
  26 #include <sys/procfs.h>
  27 #include <sys/uio.h>
  28
  29 #include "x86-nat.h"
  30 #ifndef __x86_64__
  31 #include "i386-linux-nat.h"
  32 #endif
  33 #include "x86-linux-nat.h"
  34 #include "i386-linux-tdep.h"
  35 #ifdef __x86_64__
  36 #include "amd64-linux-tdep.h"
  37 #endif
  38 #include "gdbsupport/x86-xstate.h"
  39 #include "nat/linux-btrace.h"
  40 #include "nat/linux-nat.h"
  41 #include "nat/x86-linux.h"
  42 #include "nat/x86-linux-dregs.h"
  43 #include "nat/linux-ptrace.h"
  44
  45 /* linux_nat_target::low_new_fork implementation.  */
  46
  47 void
  48 x86_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid)
  49 {
  50   pid_t parent_pid;
  51   struct x86_debug_reg_state *parent_state;
  52   struct x86_debug_reg_state *child_state;
  53
  54   /* NULL means no watchpoint has ever been set in the parent.  In
  55      that case, there's nothing to do.  */
  56   if (parent->arch_private == NULL)
  57     return;
  58
  59   /* Linux kernel before 2.6.33 commit
  60      72f674d203cd230426437cdcf7dd6f681dad8b0d
  61      will inherit hardware debug registers from parent
  62      on fork/vfork/clone.  Newer Linux kernels create such tasks with
  63      zeroed debug registers.
  64
  65      GDB core assumes the child inherits the watchpoints/hw
  66      breakpoints of the parent, and will remove them all from the
  67      forked off process.  Copy the debug registers mirrors into the
  68      new process so that all breakpoints and watchpoints can be
  69      removed together.  The debug registers mirror will become zeroed
  70      in the end before detaching the forked off process, thus making
  71      this compatible with older Linux kernels too.  */
  72
  73   parent_pid = parent->ptid.pid ();
  74   parent_state = x86_debug_reg_state (parent_pid);
  75   child_state = x86_debug_reg_state (child_pid);
  76   *child_state = *parent_state;
  77 }
  78 \f
  79
  80 x86_linux_nat_target::~x86_linux_nat_target ()
  81 {
  82 }
  83
  84 /* Implement the virtual inf_ptrace_target::post_startup_inferior method.  */
  85
  86 void
  87 x86_linux_nat_target::post_startup_inferior (ptid_t ptid)
  88 {
  89   x86_cleanup_dregs ();
  90   linux_nat_target::post_startup_inferior (ptid);
  91 }
  92
  93 #ifdef __x86_64__
  94 /* Value of CS segment register:
  95      64bit process: 0x33
  96      32bit process: 0x23  */
  97 #define AMD64_LINUX_USER64_CS 0x33
  98
  99 /* Value of DS segment register:
 100      LP64 process: 0x0
 101      X32 process: 0x2b  */
 102 #define AMD64_LINUX_X32_DS 0x2b
 103 #endif
 104
 105 /* Get Linux/x86 target description from running target.  */
 106
 107 const struct target_desc *
 108 x86_linux_nat_target::read_description ()
 109 {
 110   int tid;
 111   int is_64bit = 0;
 112 #ifdef __x86_64__
 113   int is_x32;
 114 #endif
 115   static uint64_t xcr0;
 116   uint64_t xcr0_features_bits;
 117
 118   tid = inferior_ptid.pid ();
 119
 120 #ifdef __x86_64__
 121   {
 122     unsigned long cs;
 123     unsigned long ds;
 124
 125     /* Get CS register.  */
 126     errno = 0;
 127     cs = ptrace (PTRACE_PEEKUSER, tid,
 128                  offsetof (struct user_regs_struct, cs), 0);
 129     if (errno != 0)
 130       perror_with_name (_("Couldn't get CS register"));
 131
 132     is_64bit = cs == AMD64_LINUX_USER64_CS;
 133
 134     /* Get DS register.  */
 135     errno = 0;
 136     ds = ptrace (PTRACE_PEEKUSER, tid,
 137                  offsetof (struct user_regs_struct, ds), 0);
 138     if (errno != 0)
 139       perror_with_name (_("Couldn't get DS register"));
 140
 141     is_x32 = ds == AMD64_LINUX_X32_DS;
 142
 143     if (sizeof (void *) == 4 && is_64bit && !is_x32)
 144       error (_("Can't debug 64-bit process with 32-bit GDB"));
 145   }
 146 #elif HAVE_PTRACE_GETFPXREGS
 147   if (have_ptrace_getfpxregs == -1)
 148     {
 149       elf_fpxregset_t fpxregs;
 150
 151       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 152         {
 153           have_ptrace_getfpxregs = 0;
 154           have_ptrace_getregset = TRIBOOL_FALSE;
 155           return i386_linux_read_description (X86_XSTATE_X87_MASK);
 156         }
 157     }
 158 #endif
 159
 160   if (have_ptrace_getregset == TRIBOOL_UNKNOWN)
 161     {
 162       uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 163       struct iovec iov;
 164
 165       iov.iov_base = xstateregs;
 166       iov.iov_len = sizeof (xstateregs);
 167
 168       /* Check if PTRACE_GETREGSET works.  */
 169       if (ptrace (PTRACE_GETREGSET, tid,
 170                   (unsigned int) NT_X86_XSTATE, &iov) < 0)
 171         have_ptrace_getregset = TRIBOOL_FALSE;
 172       else
 173         {
 174           have_ptrace_getregset = TRIBOOL_TRUE;
 175
 176           /* Get XCR0 from XSAVE extended state.  */
 177           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 178                              / sizeof (uint64_t))];
 179         }
 180     }
 181
 182   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  If
 183      PTRACE_GETREGSET is not available then set xcr0_features_bits to
 184      zero so that the "no-features" descriptions are returned by the
 185      switches below.  */
 186   if (have_ptrace_getregset == TRIBOOL_TRUE)
 187     xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
 188   else
 189     xcr0_features_bits = 0;
 190
 191   if (is_64bit)
 192     {
 193 #ifdef __x86_64__
 194       return amd64_linux_read_description (xcr0_features_bits, is_x32);
 195 #endif
 196     }
 197   else
 198     {
 199       const struct target_desc * tdesc
 200         = i386_linux_read_description (xcr0_features_bits);
 201
 202       if (tdesc == NULL)
 203         tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK);
 204
 205       return tdesc;
 206     }
 207
 208   gdb_assert_not_reached ("failed to return tdesc");
 209 }
 210 \f
 211
 212 /* Enable branch tracing.  */
 213
 214 struct btrace_target_info *
 215 x86_linux_nat_target::enable_btrace (ptid_t ptid,
 216                                      const struct btrace_config *conf)
 217 {
 218   struct btrace_target_info *tinfo = nullptr;
 219   try
 220     {
 221       tinfo = linux_enable_btrace (ptid, conf);
 222     }
 223   catch (const gdb_exception_error &exception)
 224     {
 225       error (_("Could not enable branch tracing for %s: %s"),
 226              target_pid_to_str (ptid).c_str (), exception.what ());
 227     }
 228
 229   return tinfo;
 230 }
 231
 232 /* Disable branch tracing.  */
 233
 234 void
 235 x86_linux_nat_target::disable_btrace (struct btrace_target_info *tinfo)
 236 {
 237   enum btrace_error errcode = linux_disable_btrace (tinfo);
 238
 239   if (errcode != BTRACE_ERR_NONE)
 240     error (_("Could not disable branch tracing."));
 241 }
 242
 243 /* Teardown branch tracing.  */
 244
 245 void
 246 x86_linux_nat_target::teardown_btrace (struct btrace_target_info *tinfo)
 247 {
 248   /* Ignore errors.  */
 249   linux_disable_btrace (tinfo);
 250 }
 251
 252 enum btrace_error
 253 x86_linux_nat_target::read_btrace (struct btrace_data *data,
 254                                    struct btrace_target_info *btinfo,
 255                                    enum btrace_read_type type)
 256 {
 257   return linux_read_btrace (data, btinfo, type);
 258 }
 259
 260 /* See to_btrace_conf in target.h.  */
 261
 262 const struct btrace_config *
 263 x86_linux_nat_target::btrace_conf (const struct btrace_target_info *btinfo)
 264 {
 265   return linux_btrace_conf (btinfo);
 266 }
 267
 268 \f
 269
 270 /* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
 271    the thread local storage (or its descriptor) and returns PS_OK
 272    on success.  Returns PS_ERR on failure.  */
 273
 274 ps_err_e
 275 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
 276 {
 277   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 278      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 279      4 byte integers in size: `entry_number', `base_addr', `limit',
 280      and a bunch of status bits.
 281
 282      The values returned by this ptrace call should be part of the
 283      regcache buffer, and ps_get_thread_area should channel its
 284      request through the regcache.  That way remote targets could
 285      provide the value using the remote protocol and not this direct
 286      call.
 287
 288      Is this function needed?  I'm guessing that the `base' is the
 289      address of a descriptor that libthread_db uses to find the
 290      thread local address base that GDB needs.  Perhaps that
 291      descriptor is defined by the ABI.  Anyway, given that
 292      libthread_db calls this function without prompting (gdb
 293      requesting tls base) I guess it needs info in there anyway.  */
 294   unsigned int desc[4];
 295
 296   /* This code assumes that "int" is 32 bits and that
 297      GET_THREAD_AREA returns no more than 4 int values.  */
 298   gdb_assert (sizeof (int) == 4);
 299
 300 #ifndef PTRACE_GET_THREAD_AREA
 301 #define PTRACE_GET_THREAD_AREA 25
 302 #endif
 303
 304   if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
 305     return PS_ERR;
 306
 307   *base_addr = desc[1];
 308   return PS_OK;
 309 }
 310 \f
 311
 312 void _initialize_x86_linux_nat ();
 313 void
 314 _initialize_x86_linux_nat ()
 315 {
 316   /* Initialize the debug register function vectors.  */
 317   x86_dr_low.set_control = x86_linux_dr_set_control;
 318   x86_dr_low.set_addr = x86_linux_dr_set_addr;
 319   x86_dr_low.get_addr = x86_linux_dr_get_addr;
 320   x86_dr_low.get_status = x86_linux_dr_get_status;
 321   x86_dr_low.get_control = x86_linux_dr_get_control;
 322   x86_set_debug_register_length (sizeof (void *));
 323 }