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 /* Update the thread's debug registers if the values in our local
 175    mirror have been changed.  */
 176
 177 static void
 178 x86_linux_update_debug_registers (struct lwp_info *lwp)
 179 {
 180   ptid_t ptid = ptid_of_lwp (lwp);
 181   int clear_status = 0;
 182
 183   gdb_assert (lwp_is_stopped (lwp));
 184
 185   if (lwp_debug_registers_changed (lwp))
 186     {
 187       struct x86_debug_reg_state *state
 188         = x86_debug_reg_state (ptid_get_pid (ptid));
 189       int i;
 190
 191       /* Prior to Linux kernel 2.6.33 commit
 192          72f674d203cd230426437cdcf7dd6f681dad8b0d, setting DR0-3 to
 193          a value that did not match what was enabled in DR_CONTROL
 194          resulted in EINVAL.  To avoid this we zero DR_CONTROL before
 195          writing address registers, only writing DR_CONTROL's actual
 196          value once all the addresses are in place.  */
 197       x86_linux_dr_set (ptid, DR_CONTROL, 0);
 198
 199       ALL_DEBUG_ADDRESS_REGISTERS (i)
 200         if (state->dr_ref_count[i] > 0)
 201           {
 202             x86_linux_dr_set (ptid, i, state->dr_mirror[i]);
 203
 204             /* If we're setting a watchpoint, any change the inferior
 205                has made to its debug registers needs to be discarded
 206                to avoid x86_stopped_data_address getting confused.  */
 207             clear_status = 1;
 208           }
 209
 210       /* If DR_CONTROL is supposed to be zero then it's already set.  */
 211       if (state->dr_control_mirror != 0)
 212         x86_linux_dr_set (ptid, DR_CONTROL, state->dr_control_mirror);
 213
 214       lwp_set_debug_registers_changed (lwp, 0);
 215     }
 216
 217   if (clear_status
 218       || lwp_stop_reason (lwp) == TARGET_STOPPED_BY_WATCHPOINT)
 219     x86_linux_dr_set (ptid, DR_STATUS, 0);
 220 }
 221
 222 /* Called prior to resuming a thread.  */
 223
 224 static void
 225 x86_linux_prepare_to_resume (struct lwp_info *lwp)
 226 {
 227   x86_linux_update_debug_registers (lwp);
 228 }
 229
 230 /* Called when a new thread is detected.  */
 231
 232 static void
 233 x86_linux_new_thread (struct lwp_info *lwp)
 234 {
 235   lwp_set_debug_registers_changed (lwp, 1);
 236 }
 237 \f
 238
 239 /* linux_nat_new_fork hook.   */
 240
 241 static void
 242 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
 243 {
 244   pid_t parent_pid;
 245   struct x86_debug_reg_state *parent_state;
 246   struct x86_debug_reg_state *child_state;
 247
 248   /* NULL means no watchpoint has ever been set in the parent.  In
 249      that case, there's nothing to do.  */
 250   if (parent->arch_private == NULL)
 251     return;
 252
 253   /* Linux kernel before 2.6.33 commit
 254      72f674d203cd230426437cdcf7dd6f681dad8b0d
 255      will inherit hardware debug registers from parent
 256      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 257      zeroed debug registers.
 258
 259      GDB core assumes the child inherits the watchpoints/hw
 260      breakpoints of the parent, and will remove them all from the
 261      forked off process.  Copy the debug registers mirrors into the
 262      new process so that all breakpoints and watchpoints can be
 263      removed together.  The debug registers mirror will become zeroed
 264      in the end before detaching the forked off process, thus making
 265      this compatible with older Linux kernels too.  */
 266
 267   parent_pid = ptid_get_pid (parent->ptid);
 268   parent_state = x86_debug_reg_state (parent_pid);
 269   child_state = x86_debug_reg_state (child_pid);
 270   *child_state = *parent_state;
 271 }
 272 \f
 273
 274 static void (*super_post_startup_inferior) (struct target_ops *self,
 275                                             ptid_t ptid);
 276
 277 static void
 278 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
 279 {
 280   x86_cleanup_dregs ();
 281   super_post_startup_inferior (self, ptid);
 282 }
 283
 284 #ifdef __x86_64__
 285 /* Value of CS segment register:
 286      64bit process: 0x33
 287      32bit process: 0x23  */
 288 #define AMD64_LINUX_USER64_CS 0x33
 289
 290 /* Value of DS segment register:
 291      LP64 process: 0x0
 292      X32 process: 0x2b  */
 293 #define AMD64_LINUX_X32_DS 0x2b
 294 #endif
 295
 296 /* Get Linux/x86 target description from running target.  */
 297
 298 static const struct target_desc *
 299 x86_linux_read_description (struct target_ops *ops)
 300 {
 301   int tid;
 302   int is_64bit = 0;
 303 #ifdef __x86_64__
 304   int is_x32;
 305 #endif
 306   static uint64_t xcr0;
 307   uint64_t xcr0_features_bits;
 308
 309   /* GNU/Linux LWP ID's are process ID's.  */
 310   tid = ptid_get_lwp (inferior_ptid);
 311   if (tid == 0)
 312     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 313
 314 #ifdef __x86_64__
 315   {
 316     unsigned long cs;
 317     unsigned long ds;
 318
 319     /* Get CS register.  */
 320     errno = 0;
 321     cs = ptrace (PTRACE_PEEKUSER, tid,
 322                  offsetof (struct user_regs_struct, cs), 0);
 323     if (errno != 0)
 324       perror_with_name (_("Couldn't get CS register"));
 325
 326     is_64bit = cs == AMD64_LINUX_USER64_CS;
 327
 328     /* Get DS register.  */
 329     errno = 0;
 330     ds = ptrace (PTRACE_PEEKUSER, tid,
 331                  offsetof (struct user_regs_struct, ds), 0);
 332     if (errno != 0)
 333       perror_with_name (_("Couldn't get DS register"));
 334
 335     is_x32 = ds == AMD64_LINUX_X32_DS;
 336
 337     if (sizeof (void *) == 4 && is_64bit && !is_x32)
 338       error (_("Can't debug 64-bit process with 32-bit GDB"));
 339   }
 340 #elif HAVE_PTRACE_GETFPXREGS
 341   if (have_ptrace_getfpxregs == -1)
 342     {
 343       elf_fpxregset_t fpxregs;
 344
 345       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 346         {
 347           have_ptrace_getfpxregs = 0;
 348           have_ptrace_getregset = 0;
 349           return tdesc_i386_mmx_linux;
 350         }
 351     }
 352 #endif
 353
 354   if (have_ptrace_getregset == -1)
 355     {
 356       uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 357       struct iovec iov;
 358
 359       iov.iov_base = xstateregs;
 360       iov.iov_len = sizeof (xstateregs);
 361
 362       /* Check if PTRACE_GETREGSET works.  */
 363       if (ptrace (PTRACE_GETREGSET, tid,
 364                   (unsigned int) NT_X86_XSTATE, &iov) < 0)
 365         have_ptrace_getregset = 0;
 366       else
 367         {
 368           have_ptrace_getregset = 1;
 369
 370           /* Get XCR0 from XSAVE extended state.  */
 371           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 372                              / sizeof (uint64_t))];
 373         }
 374     }
 375
 376   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  If
 377      PTRACE_GETREGSET is not available then set xcr0_features_bits to
 378      zero so that the "no-features" descriptions are returned by the
 379      switches below.  */
 380   if (have_ptrace_getregset)
 381     xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
 382   else
 383     xcr0_features_bits = 0;
 384
 385   if (is_64bit)
 386     {
 387 #ifdef __x86_64__
 388       switch (xcr0_features_bits)
 389         {
 390         case X86_XSTATE_MPX_AVX512_MASK:
 391         case X86_XSTATE_AVX512_MASK:
 392           if (is_x32)
 393             return tdesc_x32_avx512_linux;
 394           else
 395             return tdesc_amd64_avx512_linux;
 396         case X86_XSTATE_MPX_MASK:
 397           if (is_x32)
 398             return tdesc_x32_avx_linux; /* No MPX on x32 using AVX.  */
 399           else
 400             return tdesc_amd64_mpx_linux;
 401         case X86_XSTATE_AVX_MASK:
 402           if (is_x32)
 403             return tdesc_x32_avx_linux;
 404           else
 405             return tdesc_amd64_avx_linux;
 406         default:
 407           if (is_x32)
 408             return tdesc_x32_linux;
 409           else
 410             return tdesc_amd64_linux;
 411         }
 412 #endif
 413     }
 414   else
 415     {
 416       switch (xcr0_features_bits)
 417         {
 418         case X86_XSTATE_MPX_AVX512_MASK:
 419         case X86_XSTATE_AVX512_MASK:
 420           return tdesc_i386_avx512_linux;
 421         case X86_XSTATE_MPX_MASK:
 422           return tdesc_i386_mpx_linux;
 423         case X86_XSTATE_AVX_MASK:
 424           return tdesc_i386_avx_linux;
 425         default:
 426           return tdesc_i386_linux;
 427         }
 428     }
 429
 430   gdb_assert_not_reached ("failed to return tdesc");
 431 }
 432 \f
 433
 434 /* Enable branch tracing.  */
 435
 436 static struct btrace_target_info *
 437 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
 438                          const struct btrace_config *conf)
 439 {
 440   struct btrace_target_info *tinfo;
 441   struct gdbarch *gdbarch;
 442
 443   errno = 0;
 444   tinfo = linux_enable_btrace (ptid, conf);
 445
 446   if (tinfo == NULL)
 447     error (_("Could not enable branch tracing for %s: %s."),
 448            target_pid_to_str (ptid), safe_strerror (errno));
 449
 450   /* Fill in the size of a pointer in bits.  */
 451   if (tinfo->ptr_bits == 0)
 452     {
 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 }