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