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 /* Support for debug registers.  */
  55
  56 /* Get debug register REGNUM value from only the one LWP of PTID.  */
  57
  58 static unsigned long
  59 x86_linux_dr_get (ptid_t ptid, int regnum)
  60 {
  61   int tid;
  62   unsigned long value;
  63
  64   gdb_assert (ptid_lwp_p (ptid));
  65   tid = ptid_get_lwp (ptid);
  66
  67   errno = 0;
  68   value = ptrace (PTRACE_PEEKUSER, tid,
  69                   offsetof (struct user, u_debugreg[regnum]), 0);
  70   if (errno != 0)
  71     perror_with_name (_("Couldn't read debug register"));
  72
  73   return value;
  74 }
  75
  76 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
  77
  78 static void
  79 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
  80 {
  81   int tid;
  82
  83   gdb_assert (ptid_lwp_p (ptid));
  84   tid = ptid_get_lwp (ptid);
  85
  86   errno = 0;
  87   ptrace (PTRACE_POKEUSER, tid,
  88           offsetof (struct user, u_debugreg[regnum]), value);
  89   if (errno != 0)
  90     perror_with_name (_("Couldn't write debug register"));
  91 }
  92
  93 /* Return the inferior's debug register REGNUM.  */
  94
  95 static CORE_ADDR
  96 x86_linux_dr_get_addr (int regnum)
  97 {
  98   /* DR6 and DR7 are retrieved with some other way.  */
  99   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
 100
 101   return x86_linux_dr_get (inferior_ptid, regnum);
 102 }
 103
 104 /* Return the inferior's DR7 debug control register.  */
 105
 106 static unsigned long
 107 x86_linux_dr_get_control (void)
 108 {
 109   return x86_linux_dr_get (inferior_ptid, DR_CONTROL);
 110 }
 111
 112 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 113
 114 static unsigned long
 115 x86_linux_dr_get_status (void)
 116 {
 117   return x86_linux_dr_get (inferior_ptid, DR_STATUS);
 118 }
 119
 120 /* Callback for iterate_over_lwps.  Update the debug registers of
 121    LWP.  */
 122
 123 static int
 124 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
 125 {
 126   if (lwp->arch_private == NULL)
 127     lwp->arch_private = XCNEW (struct arch_lwp_info);
 128
 129   /* The actual update is done later just before resuming the lwp, we
 130      just mark that the registers need updating.  */
 131   lwp->arch_private->debug_registers_changed = 1;
 132
 133   /* If the lwp isn't stopped, force it to momentarily pause, so we
 134      can update its debug registers.  */
 135   if (!lwp->stopped)
 136     linux_stop_lwp (lwp);
 137
 138   /* Continue the iteration.  */
 139   return 0;
 140 }
 141
 142 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior.  */
 143
 144 static void
 145 x86_linux_dr_set_control (unsigned long control)
 146 {
 147   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 148
 149   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 150 }
 151
 152 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
 153    inferior.  */
 154
 155 static void
 156 x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 157 {
 158   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 159
 160   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 161
 162   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 163 }
 164
 165 /* Called when resuming a thread.
 166    If the debug regs have changed, update the thread's copies.  */
 167
 168 static void
 169 x86_linux_prepare_to_resume (struct lwp_info *lwp)
 170 {
 171   int clear_status = 0;
 172
 173   /* NULL means this is the main thread still going through the shell,
 174      or, no watchpoint has been set yet.  In that case, there's
 175      nothing to do.  */
 176   if (lwp->arch_private == NULL)
 177     return;
 178
 179   if (lwp->arch_private->debug_registers_changed)
 180     {
 181       struct x86_debug_reg_state *state
 182         = x86_debug_reg_state (ptid_get_pid (lwp->ptid));
 183       int i;
 184
 185       /* On Linux kernel before 2.6.33 commit
 186          72f674d203cd230426437cdcf7dd6f681dad8b0d
 187          if you enable a breakpoint by the DR_CONTROL bits you need to have
 188          already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
 189
 190          Ensure DR_CONTROL gets written as the very last register here.  */
 191
 192       /* Clear DR_CONTROL first.  In some cases, setting DR0-3 to a
 193          value that doesn't match what is enabled in DR_CONTROL
 194          results in EINVAL.  */
 195       x86_linux_dr_set (lwp->ptid, DR_CONTROL, 0);
 196
 197       ALL_DEBUG_ADDRESS_REGISTERS (i)
 198         if (state->dr_ref_count[i] > 0)
 199           {
 200             x86_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
 201
 202             /* If we're setting a watchpoint, any change the inferior
 203                had done itself to the debug registers needs to be
 204                discarded, otherwise, x86_stopped_data_address can get
 205                confused.  */
 206             clear_status = 1;
 207           }
 208
 209       /* If DR_CONTROL is supposed to be zero, we've already set it
 210          above.  */
 211       if (state->dr_control_mirror != 0)
 212         x86_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
 213
 214       lwp->arch_private->debug_registers_changed = 0;
 215     }
 216
 217   if (clear_status || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
 218     x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
 219 }
 220
 221 static void
 222 x86_linux_new_thread (struct lwp_info *lp)
 223 {
 224   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 225
 226   info->debug_registers_changed = 1;
 227
 228   lp->arch_private = info;
 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   gdbarch = target_thread_architecture (ptid);
 445   tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
 446
 447   return tinfo;
 448 }
 449
 450 /* Disable branch tracing.  */
 451
 452 static void
 453 x86_linux_disable_btrace (struct target_ops *self,
 454                           struct btrace_target_info *tinfo)
 455 {
 456   enum btrace_error errcode = linux_disable_btrace (tinfo);
 457
 458   if (errcode != BTRACE_ERR_NONE)
 459     error (_("Could not disable branch tracing."));
 460 }
 461
 462 /* Teardown branch tracing.  */
 463
 464 static void
 465 x86_linux_teardown_btrace (struct target_ops *self,
 466                            struct btrace_target_info *tinfo)
 467 {
 468   /* Ignore errors.  */
 469   linux_disable_btrace (tinfo);
 470 }
 471
 472 static enum btrace_error
 473 x86_linux_read_btrace (struct target_ops *self,
 474                        struct btrace_data *data,
 475                        struct btrace_target_info *btinfo,
 476                        enum btrace_read_type type)
 477 {
 478   return linux_read_btrace (data, btinfo, type);
 479 }
 480
 481 /* See to_btrace_conf in target.h.  */
 482
 483 static const struct btrace_config *
 484 x86_linux_btrace_conf (struct target_ops *self,
 485                        const struct btrace_target_info *btinfo)
 486 {
 487   return linux_btrace_conf (btinfo);
 488 }
 489
 490 \f
 491
 492 /* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
 493    the thread local storage (or its descriptor) and returns PS_OK
 494    on success.  Returns PS_ERR on failure.  */
 495
 496 ps_err_e
 497 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
 498 {
 499   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 500      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 501      4 byte integers in size: `entry_number', `base_addr', `limit',
 502      and a bunch of status bits.
 503
 504      The values returned by this ptrace call should be part of the
 505      regcache buffer, and ps_get_thread_area should channel its
 506      request through the regcache.  That way remote targets could
 507      provide the value using the remote protocol and not this direct
 508      call.
 509
 510      Is this function needed?  I'm guessing that the `base' is the
 511      address of a descriptor that libthread_db uses to find the
 512      thread local address base that GDB needs.  Perhaps that
 513      descriptor is defined by the ABI.  Anyway, given that
 514      libthread_db calls this function without prompting (gdb
 515      requesting tls base) I guess it needs info in there anyway.  */
 516   unsigned int desc[4];
 517
 518   /* This code assumes that "int" is 32 bits and that
 519      GET_THREAD_AREA returns no more than 4 int values.  */
 520   gdb_assert (sizeof (int) == 4);
 521
 522 #ifndef PTRACE_GET_THREAD_AREA
 523 #define PTRACE_GET_THREAD_AREA 25
 524 #endif
 525
 526   if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
 527     return PS_ERR;
 528
 529   *base_addr = desc[1];
 530   return PS_OK;
 531 }
 532 \f
 533
 534 /* Create an x86 GNU/Linux target.  */
 535
 536 struct target_ops *
 537 x86_linux_create_target (void)
 538 {
 539   /* Fill in the generic GNU/Linux methods.  */
 540   struct target_ops *t = linux_target ();
 541
 542   /* Initialize the debug register function vectors.  */
 543   x86_use_watchpoints (t);
 544   x86_dr_low.set_control = x86_linux_dr_set_control;
 545   x86_dr_low.set_addr = x86_linux_dr_set_addr;
 546   x86_dr_low.get_addr = x86_linux_dr_get_addr;
 547   x86_dr_low.get_status = x86_linux_dr_get_status;
 548   x86_dr_low.get_control = x86_linux_dr_get_control;
 549   x86_set_debug_register_length (sizeof (void *));
 550
 551   /* Override the GNU/Linux inferior startup hook.  */
 552   super_post_startup_inferior = t->to_post_startup_inferior;
 553   t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
 554
 555   /* Add the description reader.  */
 556   t->to_read_description = x86_linux_read_description;
 557
 558   /* Add btrace methods.  */
 559   t->to_supports_btrace = linux_supports_btrace;
 560   t->to_enable_btrace = x86_linux_enable_btrace;
 561   t->to_disable_btrace = x86_linux_disable_btrace;
 562   t->to_teardown_btrace = x86_linux_teardown_btrace;
 563   t->to_read_btrace = x86_linux_read_btrace;
 564   t->to_btrace_conf = x86_linux_btrace_conf;
 565
 566   return t;
 567 }
 568
 569 /* Add an x86 GNU/Linux target.  */
 570
 571 void
 572 x86_linux_add_target (struct target_ops *t)
 573 {
 574   linux_nat_add_target (t);
 575   linux_nat_set_new_thread (t, x86_linux_new_thread);
 576   linux_nat_set_new_fork (t, x86_linux_new_fork);
 577   linux_nat_set_forget_process (t, x86_forget_process);
 578   linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
 579 }