gdb/s390-linux-nat.c

   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 #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) &regs;
 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 *) &regs);
 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) &regs;
 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, &regs, 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
1049 _initialize_s390_nat (void)
1050 {
1051   /* Register the target.  */
1052   linux_target = &the_s390_linux_nat_target;
1053   add_inf_child_target (&the_s390_linux_nat_target);
1054
1055   /* A maintenance command to enable showing the PER state.  */
1056   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1057                            &show_debug_regs, _("\
1058 Set whether to show the PER (debug) hardware state."), _("\
1059 Show whether to show the PER (debug) hardware state."), _("\
1060 Use \"on\" to enable, \"off\" to disable.\n\
1061 If enabled, the PER state is shown after it is changed by GDB,\n\
1062 and when the inferior triggers a breakpoint or watchpoint."),
1063                            NULL,
1064                            NULL,
1065                            &maintenance_set_cmdlist,
1066                            &maintenance_show_cmdlist);
1067 }