| /* Native-dependent code for GNU/Linux x86 (i386 and x86-64). | |
| Copyright (C) 1999-2026 Free Software Foundation, Inc. | |
| This file is part of GDB. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
| #include "elf/common.h" | |
| #include "nat/gdb_ptrace.h" | |
| #include "nat/linux-ptrace.h" | |
| #include "nat/x86-cpuid.h" | |
| #include <sys/uio.h> | |
| #include "x86-linux.h" | |
| #include "x86-linux-dregs.h" | |
| #include "nat/gdb_ptrace.h" | |
| #include <sys/user.h> | |
| #ifndef __x86_64__ | |
| #include "nat/i386-linux.h" | |
| #else | |
| #include "nat/amd64-linux.h" | |
| #endif | |
| /* Per-thread arch-specific data we want to keep. */ | |
| struct arch_lwp_info | |
| { | |
| /* Non-zero if our copy differs from what's recorded in the | |
| thread. */ | |
| int debug_registers_changed; | |
| }; | |
| /* See nat/x86-linux.h. */ | |
| void | |
| lwp_set_debug_registers_changed (struct lwp_info *lwp, int value) | |
| { | |
| if (lwp_arch_private_info (lwp) == NULL) | |
| lwp_set_arch_private_info (lwp, XCNEW (struct arch_lwp_info)); | |
| lwp_arch_private_info (lwp)->debug_registers_changed = value; | |
| } | |
| /* See nat/x86-linux.h. */ | |
| int | |
| lwp_debug_registers_changed (struct lwp_info *lwp) | |
| { | |
| struct arch_lwp_info *info = lwp_arch_private_info (lwp); | |
| /* NULL means either that this is the main thread still going | |
| through the shell, or that no watchpoint has been set yet. | |
| The debug registers are unchanged in either case. */ | |
| if (info == NULL) | |
| return 0; | |
| return info->debug_registers_changed; | |
| } | |
| /* See nat/x86-linux.h. */ | |
| void | |
| x86_linux_new_thread (struct lwp_info *lwp) | |
| { | |
| lwp_set_debug_registers_changed (lwp, 1); | |
| } | |
| /* See nat/x86-linux.h. */ | |
| void | |
| x86_linux_delete_thread (struct arch_lwp_info *arch_lwp) | |
| { | |
| xfree (arch_lwp); | |
| } | |
| /* See nat/x86-linux.h. */ | |
| void | |
| x86_linux_prepare_to_resume (struct lwp_info *lwp) | |
| { | |
| x86_linux_update_debug_registers (lwp); | |
| } | |
| #ifdef __x86_64__ | |
| /* Value of CS segment register: | |
| 64bit process: 0x33 | |
| 32bit process: 0x23 */ | |
| #define AMD64_LINUX_USER64_CS 0x33 | |
| /* Value of DS segment register: | |
| LP64 process: 0x0 | |
| X32 process: 0x2b */ | |
| #define AMD64_LINUX_X32_DS 0x2b | |
| #endif | |
| /* See nat/x86-linux.h. */ | |
| x86_linux_arch_size | |
| x86_linux_ptrace_get_arch_size (int tid) | |
| { | |
| #ifdef __x86_64__ | |
| unsigned long cs; | |
| unsigned long ds; | |
| /* Get CS register. */ | |
| errno = 0; | |
| cs = ptrace (PTRACE_PEEKUSER, tid, | |
| offsetof (struct user_regs_struct, cs), 0); | |
| if (errno != 0) | |
| perror_with_name (_("Couldn't get CS register")); | |
| bool is_64bit = cs == AMD64_LINUX_USER64_CS; | |
| /* Get DS register. */ | |
| errno = 0; | |
| ds = ptrace (PTRACE_PEEKUSER, tid, | |
| offsetof (struct user_regs_struct, ds), 0); | |
| if (errno != 0) | |
| perror_with_name (_("Couldn't get DS register")); | |
| bool is_x32 = ds == AMD64_LINUX_X32_DS; | |
| return x86_linux_arch_size (is_64bit, is_x32); | |
| #else | |
| return x86_linux_arch_size (false, false); | |
| #endif | |
| } | |
| /* See nat/x86-linux.h. */ | |
| bool | |
| x86_check_ssp_support (const int tid) | |
| { | |
| /* It's not enough to check shadow stack support with the ptrace call | |
| below only, as we cannot distinguish between shadow stack not enabled | |
| for the current thread and shadow stack is not supported by HW. In | |
| both scenarios the ptrace call fails with ENODEV. In case shadow | |
| stack is not enabled for the current thread, we still want to return | |
| true. */ | |
| unsigned int eax, ebx, ecx, edx; | |
| eax = ebx = ecx = edx = 0; | |
| if (!__get_cpuid_count (7, 0, &eax, &ebx, &ecx, &edx)) | |
| return false; | |
| if ((ecx & bit_SHSTK) == 0) | |
| return false; | |
| /* Further check for NT_X86_SHSTK kernel support. */ | |
| uint64_t ssp; | |
| iovec iov {&ssp, sizeof (ssp) }; | |
| errno = 0; | |
| int res = ptrace (PTRACE_GETREGSET, tid, NT_X86_SHSTK, &iov); | |
| if (res < 0) | |
| { | |
| if (errno == EINVAL) | |
| { | |
| /* The errno EINVAL for a PTRACE_GETREGSET call indicates that | |
| kernel support is not available. */ | |
| return false; | |
| } | |
| else if (errno == ENODEV) | |
| { | |
| /* At this point, since we already checked CPUID, the errno | |
| ENODEV for a PTRACE_GETREGSET call indicates that shadow | |
| stack is not enabled for the current thread. As it could be | |
| enabled later, we still want to return true here. */ | |
| return true; | |
| } | |
| else | |
| { | |
| warning (_("Unknown ptrace error for NT_X86_SHSTK: %s"), | |
| safe_strerror (errno)); | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| /* See nat/x86-linux.h. */ | |
| bool | |
| i386_ptrace_get_tls_data (int pid, gdb::array_view<user_desc> buffer) | |
| { | |
| gdb_assert (buffer.size () == 3); | |
| for (int i = 0; i < 3; ++i) | |
| { | |
| void *addr = (void *) (uintptr_t) (i386_initial_tls_gdt + i); | |
| void *data = buffer.slice (i, 1).data (); | |
| if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, data) < 0) | |
| return false; | |
| } | |
| return true; | |
| } | |
| /* See nat/x86-linux.h. */ | |
| bool | |
| i386_ptrace_set_tls_data (int pid, gdb::array_view<user_desc> buffer) | |
| { | |
| gdb_assert (buffer.size () == 3); | |
| for (int i = 0; i < 3; ++i) | |
| { | |
| void *addr = (void *) (uintptr_t) (i386_initial_tls_gdt + i); | |
| void *data = buffer.slice (i, 1).data (); | |
| if (ptrace (PTRACE_SET_THREAD_AREA, pid, addr, data) < 0) | |
| return false; | |
| } | |
| return true; | |
| } |