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