gdb/s390-linux-nat.c

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