1/* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
2
3   Copyright (C) 1999-2020 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 "nat/gdb_ptrace.h"
25#include <sys/user.h>
26#include <sys/procfs.h>
27#include <sys/uio.h>
28
29#include "x86-nat.h"
30#ifndef __x86_64__
31#include "i386-linux-nat.h"
32#endif
33#include "x86-linux-nat.h"
34#include "i386-linux-tdep.h"
35#ifdef __x86_64__
36#include "amd64-linux-tdep.h"
37#endif
38#include "gdbsupport/x86-xstate.h"
39#include "nat/linux-btrace.h"
40#include "nat/linux-nat.h"
41#include "nat/x86-linux.h"
42#include "nat/x86-linux-dregs.h"
43#include "nat/linux-ptrace.h"
44
45/* linux_nat_target::low_new_fork implementation.  */
46
47void
48x86_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid)
49{
50  pid_t parent_pid;
51  struct x86_debug_reg_state *parent_state;
52  struct x86_debug_reg_state *child_state;
53
54  /* NULL means no watchpoint has ever been set in the parent.  In
55     that case, there's nothing to do.  */
56  if (parent->arch_private == NULL)
57    return;
58
59  /* Linux kernel before 2.6.33 commit
60     72f674d203cd230426437cdcf7dd6f681dad8b0d
61     will inherit hardware debug registers from parent
62     on fork/vfork/clone.  Newer Linux kernels create such tasks with
63     zeroed debug registers.
64
65     GDB core assumes the child inherits the watchpoints/hw
66     breakpoints of the parent, and will remove them all from the
67     forked off process.  Copy the debug registers mirrors into the
68     new process so that all breakpoints and watchpoints can be
69     removed together.  The debug registers mirror will become zeroed
70     in the end before detaching the forked off process, thus making
71     this compatible with older Linux kernels too.  */
72
73  parent_pid = parent->ptid.pid ();
74  parent_state = x86_debug_reg_state (parent_pid);
75  child_state = x86_debug_reg_state (child_pid);
76  *child_state = *parent_state;
77}
78
79
80x86_linux_nat_target::~x86_linux_nat_target ()
81{
82}
83
84void
85x86_linux_nat_target::post_startup_inferior (ptid_t ptid)
86{
87  x86_cleanup_dregs ();
88  linux_nat_target::post_startup_inferior (ptid);
89}
90
91#ifdef __x86_64__
92/* Value of CS segment register:
93     64bit process: 0x33
94     32bit process: 0x23  */
95#define AMD64_LINUX_USER64_CS 0x33
96
97/* Value of DS segment register:
98     LP64 process: 0x0
99     X32 process: 0x2b  */
100#define AMD64_LINUX_X32_DS 0x2b
101#endif
102
103/* Get Linux/x86 target description from running target.  */
104
105const struct target_desc *
106x86_linux_nat_target::read_description ()
107{
108  int tid;
109  int is_64bit = 0;
110#ifdef __x86_64__
111  int is_x32;
112#endif
113  static uint64_t xcr0;
114  uint64_t xcr0_features_bits;
115
116  /* GNU/Linux LWP ID's are process ID's.  */
117  tid = inferior_ptid.lwp ();
118  if (tid == 0)
119    tid = inferior_ptid.pid (); /* Not a threaded program.  */
120
121#ifdef __x86_64__
122  {
123    unsigned long cs;
124    unsigned long ds;
125
126    /* Get CS register.  */
127    errno = 0;
128    cs = ptrace (PTRACE_PEEKUSER, tid,
129		 offsetof (struct user_regs_struct, cs), 0);
130    if (errno != 0)
131      perror_with_name (_("Couldn't get CS register"));
132
133    is_64bit = cs == AMD64_LINUX_USER64_CS;
134
135    /* Get DS register.  */
136    errno = 0;
137    ds = ptrace (PTRACE_PEEKUSER, tid,
138		 offsetof (struct user_regs_struct, ds), 0);
139    if (errno != 0)
140      perror_with_name (_("Couldn't get DS register"));
141
142    is_x32 = ds == AMD64_LINUX_X32_DS;
143
144    if (sizeof (void *) == 4 && is_64bit && !is_x32)
145      error (_("Can't debug 64-bit process with 32-bit GDB"));
146  }
147#elif HAVE_PTRACE_GETFPXREGS
148  if (have_ptrace_getfpxregs == -1)
149    {
150      elf_fpxregset_t fpxregs;
151
152      if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
153	{
154	  have_ptrace_getfpxregs = 0;
155	  have_ptrace_getregset = TRIBOOL_FALSE;
156	  return i386_linux_read_description (X86_XSTATE_X87_MASK);
157	}
158    }
159#endif
160
161  if (have_ptrace_getregset == TRIBOOL_UNKNOWN)
162    {
163      uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
164      struct iovec iov;
165
166      iov.iov_base = xstateregs;
167      iov.iov_len = sizeof (xstateregs);
168
169      /* Check if PTRACE_GETREGSET works.  */
170      if (ptrace (PTRACE_GETREGSET, tid,
171		  (unsigned int) NT_X86_XSTATE, &iov) < 0)
172	have_ptrace_getregset = TRIBOOL_FALSE;
173      else
174	{
175	  have_ptrace_getregset = TRIBOOL_TRUE;
176
177	  /* Get XCR0 from XSAVE extended state.  */
178	  xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
179			     / sizeof (uint64_t))];
180	}
181    }
182
183  /* Check the native XCR0 only if PTRACE_GETREGSET is available.  If
184     PTRACE_GETREGSET is not available then set xcr0_features_bits to
185     zero so that the "no-features" descriptions are returned by the
186     switches below.  */
187  if (have_ptrace_getregset == TRIBOOL_TRUE)
188    xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
189  else
190    xcr0_features_bits = 0;
191
192  if (is_64bit)
193    {
194#ifdef __x86_64__
195      return amd64_linux_read_description (xcr0_features_bits, is_x32);
196#endif
197    }
198  else
199    {
200      const struct target_desc * tdesc
201	= i386_linux_read_description (xcr0_features_bits);
202
203      if (tdesc == NULL)
204	tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK);
205
206      return tdesc;
207    }
208
209  gdb_assert_not_reached ("failed to return tdesc");
210}
211
212
213/* Enable branch tracing.  */
214
215struct btrace_target_info *
216x86_linux_nat_target::enable_btrace (ptid_t ptid,
217				     const struct btrace_config *conf)
218{
219  struct btrace_target_info *tinfo = nullptr;
220  try
221    {
222      tinfo = linux_enable_btrace (ptid, conf);
223    }
224  catch (const gdb_exception_error &exception)
225    {
226      error (_("Could not enable branch tracing for %s: %s"),
227	     target_pid_to_str (ptid).c_str (), exception.what ());
228    }
229
230  return tinfo;
231}
232
233/* Disable branch tracing.  */
234
235void
236x86_linux_nat_target::disable_btrace (struct btrace_target_info *tinfo)
237{
238  enum btrace_error errcode = linux_disable_btrace (tinfo);
239
240  if (errcode != BTRACE_ERR_NONE)
241    error (_("Could not disable branch tracing."));
242}
243
244/* Teardown branch tracing.  */
245
246void
247x86_linux_nat_target::teardown_btrace (struct btrace_target_info *tinfo)
248{
249  /* Ignore errors.  */
250  linux_disable_btrace (tinfo);
251}
252
253enum btrace_error
254x86_linux_nat_target::read_btrace (struct btrace_data *data,
255				   struct btrace_target_info *btinfo,
256				   enum btrace_read_type type)
257{
258  return linux_read_btrace (data, btinfo, type);
259}
260
261/* See to_btrace_conf in target.h.  */
262
263const struct btrace_config *
264x86_linux_nat_target::btrace_conf (const struct btrace_target_info *btinfo)
265{
266  return linux_btrace_conf (btinfo);
267}
268
269
270
271/* Helper for ps_get_thread_area.  Sets BASE_ADDR to a pointer to
272   the thread local storage (or its descriptor) and returns PS_OK
273   on success.  Returns PS_ERR on failure.  */
274
275ps_err_e
276x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
277{
278  /* NOTE: cagney/2003-08-26: The definition of this buffer is found
279     in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
280     4 byte integers in size: `entry_number', `base_addr', `limit',
281     and a bunch of status bits.
282
283     The values returned by this ptrace call should be part of the
284     regcache buffer, and ps_get_thread_area should channel its
285     request through the regcache.  That way remote targets could
286     provide the value using the remote protocol and not this direct
287     call.
288
289     Is this function needed?  I'm guessing that the `base' is the
290     address of a descriptor that libthread_db uses to find the
291     thread local address base that GDB needs.  Perhaps that
292     descriptor is defined by the ABI.  Anyway, given that
293     libthread_db calls this function without prompting (gdb
294     requesting tls base) I guess it needs info in there anyway.  */
295  unsigned int desc[4];
296
297  /* This code assumes that "int" is 32 bits and that
298     GET_THREAD_AREA returns no more than 4 int values.  */
299  gdb_assert (sizeof (int) == 4);
300
301#ifndef PTRACE_GET_THREAD_AREA
302#define PTRACE_GET_THREAD_AREA 25
303#endif
304
305  if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
306    return PS_ERR;
307
308  *base_addr = desc[1];
309  return PS_OK;
310}
311
312
313void _initialize_x86_linux_nat ();
314void
315_initialize_x86_linux_nat ()
316{
317  /* Initialize the debug register function vectors.  */
318  x86_dr_low.set_control = x86_linux_dr_set_control;
319  x86_dr_low.set_addr = x86_linux_dr_set_addr;
320  x86_dr_low.get_addr = x86_linux_dr_get_addr;
321  x86_dr_low.get_status = x86_linux_dr_get_status;
322  x86_dr_low.get_control = x86_linux_dr_get_control;
323  x86_set_debug_register_length (sizeof (void *));
324}
325