1 /* S390 native-dependent code for GDB, the GNU debugger. 2 Copyright (C) 2001-2023 Free Software Foundation, Inc. 3 4 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 5 for IBM Deutschland Entwicklung GmbH, IBM Corporation. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "regcache.h" 24 #include "inferior.h" 25 #include "target.h" 26 #include "linux-nat.h" 27 #include "auxv.h" 28 #include "gregset.h" 29 #include "regset.h" 30 #include "nat/linux-ptrace.h" 31 #include "gdbcmd.h" 32 #include "gdbarch.h" 33 34 #include "s390-tdep.h" 35 #include "s390-linux-tdep.h" 36 #include "elf/common.h" 37 38 #include <asm/ptrace.h> 39 #include "nat/gdb_ptrace.h" 40 #include <asm/types.h> 41 #include <sys/procfs.h> 42 #include <sys/ucontext.h> 43 #include <elf.h> 44 #include <algorithm> 45 #include "inf-ptrace.h" 46 #include "linux-tdep.h" 47 48 /* Per-thread arch-specific data. */ 49 50 struct arch_lwp_info 51 { 52 /* Non-zero if the thread's PER info must be re-written. */ 53 int per_info_changed; 54 }; 55 56 static int have_regset_last_break = 0; 57 static int have_regset_system_call = 0; 58 static int have_regset_tdb = 0; 59 static int have_regset_vxrs = 0; 60 static int have_regset_gs = 0; 61 62 /* Register map for 32-bit executables running under a 64-bit 63 kernel. */ 64 65 #ifdef __s390x__ 66 static const struct regcache_map_entry s390_64_regmap_gregset[] = 67 { 68 /* Skip PSWM and PSWA, since they must be handled specially. */ 69 { 2, REGCACHE_MAP_SKIP, 8 }, 70 { 1, S390_R0_UPPER_REGNUM, 4 }, { 1, S390_R0_REGNUM, 4 }, 71 { 1, S390_R1_UPPER_REGNUM, 4 }, { 1, S390_R1_REGNUM, 4 }, 72 { 1, S390_R2_UPPER_REGNUM, 4 }, { 1, S390_R2_REGNUM, 4 }, 73 { 1, S390_R3_UPPER_REGNUM, 4 }, { 1, S390_R3_REGNUM, 4 }, 74 { 1, S390_R4_UPPER_REGNUM, 4 }, { 1, S390_R4_REGNUM, 4 }, 75 { 1, S390_R5_UPPER_REGNUM, 4 }, { 1, S390_R5_REGNUM, 4 }, 76 { 1, S390_R6_UPPER_REGNUM, 4 }, { 1, S390_R6_REGNUM, 4 }, 77 { 1, S390_R7_UPPER_REGNUM, 4 }, { 1, S390_R7_REGNUM, 4 }, 78 { 1, S390_R8_UPPER_REGNUM, 4 }, { 1, S390_R8_REGNUM, 4 }, 79 { 1, S390_R9_UPPER_REGNUM, 4 }, { 1, S390_R9_REGNUM, 4 }, 80 { 1, S390_R10_UPPER_REGNUM, 4 }, { 1, S390_R10_REGNUM, 4 }, 81 { 1, S390_R11_UPPER_REGNUM, 4 }, { 1, S390_R11_REGNUM, 4 }, 82 { 1, S390_R12_UPPER_REGNUM, 4 }, { 1, S390_R12_REGNUM, 4 }, 83 { 1, S390_R13_UPPER_REGNUM, 4 }, { 1, S390_R13_REGNUM, 4 }, 84 { 1, S390_R14_UPPER_REGNUM, 4 }, { 1, S390_R14_REGNUM, 4 }, 85 { 1, S390_R15_UPPER_REGNUM, 4 }, { 1, S390_R15_REGNUM, 4 }, 86 { 16, S390_A0_REGNUM, 4 }, 87 { 1, REGCACHE_MAP_SKIP, 4 }, { 1, S390_ORIG_R2_REGNUM, 4 }, 88 { 0 } 89 }; 90 91 static const struct regset s390_64_gregset = 92 { 93 s390_64_regmap_gregset, 94 regcache_supply_regset, 95 regcache_collect_regset 96 }; 97 98 #define S390_PSWM_OFFSET 0 99 #define S390_PSWA_OFFSET 8 100 #endif 101 102 /* PER-event mask bits and PER control bits (CR9). */ 103 104 #define PER_BIT(n) (1UL << (63 - (n))) 105 #define PER_EVENT_BRANCH PER_BIT (32) 106 #define PER_EVENT_IFETCH PER_BIT (33) 107 #define PER_EVENT_STORE PER_BIT (34) 108 #define PER_EVENT_NULLIFICATION PER_BIT (39) 109 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40) 110 #define PER_CONTROL_SUSPENSION PER_BIT (41) 111 #define PER_CONTROL_ALTERATION PER_BIT (42) 112 113 class s390_linux_nat_target final : public linux_nat_target 114 { 115 public: 116 /* Add our register access methods. */ 117 void fetch_registers (struct regcache *, int) override; 118 void store_registers (struct regcache *, int) override; 119 120 /* Add our watchpoint methods. */ 121 int can_use_hw_breakpoint (enum bptype, int, int) override; 122 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) 123 override; 124 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) 125 override; 126 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; 127 bool stopped_by_watchpoint () override; 128 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 129 struct expression *) override; 130 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 131 struct expression *) override; 132 133 /* Detect target architecture. */ 134 const struct target_desc *read_description () override; 135 int auxv_parse (const gdb_byte **readptr, 136 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) 137 override; 138 139 /* Override linux_nat_target low methods. */ 140 void low_new_thread (struct lwp_info *lp) override; 141 void low_delete_thread (struct arch_lwp_info *lp) override; 142 void low_prepare_to_resume (struct lwp_info *lp) override; 143 void low_new_fork (struct lwp_info *parent, pid_t child_pid) override; 144 void low_forget_process (pid_t pid) override; 145 }; 146 147 static s390_linux_nat_target the_s390_linux_nat_target; 148 149 /* Fill GDB's register array with the general-purpose register values 150 in *REGP. 151 152 When debugging a 32-bit executable running under a 64-bit kernel, 153 we have to fix up the 64-bit registers we get from the kernel to 154 make them look like 32-bit registers. */ 155 156 void 157 supply_gregset (struct regcache *regcache, const gregset_t *regp) 158 { 159 #ifdef __s390x__ 160 struct gdbarch *gdbarch = regcache->arch (); 161 if (gdbarch_ptr_bit (gdbarch) == 32) 162 { 163 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 164 ULONGEST pswm, pswa; 165 gdb_byte buf[4]; 166 167 regcache_supply_regset (&s390_64_gregset, regcache, -1, 168 regp, sizeof (gregset_t)); 169 pswm = extract_unsigned_integer ((const gdb_byte *) regp 170 + S390_PSWM_OFFSET, 8, byte_order); 171 pswa = extract_unsigned_integer ((const gdb_byte *) regp 172 + S390_PSWA_OFFSET, 8, byte_order); 173 store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000); 174 regcache->raw_supply (S390_PSWM_REGNUM, buf); 175 store_unsigned_integer (buf, 4, byte_order, 176 (pswa & 0x7fffffff) | (pswm & 0x80000000)); 177 regcache->raw_supply (S390_PSWA_REGNUM, buf); 178 return; 179 } 180 #endif 181 182 regcache_supply_regset (&s390_gregset, regcache, -1, regp, 183 sizeof (gregset_t)); 184 } 185 186 /* Fill register REGNO (if it is a general-purpose register) in 187 *REGP with the value in GDB's register array. If REGNO is -1, 188 do this for all registers. */ 189 190 void 191 fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno) 192 { 193 #ifdef __s390x__ 194 struct gdbarch *gdbarch = regcache->arch (); 195 if (gdbarch_ptr_bit (gdbarch) == 32) 196 { 197 regcache_collect_regset (&s390_64_gregset, regcache, regno, 198 regp, sizeof (gregset_t)); 199 200 if (regno == -1 201 || regno == S390_PSWM_REGNUM || regno == S390_PSWA_REGNUM) 202 { 203 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 204 ULONGEST pswa, pswm; 205 gdb_byte buf[4]; 206 gdb_byte *pswm_p = (gdb_byte *) regp + S390_PSWM_OFFSET; 207 gdb_byte *pswa_p = (gdb_byte *) regp + S390_PSWA_OFFSET; 208 209 pswm = extract_unsigned_integer (pswm_p, 8, byte_order); 210 211 if (regno == -1 || regno == S390_PSWM_REGNUM) 212 { 213 pswm &= 0x80000000; 214 regcache->raw_collect (S390_PSWM_REGNUM, buf); 215 pswm |= (extract_unsigned_integer (buf, 4, byte_order) 216 & 0xfff7ffff) << 32; 217 } 218 219 if (regno == -1 || regno == S390_PSWA_REGNUM) 220 { 221 regcache->raw_collect (S390_PSWA_REGNUM, buf); 222 pswa = extract_unsigned_integer (buf, 4, byte_order); 223 pswm ^= (pswm ^ pswa) & 0x80000000; 224 pswa &= 0x7fffffff; 225 store_unsigned_integer (pswa_p, 8, byte_order, pswa); 226 } 227 228 store_unsigned_integer (pswm_p, 8, byte_order, pswm); 229 } 230 return; 231 } 232 #endif 233 234 regcache_collect_regset (&s390_gregset, regcache, regno, regp, 235 sizeof (gregset_t)); 236 } 237 238 /* Fill GDB's register array with the floating-point register values 239 in *REGP. */ 240 void 241 supply_fpregset (struct regcache *regcache, const fpregset_t *regp) 242 { 243 regcache_supply_regset (&s390_fpregset, regcache, -1, regp, 244 sizeof (fpregset_t)); 245 } 246 247 /* Fill register REGNO (if it is a general-purpose register) in 248 *REGP with the value in GDB's register array. If REGNO is -1, 249 do this for all registers. */ 250 void 251 fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno) 252 { 253 regcache_collect_regset (&s390_fpregset, regcache, regno, regp, 254 sizeof (fpregset_t)); 255 } 256 257 /* Find the TID for the current inferior thread to use with ptrace. */ 258 static int 259 s390_inferior_tid (void) 260 { 261 /* GNU/Linux LWP ID's are process ID's. */ 262 int tid = inferior_ptid.lwp (); 263 if (tid == 0) 264 tid = inferior_ptid.pid (); /* Not a threaded program. */ 265 266 return tid; 267 } 268 269 /* Fetch all general-purpose registers from process/thread TID and 270 store their values in GDB's register cache. */ 271 static void 272 fetch_regs (struct regcache *regcache, int tid) 273 { 274 gregset_t regs; 275 ptrace_area parea; 276 277 parea.len = sizeof (regs); 278 parea.process_addr = (addr_t) ®s; 279 parea.kernel_addr = offsetof (struct user_regs_struct, psw); 280 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0) 281 perror_with_name (_("Couldn't get registers")); 282 283 supply_gregset (regcache, (const gregset_t *) ®s); 284 } 285 286 /* Store all valid general-purpose registers in GDB's register cache 287 into the process/thread specified by TID. */ 288 static void 289 store_regs (const struct regcache *regcache, int tid, int regnum) 290 { 291 gregset_t regs; 292 ptrace_area parea; 293 294 parea.len = sizeof (regs); 295 parea.process_addr = (addr_t) ®s; 296 parea.kernel_addr = offsetof (struct user_regs_struct, psw); 297 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0) 298 perror_with_name (_("Couldn't get registers")); 299 300 fill_gregset (regcache, ®s, regnum); 301 302 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0) 303 perror_with_name (_("Couldn't write registers")); 304 } 305 306 /* Fetch all floating-point registers from process/thread TID and store 307 their values in GDB's register cache. */ 308 static void 309 fetch_fpregs (struct regcache *regcache, int tid) 310 { 311 fpregset_t fpregs; 312 ptrace_area parea; 313 314 parea.len = sizeof (fpregs); 315 parea.process_addr = (addr_t) &fpregs; 316 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs); 317 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0) 318 perror_with_name (_("Couldn't get floating point status")); 319 320 supply_fpregset (regcache, (const fpregset_t *) &fpregs); 321 } 322 323 /* Store all valid floating-point registers in GDB's register cache 324 into the process/thread specified by TID. */ 325 static void 326 store_fpregs (const struct regcache *regcache, int tid, int regnum) 327 { 328 fpregset_t fpregs; 329 ptrace_area parea; 330 331 parea.len = sizeof (fpregs); 332 parea.process_addr = (addr_t) &fpregs; 333 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs); 334 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0) 335 perror_with_name (_("Couldn't get floating point status")); 336 337 fill_fpregset (regcache, &fpregs, regnum); 338 339 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0) 340 perror_with_name (_("Couldn't write floating point status")); 341 } 342 343 /* Fetch all registers in the kernel's register set whose number is 344 REGSET_ID, whose size is REGSIZE, and whose layout is described by 345 REGSET, from process/thread TID and store their values in GDB's 346 register cache. */ 347 static void 348 fetch_regset (struct regcache *regcache, int tid, 349 int regset_id, int regsize, const struct regset *regset) 350 { 351 void *buf = alloca (regsize); 352 struct iovec iov; 353 354 iov.iov_base = buf; 355 iov.iov_len = regsize; 356 357 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0) 358 { 359 if (errno == ENODATA) 360 regcache_supply_regset (regset, regcache, -1, NULL, regsize); 361 else 362 perror_with_name (_("Couldn't get register set")); 363 } 364 else 365 regcache_supply_regset (regset, regcache, -1, buf, regsize); 366 } 367 368 /* Store all registers in the kernel's register set whose number is 369 REGSET_ID, whose size is REGSIZE, and whose layout is described by 370 REGSET, from GDB's register cache back to process/thread TID. */ 371 static void 372 store_regset (struct regcache *regcache, int tid, 373 int regset_id, int regsize, const struct regset *regset) 374 { 375 void *buf = alloca (regsize); 376 struct iovec iov; 377 378 iov.iov_base = buf; 379 iov.iov_len = regsize; 380 381 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0) 382 perror_with_name (_("Couldn't get register set")); 383 384 regcache_collect_regset (regset, regcache, -1, buf, regsize); 385 386 if (ptrace (PTRACE_SETREGSET, tid, (long) regset_id, (long) &iov) < 0) 387 perror_with_name (_("Couldn't set register set")); 388 } 389 390 /* Check whether the kernel provides a register set with number REGSET 391 of size REGSIZE for process/thread TID. */ 392 static int 393 check_regset (int tid, int regset, int regsize) 394 { 395 void *buf = alloca (regsize); 396 struct iovec iov; 397 398 iov.iov_base = buf; 399 iov.iov_len = regsize; 400 401 if (ptrace (PTRACE_GETREGSET, tid, (long) regset, (long) &iov) >= 0 402 || errno == ENODATA) 403 return 1; 404 return 0; 405 } 406 407 /* Fetch register REGNUM from the child process. If REGNUM is -1, do 408 this for all registers. */ 409 void 410 s390_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum) 411 { 412 pid_t tid = get_ptrace_pid (regcache->ptid ()); 413 414 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum)) 415 fetch_regs (regcache, tid); 416 417 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum)) 418 fetch_fpregs (regcache, tid); 419 420 if (have_regset_last_break) 421 if (regnum == -1 || regnum == S390_LAST_BREAK_REGNUM) 422 fetch_regset (regcache, tid, NT_S390_LAST_BREAK, 8, 423 (gdbarch_ptr_bit (regcache->arch ()) == 32 424 ? &s390_last_break_regset : &s390x_last_break_regset)); 425 426 if (have_regset_system_call) 427 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM) 428 fetch_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4, 429 &s390_system_call_regset); 430 431 if (have_regset_tdb) 432 if (regnum == -1 || S390_IS_TDBREGSET_REGNUM (regnum)) 433 fetch_regset (regcache, tid, NT_S390_TDB, s390_sizeof_tdbregset, 434 &s390_tdb_regset); 435 436 if (have_regset_vxrs) 437 { 438 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM 439 && regnum <= S390_V15_LOWER_REGNUM)) 440 fetch_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8, 441 &s390_vxrs_low_regset); 442 if (regnum == -1 || (regnum >= S390_V16_REGNUM 443 && regnum <= S390_V31_REGNUM)) 444 fetch_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16, 445 &s390_vxrs_high_regset); 446 } 447 448 if (have_regset_gs) 449 { 450 if (regnum == -1 || (regnum >= S390_GSD_REGNUM 451 && regnum <= S390_GSEPLA_REGNUM)) 452 fetch_regset (regcache, tid, NT_S390_GS_CB, 4 * 8, 453 &s390_gs_regset); 454 if (regnum == -1 || (regnum >= S390_BC_GSD_REGNUM 455 && regnum <= S390_BC_GSEPLA_REGNUM)) 456 fetch_regset (regcache, tid, NT_S390_GS_BC, 4 * 8, 457 &s390_gsbc_regset); 458 } 459 } 460 461 /* Store register REGNUM back into the child process. If REGNUM is 462 -1, do this for all registers. */ 463 void 464 s390_linux_nat_target::store_registers (struct regcache *regcache, int regnum) 465 { 466 pid_t tid = get_ptrace_pid (regcache->ptid ()); 467 468 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum)) 469 store_regs (regcache, tid, regnum); 470 471 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum)) 472 store_fpregs (regcache, tid, regnum); 473 474 /* S390_LAST_BREAK_REGNUM is read-only. */ 475 476 if (have_regset_system_call) 477 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM) 478 store_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4, 479 &s390_system_call_regset); 480 481 if (have_regset_vxrs) 482 { 483 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM 484 && regnum <= S390_V15_LOWER_REGNUM)) 485 store_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8, 486 &s390_vxrs_low_regset); 487 if (regnum == -1 || (regnum >= S390_V16_REGNUM 488 && regnum <= S390_V31_REGNUM)) 489 store_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16, 490 &s390_vxrs_high_regset); 491 } 492 } 493 494 495 /* Hardware-assisted watchpoint handling. */ 496 497 /* For each process we maintain a list of all currently active 498 watchpoints, in order to properly handle watchpoint removal. 499 500 The only thing we actually need is the total address space area 501 spanned by the watchpoints. */ 502 503 struct watch_area 504 { 505 CORE_ADDR lo_addr; 506 CORE_ADDR hi_addr; 507 }; 508 509 /* Hardware debug state. */ 510 511 struct s390_debug_reg_state 512 { 513 std::vector<watch_area> watch_areas; 514 std::vector<watch_area> break_areas; 515 }; 516 517 /* Per-process data. */ 518 519 struct s390_process_info 520 { 521 struct s390_process_info *next = nullptr; 522 pid_t pid = 0; 523 struct s390_debug_reg_state state; 524 }; 525 526 static struct s390_process_info *s390_process_list = NULL; 527 528 /* Find process data for process PID. */ 529 530 static struct s390_process_info * 531 s390_find_process_pid (pid_t pid) 532 { 533 struct s390_process_info *proc; 534 535 for (proc = s390_process_list; proc; proc = proc->next) 536 if (proc->pid == pid) 537 return proc; 538 539 return NULL; 540 } 541 542 /* Add process data for process PID. Returns newly allocated info 543 object. */ 544 545 static struct s390_process_info * 546 s390_add_process (pid_t pid) 547 { 548 struct s390_process_info *proc = new struct s390_process_info; 549 550 proc->pid = pid; 551 proc->next = s390_process_list; 552 s390_process_list = proc; 553 554 return proc; 555 } 556 557 /* Get data specific info for process PID, creating it if necessary. 558 Never returns NULL. */ 559 560 static struct s390_process_info * 561 s390_process_info_get (pid_t pid) 562 { 563 struct s390_process_info *proc; 564 565 proc = s390_find_process_pid (pid); 566 if (proc == NULL) 567 proc = s390_add_process (pid); 568 569 return proc; 570 } 571 572 /* Get hardware debug state for process PID. */ 573 574 static struct s390_debug_reg_state * 575 s390_get_debug_reg_state (pid_t pid) 576 { 577 return &s390_process_info_get (pid)->state; 578 } 579 580 /* Called whenever GDB is no longer debugging process PID. It deletes 581 data structures that keep track of hardware debug state. */ 582 583 void 584 s390_linux_nat_target::low_forget_process (pid_t pid) 585 { 586 struct s390_process_info *proc, **proc_link; 587 588 proc = s390_process_list; 589 proc_link = &s390_process_list; 590 591 while (proc != NULL) 592 { 593 if (proc->pid == pid) 594 { 595 *proc_link = proc->next; 596 delete proc; 597 return; 598 } 599 600 proc_link = &proc->next; 601 proc = *proc_link; 602 } 603 } 604 605 /* linux_nat_new_fork hook. */ 606 607 void 608 s390_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid) 609 { 610 pid_t parent_pid; 611 struct s390_debug_reg_state *parent_state; 612 struct s390_debug_reg_state *child_state; 613 614 /* NULL means no watchpoint has ever been set in the parent. In 615 that case, there's nothing to do. */ 616 if (lwp_arch_private_info (parent) == NULL) 617 return; 618 619 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of 620 the parent. So copy the debug state from parent to child. */ 621 622 parent_pid = parent->ptid.pid (); 623 parent_state = s390_get_debug_reg_state (parent_pid); 624 child_state = s390_get_debug_reg_state (child_pid); 625 626 child_state->watch_areas = parent_state->watch_areas; 627 child_state->break_areas = parent_state->break_areas; 628 } 629 630 /* Dump PER state. */ 631 632 static void 633 s390_show_debug_regs (int tid, const char *where) 634 { 635 per_struct per_info; 636 ptrace_area parea; 637 638 parea.len = sizeof (per_info); 639 parea.process_addr = (addr_t) &per_info; 640 parea.kernel_addr = offsetof (struct user_regs_struct, per_info); 641 642 if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea, 0) < 0) 643 perror_with_name (_("Couldn't retrieve debug regs")); 644 645 debug_printf ("PER (debug) state for %d -- %s\n" 646 " cr9-11: %lx %lx %lx\n" 647 " start, end: %lx %lx\n" 648 " code/ATMID: %x address: %lx PAID: %x\n", 649 tid, 650 where, 651 per_info.control_regs.words.cr[0], 652 per_info.control_regs.words.cr[1], 653 per_info.control_regs.words.cr[2], 654 per_info.starting_addr, 655 per_info.ending_addr, 656 per_info.lowcore.words.perc_atmid, 657 per_info.lowcore.words.address, 658 per_info.lowcore.words.access_id); 659 } 660 661 bool 662 s390_linux_nat_target::stopped_by_watchpoint () 663 { 664 struct s390_debug_reg_state *state 665 = s390_get_debug_reg_state (inferior_ptid.pid ()); 666 per_lowcore_bits per_lowcore; 667 ptrace_area parea; 668 669 if (show_debug_regs) 670 s390_show_debug_regs (s390_inferior_tid (), "stop"); 671 672 /* Speed up common case. */ 673 if (state->watch_areas.empty ()) 674 return false; 675 676 siginfo_t siginfo; 677 if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) 678 return false; 679 if (siginfo.si_signo != SIGTRAP 680 || (siginfo.si_code & 0xffff) != TRAP_HWBKPT) 681 return false; 682 683 parea.len = sizeof (per_lowcore); 684 parea.process_addr = (addr_t) & per_lowcore; 685 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore); 686 if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0) 687 perror_with_name (_("Couldn't retrieve watchpoint status")); 688 689 bool result = (per_lowcore.perc_storage_alteration == 1 690 && per_lowcore.perc_store_real_address == 0); 691 692 return result; 693 } 694 695 /* Each time before resuming a thread, update its PER info. */ 696 697 void 698 s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) 699 { 700 int tid; 701 pid_t pid = ptid_of_lwp (lp).pid (); 702 703 per_struct per_info; 704 ptrace_area parea; 705 706 CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0; 707 struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp); 708 struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid); 709 int step = lwp_is_stepping (lp); 710 711 /* Nothing to do if there was never any PER info for this thread. */ 712 if (lp_priv == NULL) 713 return; 714 715 /* If PER info has changed, update it. When single-stepping, disable 716 hardware breakpoints (if any). Otherwise we're done. */ 717 if (!lp_priv->per_info_changed) 718 { 719 if (!step || state->break_areas.empty ()) 720 return; 721 } 722 723 lp_priv->per_info_changed = 0; 724 725 tid = ptid_of_lwp (lp).lwp (); 726 if (tid == 0) 727 tid = pid; 728 729 parea.len = sizeof (per_info); 730 parea.process_addr = (addr_t) & per_info; 731 parea.kernel_addr = offsetof (struct user_regs_struct, per_info); 732 733 /* Clear PER info, but adjust the single_step field (used by older 734 kernels only). */ 735 memset (&per_info, 0, sizeof (per_info)); 736 per_info.single_step = (step != 0); 737 738 if (!state->watch_areas.empty ()) 739 { 740 for (const auto &area : state->watch_areas) 741 { 742 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); 743 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); 744 } 745 746 /* Enable storage-alteration events. */ 747 per_info.control_regs.words.cr[0] |= (PER_EVENT_STORE 748 | PER_CONTROL_ALTERATION); 749 } 750 751 if (!state->break_areas.empty ()) 752 { 753 /* Don't install hardware breakpoints while single-stepping, since 754 our PER settings (e.g. the nullification bit) might then conflict 755 with the kernel's. But re-install them afterwards. */ 756 if (step) 757 lp_priv->per_info_changed = 1; 758 else 759 { 760 for (const auto &area : state->break_areas) 761 { 762 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); 763 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); 764 } 765 766 /* If there's just one breakpoint, enable instruction-fetching 767 nullification events for the breakpoint address (fast). 768 Otherwise stop after any instruction within the PER area and 769 after any branch into it (slow). */ 770 if (watch_hi_addr == watch_lo_addr) 771 per_info.control_regs.words.cr[0] |= (PER_EVENT_NULLIFICATION 772 | PER_EVENT_IFETCH); 773 else 774 { 775 /* The PER area must include the instruction before the 776 first breakpoint address. */ 777 watch_lo_addr = watch_lo_addr > 6 ? watch_lo_addr - 6 : 0; 778 per_info.control_regs.words.cr[0] 779 |= (PER_EVENT_BRANCH 780 | PER_EVENT_IFETCH 781 | PER_CONTROL_BRANCH_ADDRESS); 782 } 783 } 784 } 785 per_info.starting_addr = watch_lo_addr; 786 per_info.ending_addr = watch_hi_addr; 787 788 if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0) 789 perror_with_name (_("Couldn't modify watchpoint status")); 790 791 if (show_debug_regs) 792 s390_show_debug_regs (tid, "resume"); 793 } 794 795 /* Mark the PER info as changed, so the next resume will update it. */ 796 797 static void 798 s390_mark_per_info_changed (struct lwp_info *lp) 799 { 800 if (lwp_arch_private_info (lp) == NULL) 801 lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info)); 802 803 lwp_arch_private_info (lp)->per_info_changed = 1; 804 } 805 806 /* When attaching to a new thread, mark its PER info as changed. */ 807 808 void 809 s390_linux_nat_target::low_new_thread (struct lwp_info *lp) 810 { 811 s390_mark_per_info_changed (lp); 812 } 813 814 /* Function to call when a thread is being deleted. */ 815 816 void 817 s390_linux_nat_target::low_delete_thread (struct arch_lwp_info *arch_lwp) 818 { 819 xfree (arch_lwp); 820 } 821 822 /* Iterator callback for s390_refresh_per_info. */ 823 824 static int 825 s390_refresh_per_info_cb (struct lwp_info *lp) 826 { 827 s390_mark_per_info_changed (lp); 828 829 if (!lwp_is_stopped (lp)) 830 linux_stop_lwp (lp); 831 return 0; 832 } 833 834 /* Make sure that threads are stopped and mark PER info as changed. */ 835 836 static int 837 s390_refresh_per_info (void) 838 { 839 ptid_t pid_ptid = ptid_t (current_lwp_ptid ().pid ()); 840 841 iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb); 842 return 0; 843 } 844 845 int 846 s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, 847 enum target_hw_bp_type type, 848 struct expression *cond) 849 { 850 watch_area area; 851 struct s390_debug_reg_state *state 852 = s390_get_debug_reg_state (inferior_ptid.pid ()); 853 854 area.lo_addr = addr; 855 area.hi_addr = addr + len - 1; 856 state->watch_areas.push_back (area); 857 858 return s390_refresh_per_info (); 859 } 860 861 int 862 s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, 863 enum target_hw_bp_type type, 864 struct expression *cond) 865 { 866 unsigned ix; 867 struct s390_debug_reg_state *state 868 = s390_get_debug_reg_state (inferior_ptid.pid ()); 869 870 for (ix = 0; ix < state->watch_areas.size (); ix++) 871 { 872 watch_area &area = state->watch_areas[ix]; 873 if (area.lo_addr == addr && area.hi_addr == addr + len - 1) 874 { 875 unordered_remove (state->watch_areas, ix); 876 return s390_refresh_per_info (); 877 } 878 } 879 880 gdb_printf (gdb_stderr, 881 "Attempt to remove nonexistent watchpoint.\n"); 882 return -1; 883 } 884 885 /* Implement the "can_use_hw_breakpoint" target_ops method. */ 886 887 int 888 s390_linux_nat_target::can_use_hw_breakpoint (enum bptype type, 889 int cnt, int othertype) 890 { 891 if (type == bp_hardware_watchpoint || type == bp_hardware_breakpoint) 892 return 1; 893 return 0; 894 } 895 896 /* Implement the "insert_hw_breakpoint" target_ops method. */ 897 898 int 899 s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, 900 struct bp_target_info *bp_tgt) 901 { 902 watch_area area; 903 struct s390_debug_reg_state *state; 904 905 area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address; 906 area.hi_addr = area.lo_addr; 907 state = s390_get_debug_reg_state (inferior_ptid.pid ()); 908 state->break_areas.push_back (area); 909 910 return s390_refresh_per_info (); 911 } 912 913 /* Implement the "remove_hw_breakpoint" target_ops method. */ 914 915 int 916 s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, 917 struct bp_target_info *bp_tgt) 918 { 919 unsigned ix; 920 struct s390_debug_reg_state *state; 921 922 state = s390_get_debug_reg_state (inferior_ptid.pid ()); 923 for (ix = 0; state->break_areas.size (); ix++) 924 { 925 watch_area &area = state->break_areas[ix]; 926 if (area.lo_addr == bp_tgt->placed_address) 927 { 928 unordered_remove (state->break_areas, ix); 929 return s390_refresh_per_info (); 930 } 931 } 932 933 gdb_printf (gdb_stderr, 934 "Attempt to remove nonexistent breakpoint.\n"); 935 return -1; 936 } 937 938 int 939 s390_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int cnt) 940 { 941 return 1; 942 } 943 944 static int 945 s390_target_wordsize (void) 946 { 947 int wordsize = 4; 948 949 /* Check for 64-bit inferior process. This is the case when the host is 950 64-bit, and in addition bit 32 of the PSW mask is set. */ 951 #ifdef __s390x__ 952 long pswm; 953 954 errno = 0; 955 pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0); 956 if (errno == 0 && (pswm & 0x100000000ul) != 0) 957 wordsize = 8; 958 #endif 959 960 return wordsize; 961 } 962 963 int 964 s390_linux_nat_target::auxv_parse (const gdb_byte **readptr, 965 const gdb_byte *endptr, CORE_ADDR *typep, 966 CORE_ADDR *valp) 967 { 968 int sizeof_auxv_field = s390_target_wordsize (); 969 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 970 const gdb_byte *ptr = *readptr; 971 972 if (endptr == ptr) 973 return 0; 974 975 if (endptr - ptr < sizeof_auxv_field * 2) 976 return -1; 977 978 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order); 979 ptr += sizeof_auxv_field; 980 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order); 981 ptr += sizeof_auxv_field; 982 983 *readptr = ptr; 984 return 1; 985 } 986 987 const struct target_desc * 988 s390_linux_nat_target::read_description () 989 { 990 int tid = inferior_ptid.pid (); 991 992 have_regset_last_break 993 = check_regset (tid, NT_S390_LAST_BREAK, 8); 994 have_regset_system_call 995 = check_regset (tid, NT_S390_SYSTEM_CALL, 4); 996 997 /* If GDB itself is compiled as 64-bit, we are running on a machine in 998 z/Architecture mode. If the target is running in 64-bit addressing 999 mode, report s390x architecture. If the target is running in 31-bit 1000 addressing mode, but the kernel supports using 64-bit registers in 1001 that mode, report s390 architecture with 64-bit GPRs. */ 1002 #ifdef __s390x__ 1003 { 1004 CORE_ADDR hwcap = linux_get_hwcap (); 1005 1006 have_regset_tdb = (hwcap & HWCAP_S390_TE) 1007 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset); 1008 1009 have_regset_vxrs = (hwcap & HWCAP_S390_VX) 1010 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8) 1011 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16); 1012 1013 have_regset_gs = (hwcap & HWCAP_S390_GS) 1014 && check_regset (tid, NT_S390_GS_CB, 4 * 8) 1015 && check_regset (tid, NT_S390_GS_BC, 4 * 8); 1016 1017 if (s390_target_wordsize () == 8) 1018 return (have_regset_gs ? tdesc_s390x_gs_linux64 : 1019 have_regset_vxrs ? 1020 (have_regset_tdb ? tdesc_s390x_tevx_linux64 : 1021 tdesc_s390x_vx_linux64) : 1022 have_regset_tdb ? tdesc_s390x_te_linux64 : 1023 have_regset_system_call ? tdesc_s390x_linux64v2 : 1024 have_regset_last_break ? tdesc_s390x_linux64v1 : 1025 tdesc_s390x_linux64); 1026 1027 if (hwcap & HWCAP_S390_HIGH_GPRS) 1028 return (have_regset_gs ? tdesc_s390_gs_linux64 : 1029 have_regset_vxrs ? 1030 (have_regset_tdb ? tdesc_s390_tevx_linux64 : 1031 tdesc_s390_vx_linux64) : 1032 have_regset_tdb ? tdesc_s390_te_linux64 : 1033 have_regset_system_call ? tdesc_s390_linux64v2 : 1034 have_regset_last_break ? tdesc_s390_linux64v1 : 1035 tdesc_s390_linux64); 1036 } 1037 #endif 1038 1039 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior 1040 on a 64-bit kernel that does not support using 64-bit registers in 31-bit 1041 mode, report s390 architecture with 32-bit GPRs. */ 1042 return (have_regset_system_call? tdesc_s390_linux32v2 : 1043 have_regset_last_break? tdesc_s390_linux32v1 : 1044 tdesc_s390_linux32); 1045 } 1046 1047 void _initialize_s390_nat (); 1048 void 1049 _initialize_s390_nat () 1050 { 1051 /* Register the target. */ 1052 linux_target = &the_s390_linux_nat_target; 1053 add_inf_child_target (&the_s390_linux_nat_target); 1054 1055 /* A maintenance command to enable showing the PER state. */ 1056 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance, 1057 &show_debug_regs, _("\ 1058 Set whether to show the PER (debug) hardware state."), _("\ 1059 Show whether to show the PER (debug) hardware state."), _("\ 1060 Use \"on\" to enable, \"off\" to disable.\n\ 1061 If enabled, the PER state is shown after it is changed by GDB,\n\ 1062 and when the inferior triggers a breakpoint or watchpoint."), 1063 NULL, 1064 NULL, 1065 &maintenance_set_cmdlist, 1066 &maintenance_show_cmdlist); 1067 } 1068