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