1 /* S390 native-dependent code for GDB, the GNU debugger. 2 Copyright (C) 2001-2020 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 33 #include "s390-tdep.h" 34 #include "s390-linux-tdep.h" 35 #include "elf/common.h" 36 37 #include <asm/ptrace.h> 38 #include "nat/gdb_ptrace.h" 39 #include <asm/types.h> 40 #include <sys/procfs.h> 41 #include <sys/ucontext.h> 42 #include <elf.h> 43 #include <algorithm> 44 #include "inf-ptrace.h" 45 #include "linux-tdep.h" 46 #include "gdbarch.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 (gdb_byte **readptr, 136 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 parea.len = sizeof (per_lowcore); 677 parea.process_addr = (addr_t) & per_lowcore; 678 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore); 679 if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0) 680 perror_with_name (_("Couldn't retrieve watchpoint status")); 681 682 bool result = (per_lowcore.perc_storage_alteration == 1 683 && per_lowcore.perc_store_real_address == 0); 684 685 if (result) 686 { 687 /* Do not report this watchpoint again. */ 688 memset (&per_lowcore, 0, sizeof (per_lowcore)); 689 if (ptrace (PTRACE_POKEUSR_AREA, s390_inferior_tid (), &parea, 0) < 0) 690 perror_with_name (_("Couldn't clear watchpoint status")); 691 } 692 693 return result; 694 } 695 696 /* Each time before resuming a thread, update its PER info. */ 697 698 void 699 s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) 700 { 701 int tid; 702 pid_t pid = ptid_of_lwp (lp).pid (); 703 704 per_struct per_info; 705 ptrace_area parea; 706 707 CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0; 708 struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp); 709 struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid); 710 int step = lwp_is_stepping (lp); 711 712 /* Nothing to do if there was never any PER info for this thread. */ 713 if (lp_priv == NULL) 714 return; 715 716 /* If PER info has changed, update it. When single-stepping, disable 717 hardware breakpoints (if any). Otherwise we're done. */ 718 if (!lp_priv->per_info_changed) 719 { 720 if (!step || state->break_areas.empty ()) 721 return; 722 } 723 724 lp_priv->per_info_changed = 0; 725 726 tid = ptid_of_lwp (lp).lwp (); 727 if (tid == 0) 728 tid = pid; 729 730 parea.len = sizeof (per_info); 731 parea.process_addr = (addr_t) & per_info; 732 parea.kernel_addr = offsetof (struct user_regs_struct, per_info); 733 734 /* Clear PER info, but adjust the single_step field (used by older 735 kernels only). */ 736 memset (&per_info, 0, sizeof (per_info)); 737 per_info.single_step = (step != 0); 738 739 if (!state->watch_areas.empty ()) 740 { 741 for (const auto &area : state->watch_areas) 742 { 743 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); 744 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); 745 } 746 747 /* Enable storage-alteration events. */ 748 per_info.control_regs.words.cr[0] |= (PER_EVENT_STORE 749 | PER_CONTROL_ALTERATION); 750 } 751 752 if (!state->break_areas.empty ()) 753 { 754 /* Don't install hardware breakpoints while single-stepping, since 755 our PER settings (e.g. the nullification bit) might then conflict 756 with the kernel's. But re-install them afterwards. */ 757 if (step) 758 lp_priv->per_info_changed = 1; 759 else 760 { 761 for (const auto &area : state->break_areas) 762 { 763 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); 764 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); 765 } 766 767 /* If there's just one breakpoint, enable instruction-fetching 768 nullification events for the breakpoint address (fast). 769 Otherwise stop after any instruction within the PER area and 770 after any branch into it (slow). */ 771 if (watch_hi_addr == watch_lo_addr) 772 per_info.control_regs.words.cr[0] |= (PER_EVENT_NULLIFICATION 773 | PER_EVENT_IFETCH); 774 else 775 { 776 /* The PER area must include the instruction before the 777 first breakpoint address. */ 778 watch_lo_addr = watch_lo_addr > 6 ? watch_lo_addr - 6 : 0; 779 per_info.control_regs.words.cr[0] 780 |= (PER_EVENT_BRANCH 781 | PER_EVENT_IFETCH 782 | PER_CONTROL_BRANCH_ADDRESS); 783 } 784 } 785 } 786 per_info.starting_addr = watch_lo_addr; 787 per_info.ending_addr = watch_hi_addr; 788 789 if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0) 790 perror_with_name (_("Couldn't modify watchpoint status")); 791 792 if (show_debug_regs) 793 s390_show_debug_regs (tid, "resume"); 794 } 795 796 /* Mark the PER info as changed, so the next resume will update it. */ 797 798 static void 799 s390_mark_per_info_changed (struct lwp_info *lp) 800 { 801 if (lwp_arch_private_info (lp) == NULL) 802 lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info)); 803 804 lwp_arch_private_info (lp)->per_info_changed = 1; 805 } 806 807 /* When attaching to a new thread, mark its PER info as changed. */ 808 809 void 810 s390_linux_nat_target::low_new_thread (struct lwp_info *lp) 811 { 812 s390_mark_per_info_changed (lp); 813 } 814 815 /* Function to call when a thread is being deleted. */ 816 817 void 818 s390_linux_nat_target::low_delete_thread (struct arch_lwp_info *arch_lwp) 819 { 820 xfree (arch_lwp); 821 } 822 823 /* Iterator callback for s390_refresh_per_info. */ 824 825 static int 826 s390_refresh_per_info_cb (struct lwp_info *lp) 827 { 828 s390_mark_per_info_changed (lp); 829 830 if (!lwp_is_stopped (lp)) 831 linux_stop_lwp (lp); 832 return 0; 833 } 834 835 /* Make sure that threads are stopped and mark PER info as changed. */ 836 837 static int 838 s390_refresh_per_info (void) 839 { 840 ptid_t pid_ptid = ptid_t (current_lwp_ptid ().pid ()); 841 842 iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb); 843 return 0; 844 } 845 846 int 847 s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, 848 enum target_hw_bp_type type, 849 struct expression *cond) 850 { 851 watch_area area; 852 struct s390_debug_reg_state *state 853 = s390_get_debug_reg_state (inferior_ptid.pid ()); 854 855 area.lo_addr = addr; 856 area.hi_addr = addr + len - 1; 857 state->watch_areas.push_back (area); 858 859 return s390_refresh_per_info (); 860 } 861 862 int 863 s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, 864 enum target_hw_bp_type type, 865 struct expression *cond) 866 { 867 unsigned ix; 868 struct s390_debug_reg_state *state 869 = s390_get_debug_reg_state (inferior_ptid.pid ()); 870 871 for (ix = 0; ix < state->watch_areas.size (); ix++) 872 { 873 watch_area &area = state->watch_areas[ix]; 874 if (area.lo_addr == addr && area.hi_addr == addr + len - 1) 875 { 876 unordered_remove (state->watch_areas, ix); 877 return s390_refresh_per_info (); 878 } 879 } 880 881 fprintf_unfiltered (gdb_stderr, 882 "Attempt to remove nonexistent watchpoint.\n"); 883 return -1; 884 } 885 886 /* Implement the "can_use_hw_breakpoint" target_ops method. */ 887 888 int 889 s390_linux_nat_target::can_use_hw_breakpoint (enum bptype type, 890 int cnt, int othertype) 891 { 892 if (type == bp_hardware_watchpoint || type == bp_hardware_breakpoint) 893 return 1; 894 return 0; 895 } 896 897 /* Implement the "insert_hw_breakpoint" target_ops method. */ 898 899 int 900 s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, 901 struct bp_target_info *bp_tgt) 902 { 903 watch_area area; 904 struct s390_debug_reg_state *state; 905 906 area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address; 907 area.hi_addr = area.lo_addr; 908 state = s390_get_debug_reg_state (inferior_ptid.pid ()); 909 state->break_areas.push_back (area); 910 911 return s390_refresh_per_info (); 912 } 913 914 /* Implement the "remove_hw_breakpoint" target_ops method. */ 915 916 int 917 s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, 918 struct bp_target_info *bp_tgt) 919 { 920 unsigned ix; 921 struct s390_debug_reg_state *state; 922 923 state = s390_get_debug_reg_state (inferior_ptid.pid ()); 924 for (ix = 0; state->break_areas.size (); ix++) 925 { 926 watch_area &area = state->break_areas[ix]; 927 if (area.lo_addr == bp_tgt->placed_address) 928 { 929 unordered_remove (state->break_areas, ix); 930 return s390_refresh_per_info (); 931 } 932 } 933 934 fprintf_unfiltered (gdb_stderr, 935 "Attempt to remove nonexistent breakpoint.\n"); 936 return -1; 937 } 938 939 int 940 s390_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int cnt) 941 { 942 return 1; 943 } 944 945 static int 946 s390_target_wordsize (void) 947 { 948 int wordsize = 4; 949 950 /* Check for 64-bit inferior process. This is the case when the host is 951 64-bit, and in addition bit 32 of the PSW mask is set. */ 952 #ifdef __s390x__ 953 long pswm; 954 955 errno = 0; 956 pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0); 957 if (errno == 0 && (pswm & 0x100000000ul) != 0) 958 wordsize = 8; 959 #endif 960 961 return wordsize; 962 } 963 964 int 965 s390_linux_nat_target::auxv_parse (gdb_byte **readptr, 966 gdb_byte *endptr, CORE_ADDR *typep, 967 CORE_ADDR *valp) 968 { 969 int sizeof_auxv_field = s390_target_wordsize (); 970 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); 971 gdb_byte *ptr = *readptr; 972 973 if (endptr == ptr) 974 return 0; 975 976 if (endptr - ptr < sizeof_auxv_field * 2) 977 return -1; 978 979 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order); 980 ptr += sizeof_auxv_field; 981 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order); 982 ptr += sizeof_auxv_field; 983 984 *readptr = ptr; 985 return 1; 986 } 987 988 const struct target_desc * 989 s390_linux_nat_target::read_description () 990 { 991 int tid = s390_inferior_tid (); 992 993 have_regset_last_break 994 = check_regset (tid, NT_S390_LAST_BREAK, 8); 995 have_regset_system_call 996 = check_regset (tid, NT_S390_SYSTEM_CALL, 4); 997 998 /* If GDB itself is compiled as 64-bit, we are running on a machine in 999 z/Architecture mode. If the target is running in 64-bit addressing 1000 mode, report s390x architecture. If the target is running in 31-bit 1001 addressing mode, but the kernel supports using 64-bit registers in 1002 that mode, report s390 architecture with 64-bit GPRs. */ 1003 #ifdef __s390x__ 1004 { 1005 CORE_ADDR hwcap = linux_get_hwcap (current_top_target ()); 1006 1007 have_regset_tdb = (hwcap & HWCAP_S390_TE) 1008 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset); 1009 1010 have_regset_vxrs = (hwcap & HWCAP_S390_VX) 1011 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8) 1012 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16); 1013 1014 have_regset_gs = (hwcap & HWCAP_S390_GS) 1015 && check_regset (tid, NT_S390_GS_CB, 4 * 8) 1016 && check_regset (tid, NT_S390_GS_BC, 4 * 8); 1017 1018 if (s390_target_wordsize () == 8) 1019 return (have_regset_gs ? tdesc_s390x_gs_linux64 : 1020 have_regset_vxrs ? 1021 (have_regset_tdb ? tdesc_s390x_tevx_linux64 : 1022 tdesc_s390x_vx_linux64) : 1023 have_regset_tdb ? tdesc_s390x_te_linux64 : 1024 have_regset_system_call ? tdesc_s390x_linux64v2 : 1025 have_regset_last_break ? tdesc_s390x_linux64v1 : 1026 tdesc_s390x_linux64); 1027 1028 if (hwcap & HWCAP_S390_HIGH_GPRS) 1029 return (have_regset_gs ? tdesc_s390_gs_linux64 : 1030 have_regset_vxrs ? 1031 (have_regset_tdb ? tdesc_s390_tevx_linux64 : 1032 tdesc_s390_vx_linux64) : 1033 have_regset_tdb ? tdesc_s390_te_linux64 : 1034 have_regset_system_call ? tdesc_s390_linux64v2 : 1035 have_regset_last_break ? tdesc_s390_linux64v1 : 1036 tdesc_s390_linux64); 1037 } 1038 #endif 1039 1040 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior 1041 on a 64-bit kernel that does not support using 64-bit registers in 31-bit 1042 mode, report s390 architecture with 32-bit GPRs. */ 1043 return (have_regset_system_call? tdesc_s390_linux32v2 : 1044 have_regset_last_break? tdesc_s390_linux32v1 : 1045 tdesc_s390_linux32); 1046 } 1047 1048 void _initialize_s390_nat (); 1049 void 1050 _initialize_s390_nat () 1051 { 1052 /* Register the target. */ 1053 linux_target = &the_s390_linux_nat_target; 1054 add_inf_child_target (&the_s390_linux_nat_target); 1055 1056 /* A maintenance command to enable showing the PER state. */ 1057 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance, 1058 &show_debug_regs, _("\ 1059 Set whether to show the PER (debug) hardware state."), _("\ 1060 Show whether to show the PER (debug) hardware state."), _("\ 1061 Use \"on\" to enable, \"off\" to disable.\n\ 1062 If enabled, the PER state is shown after it is changed by GDB,\n\ 1063 and when the inferior triggers a breakpoint or watchpoint."), 1064 NULL, 1065 NULL, 1066 &maintenance_set_cmdlist, 1067 &maintenance_show_cmdlist); 1068 } 1069