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