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