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