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 == LWP_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   gdbarch = target_thread_architecture (ptid);
 454   tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
 455
 456   return tinfo;
 457 }
 458
 459 /* Disable branch tracing.  */
 460
 461 static void
 462 x86_linux_disable_btrace (struct target_ops *self,
 463                           struct btrace_target_info *tinfo)
 464 {
 465   enum btrace_error errcode = linux_disable_btrace (tinfo);
 466
 467   if (errcode != BTRACE_ERR_NONE)
 468     error (_("Could not disable branch tracing."));
 469 }
 470
 471 /* Teardown branch tracing.  */
 472
 473 static void
 474 x86_linux_teardown_btrace (struct target_ops *self,
 475                            struct btrace_target_info *tinfo)
 476 {
 477   /* Ignore errors.  */
 478   linux_disable_btrace (tinfo);
 479 }
 480
 481 static enum btrace_error
 482 x86_linux_read_btrace (struct target_ops *self,
 483                        struct btrace_data *data,
 484                        struct btrace_target_info *btinfo,
 485                        enum btrace_read_type type)
 486 {
 487   return linux_read_btrace (data, btinfo, type);
 488 }
 489
 490 /* See to_btrace_conf in target.h.  */
 491
 492 static const struct btrace_config *
 493 x86_linux_btrace_conf (struct target_ops *self,
 494                        const struct btrace_target_info *btinfo)
 495 {
 496   return linux_btrace_conf (btinfo);
 497 }
 498
 499 \f
 500
 501 /* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
 502    the thread local storage (or its descriptor) and returns PS_OK
 503    on success.  Returns PS_ERR on failure.  */
 504
 505 ps_err_e
 506 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
 507 {
 508   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 509      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 510      4 byte integers in size: `entry_number', `base_addr', `limit',
 511      and a bunch of status bits.
 512
 513      The values returned by this ptrace call should be part of the
 514      regcache buffer, and ps_get_thread_area should channel its
 515      request through the regcache.  That way remote targets could
 516      provide the value using the remote protocol and not this direct
 517      call.
 518
 519      Is this function needed?  I'm guessing that the `base' is the
 520      address of a descriptor that libthread_db uses to find the
 521      thread local address base that GDB needs.  Perhaps that
 522      descriptor is defined by the ABI.  Anyway, given that
 523      libthread_db calls this function without prompting (gdb
 524      requesting tls base) I guess it needs info in there anyway.  */
 525   unsigned int desc[4];
 526
 527   /* This code assumes that "int" is 32 bits and that
 528      GET_THREAD_AREA returns no more than 4 int values.  */
 529   gdb_assert (sizeof (int) == 4);
 530
 531 #ifndef PTRACE_GET_THREAD_AREA
 532 #define PTRACE_GET_THREAD_AREA 25
 533 #endif
 534
 535   if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
 536     return PS_ERR;
 537
 538   *base_addr = desc[1];
 539   return PS_OK;
 540 }
 541 \f
 542
 543 /* Create an x86 GNU/Linux target.  */
 544
 545 struct target_ops *
 546 x86_linux_create_target (void)
 547 {
 548   /* Fill in the generic GNU/Linux methods.  */
 549   struct target_ops *t = linux_target ();
 550
 551   /* Initialize the debug register function vectors.  */
 552   x86_use_watchpoints (t);
 553   x86_dr_low.set_control = x86_linux_dr_set_control;
 554   x86_dr_low.set_addr = x86_linux_dr_set_addr;
 555   x86_dr_low.get_addr = x86_linux_dr_get_addr;
 556   x86_dr_low.get_status = x86_linux_dr_get_status;
 557   x86_dr_low.get_control = x86_linux_dr_get_control;
 558   x86_set_debug_register_length (sizeof (void *));
 559
 560   /* Override the GNU/Linux inferior startup hook.  */
 561   super_post_startup_inferior = t->to_post_startup_inferior;
 562   t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
 563
 564   /* Add the description reader.  */
 565   t->to_read_description = x86_linux_read_description;
 566
 567   /* Add btrace methods.  */
 568   t->to_supports_btrace = linux_supports_btrace;
 569   t->to_enable_btrace = x86_linux_enable_btrace;
 570   t->to_disable_btrace = x86_linux_disable_btrace;
 571   t->to_teardown_btrace = x86_linux_teardown_btrace;
 572   t->to_read_btrace = x86_linux_read_btrace;
 573   t->to_btrace_conf = x86_linux_btrace_conf;
 574
 575   return t;
 576 }
 577
 578 /* Add an x86 GNU/Linux target.  */
 579
 580 void
 581 x86_linux_add_target (struct target_ops *t)
 582 {
 583   linux_nat_add_target (t);
 584   linux_nat_set_new_thread (t, x86_linux_new_thread);
 585   linux_nat_set_new_fork (t, x86_linux_new_fork);
 586   linux_nat_set_forget_process (t, x86_forget_process);
 587   linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
 588 }