gdb/x86-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
   2
   3    Copyright (C) 1999-2015 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 <sys/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
  43 /* Per-thread arch-specific data we want to keep.  */
  44
  45 struct arch_lwp_info
  46 {
  47   /* Non-zero if our copy differs from what's recorded in the thread.  */
  48   int debug_registers_changed;
  49 };
  50
  51 /* Does the current host support PTRACE_GETREGSET?  */
  52 int have_ptrace_getregset = -1;
  53 \f
  54
  55 /* Return the offset of REGNUM in the u_debugreg field of struct
  56    user.  */
  57
  58 static int
  59 u_debugreg_offset (int regnum)
  60 {
  61   return (offsetof (struct user, u_debugreg)
  62           + sizeof (((struct user *) 0)->u_debugreg[0]) * regnum);
  63 }
  64
  65 /* Support for debug registers.  */
  66
  67 /* Get debug register REGNUM value from only the one LWP of PTID.  */
  68
  69 static unsigned long
  70 x86_linux_dr_get (ptid_t ptid, int regnum)
  71 {
  72   int tid;
  73   unsigned long value;
  74
  75   gdb_assert (ptid_lwp_p (ptid));
  76   tid = ptid_get_lwp (ptid);
  77
  78   errno = 0;
  79   value = ptrace (PTRACE_PEEKUSER, tid, u_debugreg_offset (regnum), 0);
  80
  81   if (errno != 0)
  82     perror_with_name (_("Couldn't read debug register"));
  83
  84   return value;
  85 }
  86
  87 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
  88
  89 static void
  90 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
  91 {
  92   int tid;
  93
  94   gdb_assert (ptid_lwp_p (ptid));
  95   tid = ptid_get_lwp (ptid);
  96
  97   errno = 0;
  98   ptrace (PTRACE_POKEUSER, tid, u_debugreg_offset (regnum), value);
  99   if (errno != 0)
 100     perror_with_name (_("Couldn't write debug register"));
 101 }
 102
 103 /* Return the inferior's debug register REGNUM.  */
 104
 105 static CORE_ADDR
 106 x86_linux_dr_get_addr (int regnum)
 107 {
 108   /* DR6 and DR7 are retrieved with some other way.  */
 109   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
 110
 111   return x86_linux_dr_get (current_lwp_ptid (), regnum);
 112 }
 113
 114 /* Return the inferior's DR7 debug control register.  */
 115
 116 static unsigned long
 117 x86_linux_dr_get_control (void)
 118 {
 119   return x86_linux_dr_get (current_lwp_ptid (), DR_CONTROL);
 120 }
 121
 122 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 123
 124 static unsigned long
 125 x86_linux_dr_get_status (void)
 126 {
 127   return x86_linux_dr_get (current_lwp_ptid (), DR_STATUS);
 128 }
 129
 130 /* Callback for iterate_over_lwps.  Update the debug registers of
 131    LWP.  */
 132
 133 static int
 134 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
 135 {
 136   if (lwp->arch_private == NULL)
 137     lwp->arch_private = XCNEW (struct arch_lwp_info);
 138
 139   /* The actual update is done later just before resuming the lwp, we
 140      just mark that the registers need updating.  */
 141   lwp->arch_private->debug_registers_changed = 1;
 142
 143   /* If the lwp isn't stopped, force it to momentarily pause, so we
 144      can update its debug registers.  */
 145   if (!lwp->stopped)
 146     linux_stop_lwp (lwp);
 147
 148   /* Continue the iteration.  */
 149   return 0;
 150 }
 151
 152 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior.  */
 153
 154 static void
 155 x86_linux_dr_set_control (unsigned long control)
 156 {
 157   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
 158
 159   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 160 }
 161
 162 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
 163    inferior.  */
 164
 165 static void
 166 x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 167 {
 168   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
 169
 170   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 171
 172   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 173 }
 174
 175 /* Called when resuming a thread.
 176    If the debug regs have changed, update the thread's copies.  */
 177
 178 static void
 179 x86_linux_prepare_to_resume (struct lwp_info *lwp)
 180 {
 181   int clear_status = 0;
 182
 183   /* NULL means this is the main thread still going through the shell,
 184      or, no watchpoint has been set yet.  In that case, there's
 185      nothing to do.  */
 186   if (lwp->arch_private == NULL)
 187     return;
 188
 189   if (lwp->arch_private->debug_registers_changed)
 190     {
 191       struct x86_debug_reg_state *state
 192         = x86_debug_reg_state (ptid_get_pid (lwp->ptid));
 193       int i;
 194
 195       /* On Linux kernel before 2.6.33 commit
 196          72f674d203cd230426437cdcf7dd6f681dad8b0d
 197          if you enable a breakpoint by the DR_CONTROL bits you need to have
 198          already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
 199
 200          Ensure DR_CONTROL gets written as the very last register here.  */
 201
 202       /* Clear DR_CONTROL first.  In some cases, setting DR0-3 to a
 203          value that doesn't match what is enabled in DR_CONTROL
 204          results in EINVAL.  */
 205       x86_linux_dr_set (lwp->ptid, DR_CONTROL, 0);
 206
 207       ALL_DEBUG_ADDRESS_REGISTERS (i)
 208         if (state->dr_ref_count[i] > 0)
 209           {
 210             x86_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
 211
 212             /* If we're setting a watchpoint, any change the inferior
 213                had done itself to the debug registers needs to be
 214                discarded, otherwise, x86_stopped_data_address can get
 215                confused.  */
 216             clear_status = 1;
 217           }
 218
 219       /* If DR_CONTROL is supposed to be zero, we've already set it
 220          above.  */
 221       if (state->dr_control_mirror != 0)
 222         x86_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
 223
 224       lwp->arch_private->debug_registers_changed = 0;
 225     }
 226
 227   if (clear_status || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
 228     x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
 229 }
 230
 231 static void
 232 x86_linux_new_thread (struct lwp_info *lp)
 233 {
 234   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 235
 236   info->debug_registers_changed = 1;
 237
 238   lp->arch_private = info;
 239 }
 240 \f
 241
 242 /* linux_nat_new_fork hook.   */
 243
 244 static void
 245 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
 246 {
 247   pid_t parent_pid;
 248   struct x86_debug_reg_state *parent_state;
 249   struct x86_debug_reg_state *child_state;
 250
 251   /* NULL means no watchpoint has ever been set in the parent.  In
 252      that case, there's nothing to do.  */
 253   if (parent->arch_private == NULL)
 254     return;
 255
 256   /* Linux kernel before 2.6.33 commit
 257      72f674d203cd230426437cdcf7dd6f681dad8b0d
 258      will inherit hardware debug registers from parent
 259      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 260      zeroed debug registers.
 261
 262      GDB core assumes the child inherits the watchpoints/hw
 263      breakpoints of the parent, and will remove them all from the
 264      forked off process.  Copy the debug registers mirrors into the
 265      new process so that all breakpoints and watchpoints can be
 266      removed together.  The debug registers mirror will become zeroed
 267      in the end before detaching the forked off process, thus making
 268      this compatible with older Linux kernels too.  */
 269
 270   parent_pid = ptid_get_pid (parent->ptid);
 271   parent_state = x86_debug_reg_state (parent_pid);
 272   child_state = x86_debug_reg_state (child_pid);
 273   *child_state = *parent_state;
 274 }
 275 \f
 276
 277 static void (*super_post_startup_inferior) (struct target_ops *self,
 278                                             ptid_t ptid);
 279
 280 static void
 281 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
 282 {
 283   x86_cleanup_dregs ();
 284   super_post_startup_inferior (self, ptid);
 285 }
 286
 287 #ifdef __x86_64__
 288 /* Value of CS segment register:
 289      64bit process: 0x33
 290      32bit process: 0x23  */
 291 #define AMD64_LINUX_USER64_CS 0x33
 292
 293 /* Value of DS segment register:
 294      LP64 process: 0x0
 295      X32 process: 0x2b  */
 296 #define AMD64_LINUX_X32_DS 0x2b
 297 #endif
 298
 299 /* Get Linux/x86 target description from running target.  */
 300
 301 static const struct target_desc *
 302 x86_linux_read_description (struct target_ops *ops)
 303 {
 304   int tid;
 305   int is_64bit = 0;
 306 #ifdef __x86_64__
 307   int is_x32;
 308 #endif
 309   static uint64_t xcr0;
 310   uint64_t xcr0_features_bits;
 311
 312   /* GNU/Linux LWP ID's are process ID's.  */
 313   tid = ptid_get_lwp (inferior_ptid);
 314   if (tid == 0)
 315     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 316
 317 #ifdef __x86_64__
 318   {
 319     unsigned long cs;
 320     unsigned long ds;
 321
 322     /* Get CS register.  */
 323     errno = 0;
 324     cs = ptrace (PTRACE_PEEKUSER, tid,
 325                  offsetof (struct user_regs_struct, cs), 0);
 326     if (errno != 0)
 327       perror_with_name (_("Couldn't get CS register"));
 328
 329     is_64bit = cs == AMD64_LINUX_USER64_CS;
 330
 331     /* Get DS register.  */
 332     errno = 0;
 333     ds = ptrace (PTRACE_PEEKUSER, tid,
 334                  offsetof (struct user_regs_struct, ds), 0);
 335     if (errno != 0)
 336       perror_with_name (_("Couldn't get DS register"));
 337
 338     is_x32 = ds == AMD64_LINUX_X32_DS;
 339
 340     if (sizeof (void *) == 4 && is_64bit && !is_x32)
 341       error (_("Can't debug 64-bit process with 32-bit GDB"));
 342   }
 343 #elif HAVE_PTRACE_GETFPXREGS
 344   if (have_ptrace_getfpxregs == -1)
 345     {
 346       elf_fpxregset_t fpxregs;
 347
 348       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 349         {
 350           have_ptrace_getfpxregs = 0;
 351           have_ptrace_getregset = 0;
 352           return tdesc_i386_mmx_linux;
 353         }
 354     }
 355 #endif
 356
 357   if (have_ptrace_getregset == -1)
 358     {
 359       uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 360       struct iovec iov;
 361
 362       iov.iov_base = xstateregs;
 363       iov.iov_len = sizeof (xstateregs);
 364
 365       /* Check if PTRACE_GETREGSET works.  */
 366       if (ptrace (PTRACE_GETREGSET, tid,
 367                   (unsigned int) NT_X86_XSTATE, &iov) < 0)
 368         have_ptrace_getregset = 0;
 369       else
 370         {
 371           have_ptrace_getregset = 1;
 372
 373           /* Get XCR0 from XSAVE extended state.  */
 374           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 375                              / sizeof (uint64_t))];
 376         }
 377     }
 378
 379   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  If
 380      PTRACE_GETREGSET is not available then set xcr0_features_bits to
 381      zero so that the "no-features" descriptions are returned by the
 382      switches below.  */
 383   if (have_ptrace_getregset)
 384     xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
 385   else
 386     xcr0_features_bits = 0;
 387
 388   if (is_64bit)
 389     {
 390 #ifdef __x86_64__
 391       switch (xcr0_features_bits)
 392         {
 393         case X86_XSTATE_MPX_AVX512_MASK:
 394         case X86_XSTATE_AVX512_MASK:
 395           if (is_x32)
 396             return tdesc_x32_avx512_linux;
 397           else
 398             return tdesc_amd64_avx512_linux;
 399         case X86_XSTATE_MPX_MASK:
 400           if (is_x32)
 401             return tdesc_x32_avx_linux; /* No MPX on x32 using AVX.  */
 402           else
 403             return tdesc_amd64_mpx_linux;
 404         case X86_XSTATE_AVX_MASK:
 405           if (is_x32)
 406             return tdesc_x32_avx_linux;
 407           else
 408             return tdesc_amd64_avx_linux;
 409         default:
 410           if (is_x32)
 411             return tdesc_x32_linux;
 412           else
 413             return tdesc_amd64_linux;
 414         }
 415 #endif
 416     }
 417   else
 418     {
 419       switch (xcr0_features_bits)
 420         {
 421         case X86_XSTATE_MPX_AVX512_MASK:
 422         case X86_XSTATE_AVX512_MASK:
 423           return tdesc_i386_avx512_linux;
 424         case X86_XSTATE_MPX_MASK:
 425           return tdesc_i386_mpx_linux;
 426         case X86_XSTATE_AVX_MASK:
 427           return tdesc_i386_avx_linux;
 428         default:
 429           return tdesc_i386_linux;
 430         }
 431     }
 432
 433   gdb_assert_not_reached ("failed to return tdesc");
 434 }
 435 \f
 436
 437 /* Enable branch tracing.  */
 438
 439 static struct btrace_target_info *
 440 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
 441                          const struct btrace_config *conf)
 442 {
 443   struct btrace_target_info *tinfo;
 444   struct gdbarch *gdbarch;
 445
 446   errno = 0;
 447   tinfo = linux_enable_btrace (ptid, conf);
 448
 449   if (tinfo == NULL)
 450     error (_("Could not enable branch tracing for %s: %s."),
 451            target_pid_to_str (ptid), safe_strerror (errno));
 452
 453   /* Fill in the size of a pointer in bits.  */
 454   if (tinfo->ptr_bits == 0)
 455     {
 456       gdbarch = target_thread_architecture (ptid);
 457       tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
 458     }
 459   return tinfo;
 460 }
 461
 462 /* Disable branch tracing.  */
 463
 464 static void
 465 x86_linux_disable_btrace (struct target_ops *self,
 466                           struct btrace_target_info *tinfo)
 467 {
 468   enum btrace_error errcode = linux_disable_btrace (tinfo);
 469
 470   if (errcode != BTRACE_ERR_NONE)
 471     error (_("Could not disable branch tracing."));
 472 }
 473
 474 /* Teardown branch tracing.  */
 475
 476 static void
 477 x86_linux_teardown_btrace (struct target_ops *self,
 478                            struct btrace_target_info *tinfo)
 479 {
 480   /* Ignore errors.  */
 481   linux_disable_btrace (tinfo);
 482 }
 483
 484 static enum btrace_error
 485 x86_linux_read_btrace (struct target_ops *self,
 486                        struct btrace_data *data,
 487                        struct btrace_target_info *btinfo,
 488                        enum btrace_read_type type)
 489 {
 490   return linux_read_btrace (data, btinfo, type);
 491 }
 492
 493 /* See to_btrace_conf in target.h.  */
 494
 495 static const struct btrace_config *
 496 x86_linux_btrace_conf (struct target_ops *self,
 497                        const struct btrace_target_info *btinfo)
 498 {
 499   return linux_btrace_conf (btinfo);
 500 }
 501
 502 \f
 503
 504 /* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
 505    the thread local storage (or its descriptor) and returns PS_OK
 506    on success.  Returns PS_ERR on failure.  */
 507
 508 ps_err_e
 509 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
 510 {
 511   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 512      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 513      4 byte integers in size: `entry_number', `base_addr', `limit',
 514      and a bunch of status bits.
 515
 516      The values returned by this ptrace call should be part of the
 517      regcache buffer, and ps_get_thread_area should channel its
 518      request through the regcache.  That way remote targets could
 519      provide the value using the remote protocol and not this direct
 520      call.
 521
 522      Is this function needed?  I'm guessing that the `base' is the
 523      address of a descriptor that libthread_db uses to find the
 524      thread local address base that GDB needs.  Perhaps that
 525      descriptor is defined by the ABI.  Anyway, given that
 526      libthread_db calls this function without prompting (gdb
 527      requesting tls base) I guess it needs info in there anyway.  */
 528   unsigned int desc[4];
 529
 530   /* This code assumes that "int" is 32 bits and that
 531      GET_THREAD_AREA returns no more than 4 int values.  */
 532   gdb_assert (sizeof (int) == 4);
 533
 534 #ifndef PTRACE_GET_THREAD_AREA
 535 #define PTRACE_GET_THREAD_AREA 25
 536 #endif
 537
 538   if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
 539     return PS_ERR;
 540
 541   *base_addr = desc[1];
 542   return PS_OK;
 543 }
 544 \f
 545
 546 /* Create an x86 GNU/Linux target.  */
 547
 548 struct target_ops *
 549 x86_linux_create_target (void)
 550 {
 551   /* Fill in the generic GNU/Linux methods.  */
 552   struct target_ops *t = linux_target ();
 553
 554   /* Initialize the debug register function vectors.  */
 555   x86_use_watchpoints (t);
 556   x86_dr_low.set_control = x86_linux_dr_set_control;
 557   x86_dr_low.set_addr = x86_linux_dr_set_addr;
 558   x86_dr_low.get_addr = x86_linux_dr_get_addr;
 559   x86_dr_low.get_status = x86_linux_dr_get_status;
 560   x86_dr_low.get_control = x86_linux_dr_get_control;
 561   x86_set_debug_register_length (sizeof (void *));
 562
 563   /* Override the GNU/Linux inferior startup hook.  */
 564   super_post_startup_inferior = t->to_post_startup_inferior;
 565   t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
 566
 567   /* Add the description reader.  */
 568   t->to_read_description = x86_linux_read_description;
 569
 570   /* Add btrace methods.  */
 571   t->to_supports_btrace = linux_supports_btrace;
 572   t->to_enable_btrace = x86_linux_enable_btrace;
 573   t->to_disable_btrace = x86_linux_disable_btrace;
 574   t->to_teardown_btrace = x86_linux_teardown_btrace;
 575   t->to_read_btrace = x86_linux_read_btrace;
 576   t->to_btrace_conf = x86_linux_btrace_conf;
 577
 578   return t;
 579 }
 580
 581 /* Add an x86 GNU/Linux target.  */
 582
 583 void
 584 x86_linux_add_target (struct target_ops *t)
 585 {
 586   linux_nat_add_target (t);
 587   linux_nat_set_new_thread (t, x86_linux_new_thread);
 588   linux_nat_set_new_fork (t, x86_linux_new_fork);
 589   linux_nat_set_forget_process (t, x86_forget_process);
 590   linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
 591 }