gdb/x86-linux-nat.c

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