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