gdb/x86-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
   2
   3    Copyright (C) 1999-2017 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 #include "linux-nat.h"
  31 #ifndef __x86_64__
  32 #include "i386-linux-nat.h"
  33 #endif
  34 #include "x86-linux-nat.h"
  35 #include "i386-linux-tdep.h"
  36 #ifdef __x86_64__
  37 #include "amd64-linux-tdep.h"
  38 #endif
  39 #include "x86-xstate.h"
  40 #include "nat/linux-btrace.h"
  41 #include "nat/linux-nat.h"
  42 #include "nat/x86-linux.h"
  43 #include "nat/x86-linux-dregs.h"
  44 #include "nat/linux-ptrace.h"
  45
  46 /* Per-thread arch-specific data we want to keep.  */
  47
  48 struct arch_lwp_info
  49 {
  50   /* Non-zero if our copy differs from what's recorded in the thread.  */
  51   int debug_registers_changed;
  52 };
  53
  54 \f
  55
  56 /* linux_nat_new_fork hook.   */
  57
  58 static void
  59 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
  60 {
  61   pid_t parent_pid;
  62   struct x86_debug_reg_state *parent_state;
  63   struct x86_debug_reg_state *child_state;
  64
  65   /* NULL means no watchpoint has ever been set in the parent.  In
  66      that case, there's nothing to do.  */
  67   if (parent->arch_private == NULL)
  68     return;
  69
  70   /* Linux kernel before 2.6.33 commit
  71      72f674d203cd230426437cdcf7dd6f681dad8b0d
  72      will inherit hardware debug registers from parent
  73      on fork/vfork/clone.  Newer Linux kernels create such tasks with
  74      zeroed debug registers.
  75
  76      GDB core assumes the child inherits the watchpoints/hw
  77      breakpoints of the parent, and will remove them all from the
  78      forked off process.  Copy the debug registers mirrors into the
  79      new process so that all breakpoints and watchpoints can be
  80      removed together.  The debug registers mirror will become zeroed
  81      in the end before detaching the forked off process, thus making
  82      this compatible with older Linux kernels too.  */
  83
  84   parent_pid = ptid_get_pid (parent->ptid);
  85   parent_state = x86_debug_reg_state (parent_pid);
  86   child_state = x86_debug_reg_state (child_pid);
  87   *child_state = *parent_state;
  88 }
  89 \f
  90
  91 static void (*super_post_startup_inferior) (struct target_ops *self,
  92                                             ptid_t ptid);
  93
  94 static void
  95 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
  96 {
  97   x86_cleanup_dregs ();
  98   super_post_startup_inferior (self, ptid);
  99 }
 100
 101 #ifdef __x86_64__
 102 /* Value of CS segment register:
 103      64bit process: 0x33
 104      32bit process: 0x23  */
 105 #define AMD64_LINUX_USER64_CS 0x33
 106
 107 /* Value of DS segment register:
 108      LP64 process: 0x0
 109      X32 process: 0x2b  */
 110 #define AMD64_LINUX_X32_DS 0x2b
 111 #endif
 112
 113 /* Get Linux/x86 target description from running target.  */
 114
 115 static const struct target_desc *
 116 x86_linux_read_description (struct target_ops *ops)
 117 {
 118   int tid;
 119   int is_64bit = 0;
 120 #ifdef __x86_64__
 121   int is_x32;
 122 #endif
 123   static uint64_t xcr0;
 124   uint64_t xcr0_features_bits;
 125
 126   /* GNU/Linux LWP ID's are process ID's.  */
 127   tid = ptid_get_lwp (inferior_ptid);
 128   if (tid == 0)
 129     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 130
 131 #ifdef __x86_64__
 132   {
 133     unsigned long cs;
 134     unsigned long ds;
 135
 136     /* Get CS register.  */
 137     errno = 0;
 138     cs = ptrace (PTRACE_PEEKUSER, tid,
 139                  offsetof (struct user_regs_struct, cs), 0);
 140     if (errno != 0)
 141       perror_with_name (_("Couldn't get CS register"));
 142
 143     is_64bit = cs == AMD64_LINUX_USER64_CS;
 144
 145     /* Get DS register.  */
 146     errno = 0;
 147     ds = ptrace (PTRACE_PEEKUSER, tid,
 148                  offsetof (struct user_regs_struct, ds), 0);
 149     if (errno != 0)
 150       perror_with_name (_("Couldn't get DS register"));
 151
 152     is_x32 = ds == AMD64_LINUX_X32_DS;
 153
 154     if (sizeof (void *) == 4 && is_64bit && !is_x32)
 155       error (_("Can't debug 64-bit process with 32-bit GDB"));
 156   }
 157 #elif HAVE_PTRACE_GETFPXREGS
 158   if (have_ptrace_getfpxregs == -1)
 159     {
 160       elf_fpxregset_t fpxregs;
 161
 162       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 163         {
 164           have_ptrace_getfpxregs = 0;
 165           have_ptrace_getregset = TRIBOOL_FALSE;
 166           return tdesc_i386_mmx_linux;
 167         }
 168     }
 169 #endif
 170
 171   if (have_ptrace_getregset == TRIBOOL_UNKNOWN)
 172     {
 173       uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 174       struct iovec iov;
 175
 176       iov.iov_base = xstateregs;
 177       iov.iov_len = sizeof (xstateregs);
 178
 179       /* Check if PTRACE_GETREGSET works.  */
 180       if (ptrace (PTRACE_GETREGSET, tid,
 181                   (unsigned int) NT_X86_XSTATE, &iov) < 0)
 182         have_ptrace_getregset = TRIBOOL_FALSE;
 183       else
 184         {
 185           have_ptrace_getregset = TRIBOOL_TRUE;
 186
 187           /* Get XCR0 from XSAVE extended state.  */
 188           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 189                              / sizeof (uint64_t))];
 190         }
 191     }
 192
 193   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  If
 194      PTRACE_GETREGSET is not available then set xcr0_features_bits to
 195      zero so that the "no-features" descriptions are returned by the
 196      switches below.  */
 197   if (have_ptrace_getregset == TRIBOOL_TRUE)
 198     xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
 199   else
 200     xcr0_features_bits = 0;
 201
 202   if (is_64bit)
 203     {
 204 #ifdef __x86_64__
 205       switch (xcr0_features_bits)
 206         {
 207         case X86_XSTATE_AVX_MPX_AVX512_PKU_MASK:
 208           if (is_x32)
 209             /* No MPX, PKU on x32, fall back to AVX-AVX512.  */
 210             return tdesc_x32_avx_avx512_linux;
 211           else
 212             return tdesc_amd64_avx_mpx_avx512_pku_linux;
 213         case X86_XSTATE_AVX_AVX512_MASK:
 214           if (is_x32)
 215             return tdesc_x32_avx_avx512_linux;
 216           else
 217             return tdesc_amd64_avx_avx512_linux;
 218         case X86_XSTATE_MPX_MASK:
 219           if (is_x32)
 220             return tdesc_x32_avx_linux; /* No MPX on x32 using AVX.  */
 221           else
 222             return tdesc_amd64_mpx_linux;
 223         case X86_XSTATE_AVX_MPX_MASK:
 224           if (is_x32)
 225             return tdesc_x32_avx_linux; /* No MPX on x32 using AVX.  */
 226           else
 227             return tdesc_amd64_avx_mpx_linux;
 228         case X86_XSTATE_AVX_MASK:
 229           if (is_x32)
 230             return tdesc_x32_avx_linux;
 231           else
 232             return tdesc_amd64_avx_linux;
 233         default:
 234           if (is_x32)
 235             return tdesc_x32_linux;
 236           else
 237             return tdesc_amd64_linux;
 238         }
 239 #endif
 240     }
 241   else
 242     {
 243       switch (xcr0_features_bits)
 244         {
 245         case X86_XSTATE_AVX_MPX_AVX512_PKU_MASK:
 246           return tdesc_i386_avx_mpx_avx512_pku_linux;
 247         case X86_XSTATE_AVX_AVX512_MASK:
 248           return tdesc_i386_avx_avx512_linux;
 249         case X86_XSTATE_MPX_MASK:
 250           return tdesc_i386_mpx_linux;
 251         case X86_XSTATE_AVX_MPX_MASK:
 252           return tdesc_i386_avx_mpx_linux;
 253         case X86_XSTATE_AVX_MASK:
 254           return tdesc_i386_avx_linux;
 255         default:
 256           return tdesc_i386_linux;
 257         }
 258     }
 259
 260   gdb_assert_not_reached ("failed to return tdesc");
 261 }
 262 \f
 263
 264 /* Enable branch tracing.  */
 265
 266 static struct btrace_target_info *
 267 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
 268                          const struct btrace_config *conf)
 269 {
 270   struct btrace_target_info *tinfo;
 271
 272   errno = 0;
 273   tinfo = linux_enable_btrace (ptid, conf);
 274
 275   if (tinfo == NULL)
 276     error (_("Could not enable branch tracing for %s: %s."),
 277            target_pid_to_str (ptid), safe_strerror (errno));
 278
 279   return tinfo;
 280 }
 281
 282 /* Disable branch tracing.  */
 283
 284 static void
 285 x86_linux_disable_btrace (struct target_ops *self,
 286                           struct btrace_target_info *tinfo)
 287 {
 288   enum btrace_error errcode = linux_disable_btrace (tinfo);
 289
 290   if (errcode != BTRACE_ERR_NONE)
 291     error (_("Could not disable branch tracing."));
 292 }
 293
 294 /* Teardown branch tracing.  */
 295
 296 static void
 297 x86_linux_teardown_btrace (struct target_ops *self,
 298                            struct btrace_target_info *tinfo)
 299 {
 300   /* Ignore errors.  */
 301   linux_disable_btrace (tinfo);
 302 }
 303
 304 static enum btrace_error
 305 x86_linux_read_btrace (struct target_ops *self,
 306                        struct btrace_data *data,
 307                        struct btrace_target_info *btinfo,
 308                        enum btrace_read_type type)
 309 {
 310   return linux_read_btrace (data, btinfo, type);
 311 }
 312
 313 /* See to_btrace_conf in target.h.  */
 314
 315 static const struct btrace_config *
 316 x86_linux_btrace_conf (struct target_ops *self,
 317                        const struct btrace_target_info *btinfo)
 318 {
 319   return linux_btrace_conf (btinfo);
 320 }
 321
 322 \f
 323
 324 /* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
 325    the thread local storage (or its descriptor) and returns PS_OK
 326    on success.  Returns PS_ERR on failure.  */
 327
 328 ps_err_e
 329 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
 330 {
 331   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 332      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 333      4 byte integers in size: `entry_number', `base_addr', `limit',
 334      and a bunch of status bits.
 335
 336      The values returned by this ptrace call should be part of the
 337      regcache buffer, and ps_get_thread_area should channel its
 338      request through the regcache.  That way remote targets could
 339      provide the value using the remote protocol and not this direct
 340      call.
 341
 342      Is this function needed?  I'm guessing that the `base' is the
 343      address of a descriptor that libthread_db uses to find the
 344      thread local address base that GDB needs.  Perhaps that
 345      descriptor is defined by the ABI.  Anyway, given that
 346      libthread_db calls this function without prompting (gdb
 347      requesting tls base) I guess it needs info in there anyway.  */
 348   unsigned int desc[4];
 349
 350   /* This code assumes that "int" is 32 bits and that
 351      GET_THREAD_AREA returns no more than 4 int values.  */
 352   gdb_assert (sizeof (int) == 4);
 353
 354 #ifndef PTRACE_GET_THREAD_AREA
 355 #define PTRACE_GET_THREAD_AREA 25
 356 #endif
 357
 358   if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
 359     return PS_ERR;
 360
 361   *base_addr = desc[1];
 362   return PS_OK;
 363 }
 364 \f
 365
 366 /* Create an x86 GNU/Linux target.  */
 367
 368 struct target_ops *
 369 x86_linux_create_target (void)
 370 {
 371   /* Fill in the generic GNU/Linux methods.  */
 372   struct target_ops *t = linux_target ();
 373
 374   /* Initialize the debug register function vectors.  */
 375   x86_use_watchpoints (t);
 376   x86_dr_low.set_control = x86_linux_dr_set_control;
 377   x86_dr_low.set_addr = x86_linux_dr_set_addr;
 378   x86_dr_low.get_addr = x86_linux_dr_get_addr;
 379   x86_dr_low.get_status = x86_linux_dr_get_status;
 380   x86_dr_low.get_control = x86_linux_dr_get_control;
 381   x86_set_debug_register_length (sizeof (void *));
 382
 383   /* Override the GNU/Linux inferior startup hook.  */
 384   super_post_startup_inferior = t->to_post_startup_inferior;
 385   t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
 386
 387   /* Add the description reader.  */
 388   t->to_read_description = x86_linux_read_description;
 389
 390   /* Add btrace methods.  */
 391   t->to_supports_btrace = linux_supports_btrace;
 392   t->to_enable_btrace = x86_linux_enable_btrace;
 393   t->to_disable_btrace = x86_linux_disable_btrace;
 394   t->to_teardown_btrace = x86_linux_teardown_btrace;
 395   t->to_read_btrace = x86_linux_read_btrace;
 396   t->to_btrace_conf = x86_linux_btrace_conf;
 397
 398   return t;
 399 }
 400
 401 /* Add an x86 GNU/Linux target.  */
 402
 403 void
 404 x86_linux_add_target (struct target_ops *t)
 405 {
 406   linux_nat_add_target (t);
 407   linux_nat_set_new_thread (t, x86_linux_new_thread);
 408   linux_nat_set_new_fork (t, x86_linux_new_fork);
 409   linux_nat_set_forget_process (t, x86_forget_process);
 410   linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
 411 }