1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3
4 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 #include "defs.h"
23 #include "regcache.h"
24 #include "inferior.h"
25 #include "target.h"
26 #include "linux-nat.h"
27 #include "auxv.h"
28 #include "gregset.h"
29 #include "regset.h"
30 #include "nat/linux-ptrace.h"
31 #include "gdbcmd.h"
32
33 #include "s390-tdep.h"
34 #include "s390-linux-tdep.h"
35 #include "elf/common.h"
36
37 #include <asm/ptrace.h>
38 #include "nat/gdb_ptrace.h"
39 #include <asm/types.h>
40 #include <sys/procfs.h>
41 #include <sys/ucontext.h>
42 #include <elf.h>
43 #include <algorithm>
44 #include "inf-ptrace.h"
45 #include "linux-tdep.h"
46 #include "gdbarch.h"
47
48 /* Per-thread arch-specific data. */
49
50 struct arch_lwp_info
51 {
52 /* Non-zero if the thread's PER info must be re-written. */
53 int per_info_changed;
54 };
55
56 static int have_regset_last_break = 0;
57 static int have_regset_system_call = 0;
58 static int have_regset_tdb = 0;
59 static int have_regset_vxrs = 0;
60 static int have_regset_gs = 0;
61
62 /* Register map for 32-bit executables running under a 64-bit
63 kernel. */
64
65 #ifdef __s390x__
66 static const struct regcache_map_entry s390_64_regmap_gregset[] =
67 {
68 /* Skip PSWM and PSWA, since they must be handled specially. */
69 { 2, REGCACHE_MAP_SKIP, 8 },
70 { 1, S390_R0_UPPER_REGNUM, 4 }, { 1, S390_R0_REGNUM, 4 },
71 { 1, S390_R1_UPPER_REGNUM, 4 }, { 1, S390_R1_REGNUM, 4 },
72 { 1, S390_R2_UPPER_REGNUM, 4 }, { 1, S390_R2_REGNUM, 4 },
73 { 1, S390_R3_UPPER_REGNUM, 4 }, { 1, S390_R3_REGNUM, 4 },
74 { 1, S390_R4_UPPER_REGNUM, 4 }, { 1, S390_R4_REGNUM, 4 },
75 { 1, S390_R5_UPPER_REGNUM, 4 }, { 1, S390_R5_REGNUM, 4 },
76 { 1, S390_R6_UPPER_REGNUM, 4 }, { 1, S390_R6_REGNUM, 4 },
77 { 1, S390_R7_UPPER_REGNUM, 4 }, { 1, S390_R7_REGNUM, 4 },
78 { 1, S390_R8_UPPER_REGNUM, 4 }, { 1, S390_R8_REGNUM, 4 },
79 { 1, S390_R9_UPPER_REGNUM, 4 }, { 1, S390_R9_REGNUM, 4 },
80 { 1, S390_R10_UPPER_REGNUM, 4 }, { 1, S390_R10_REGNUM, 4 },
81 { 1, S390_R11_UPPER_REGNUM, 4 }, { 1, S390_R11_REGNUM, 4 },
82 { 1, S390_R12_UPPER_REGNUM, 4 }, { 1, S390_R12_REGNUM, 4 },
83 { 1, S390_R13_UPPER_REGNUM, 4 }, { 1, S390_R13_REGNUM, 4 },
84 { 1, S390_R14_UPPER_REGNUM, 4 }, { 1, S390_R14_REGNUM, 4 },
85 { 1, S390_R15_UPPER_REGNUM, 4 }, { 1, S390_R15_REGNUM, 4 },
86 { 16, S390_A0_REGNUM, 4 },
87 { 1, REGCACHE_MAP_SKIP, 4 }, { 1, S390_ORIG_R2_REGNUM, 4 },
88 { 0 }
89 };
90
91 static const struct regset s390_64_gregset =
92 {
93 s390_64_regmap_gregset,
94 regcache_supply_regset,
95 regcache_collect_regset
96 };
97
98 #define S390_PSWM_OFFSET 0
99 #define S390_PSWA_OFFSET 8
100 #endif
101
102 /* PER-event mask bits and PER control bits (CR9). */
103
104 #define PER_BIT(n) (1UL << (63 - (n)))
105 #define PER_EVENT_BRANCH PER_BIT (32)
106 #define PER_EVENT_IFETCH PER_BIT (33)
107 #define PER_EVENT_STORE PER_BIT (34)
108 #define PER_EVENT_NULLIFICATION PER_BIT (39)
109 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
110 #define PER_CONTROL_SUSPENSION PER_BIT (41)
111 #define PER_CONTROL_ALTERATION PER_BIT (42)
112
113 class s390_linux_nat_target final : public linux_nat_target
114 {
115 public:
116 /* Add our register access methods. */
117 void fetch_registers (struct regcache *, int) override;
118 void store_registers (struct regcache *, int) override;
119
120 /* Add our watchpoint methods. */
121 int can_use_hw_breakpoint (enum bptype, int, int) override;
122 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *)
123 override;
124 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *)
125 override;
126 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
127 bool stopped_by_watchpoint () override;
128 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
129 struct expression *) override;
130 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
131 struct expression *) override;
132
133 /* Detect target architecture. */
134 const struct target_desc *read_description () override;
135 int auxv_parse (gdb_byte **readptr,
136 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
137 override;
138
139 /* Override linux_nat_target low methods. */
140 void low_new_thread (struct lwp_info *lp) override;
141 void low_delete_thread (struct arch_lwp_info *lp) override;
142 void low_prepare_to_resume (struct lwp_info *lp) override;
143 void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
144 void low_forget_process (pid_t pid) override;
145 };
146
147 static s390_linux_nat_target the_s390_linux_nat_target;
148
149 /* Fill GDB's register array with the general-purpose register values
150 in *REGP.
151
152 When debugging a 32-bit executable running under a 64-bit kernel,
153 we have to fix up the 64-bit registers we get from the kernel to
154 make them look like 32-bit registers. */
155
156 void
supply_gregset(struct regcache * regcache,const gregset_t * regp)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
fill_gregset(const struct regcache * regcache,gregset_t * regp,int regno)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
supply_fpregset(struct regcache * regcache,const fpregset_t * regp)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
fill_fpregset(const struct regcache * regcache,fpregset_t * regp,int regno)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
s390_inferior_tid(void)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
fetch_regs(struct regcache * regcache,int tid)272 fetch_regs (struct regcache *regcache, int tid)
273 {
274 gregset_t regs;
275 ptrace_area parea;
276
277 parea.len = sizeof (regs);
278 parea.process_addr = (addr_t) ®s;
279 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
280 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
281 perror_with_name (_("Couldn't get registers"));
282
283 supply_gregset (regcache, (const gregset_t *) ®s);
284 }
285
286 /* Store all valid general-purpose registers in GDB's register cache
287 into the process/thread specified by TID. */
288 static void
store_regs(const struct regcache * regcache,int tid,int regnum)289 store_regs (const struct regcache *regcache, int tid, int regnum)
290 {
291 gregset_t regs;
292 ptrace_area parea;
293
294 parea.len = sizeof (regs);
295 parea.process_addr = (addr_t) ®s;
296 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
297 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
298 perror_with_name (_("Couldn't get registers"));
299
300 fill_gregset (regcache, ®s, regnum);
301
302 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
303 perror_with_name (_("Couldn't write registers"));
304 }
305
306 /* Fetch all floating-point registers from process/thread TID and store
307 their values in GDB's register cache. */
308 static void
fetch_fpregs(struct regcache * regcache,int tid)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
store_fpregs(const struct regcache * regcache,int tid,int regnum)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
fetch_regset(struct regcache * regcache,int tid,int regset_id,int regsize,const struct regset * regset)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
store_regset(struct regcache * regcache,int tid,int regset_id,int regsize,const struct regset * regset)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
check_regset(int tid,int regset,int regsize)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
fetch_registers(struct regcache * regcache,int regnum)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
store_registers(struct regcache * regcache,int regnum)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 *
s390_find_process_pid(pid_t pid)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 *
s390_add_process(pid_t pid)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 *
s390_process_info_get(pid_t pid)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 *
s390_get_debug_reg_state(pid_t pid)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
low_forget_process(pid_t pid)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
low_new_fork(struct lwp_info * parent,pid_t child_pid)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
s390_show_debug_regs(int tid,const char * where)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
stopped_by_watchpoint()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
low_prepare_to_resume(struct lwp_info * lp)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
s390_mark_per_info_changed(struct lwp_info * lp)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
low_new_thread(struct lwp_info * lp)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
low_delete_thread(struct arch_lwp_info * arch_lwp)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
s390_refresh_per_info_cb(struct lwp_info * lp)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
s390_refresh_per_info(void)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
insert_watchpoint(CORE_ADDR addr,int len,enum target_hw_bp_type type,struct expression * cond)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
remove_watchpoint(CORE_ADDR addr,int len,enum target_hw_bp_type type,struct expression * cond)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
can_use_hw_breakpoint(enum bptype type,int cnt,int othertype)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
insert_hw_breakpoint(struct gdbarch * gdbarch,struct bp_target_info * bp_tgt)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
remove_hw_breakpoint(struct gdbarch * gdbarch,struct bp_target_info * bp_tgt)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
region_ok_for_hw_watchpoint(CORE_ADDR addr,int cnt)940 s390_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int cnt)
941 {
942 return 1;
943 }
944
945 static int
s390_target_wordsize(void)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
auxv_parse(gdb_byte ** readptr,gdb_byte * endptr,CORE_ADDR * typep,CORE_ADDR * valp)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 *
read_description()989 s390_linux_nat_target::read_description ()
990 {
991 int tid = s390_inferior_tid ();
992
993 have_regset_last_break
994 = check_regset (tid, NT_S390_LAST_BREAK, 8);
995 have_regset_system_call
996 = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
997
998 /* If GDB itself is compiled as 64-bit, we are running on a machine in
999 z/Architecture mode. If the target is running in 64-bit addressing
1000 mode, report s390x architecture. If the target is running in 31-bit
1001 addressing mode, but the kernel supports using 64-bit registers in
1002 that mode, report s390 architecture with 64-bit GPRs. */
1003 #ifdef __s390x__
1004 {
1005 CORE_ADDR hwcap = linux_get_hwcap (current_top_target ());
1006
1007 have_regset_tdb = (hwcap & HWCAP_S390_TE)
1008 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
1009
1010 have_regset_vxrs = (hwcap & HWCAP_S390_VX)
1011 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
1012 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
1013
1014 have_regset_gs = (hwcap & HWCAP_S390_GS)
1015 && check_regset (tid, NT_S390_GS_CB, 4 * 8)
1016 && check_regset (tid, NT_S390_GS_BC, 4 * 8);
1017
1018 if (s390_target_wordsize () == 8)
1019 return (have_regset_gs ? tdesc_s390x_gs_linux64 :
1020 have_regset_vxrs ?
1021 (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
1022 tdesc_s390x_vx_linux64) :
1023 have_regset_tdb ? tdesc_s390x_te_linux64 :
1024 have_regset_system_call ? tdesc_s390x_linux64v2 :
1025 have_regset_last_break ? tdesc_s390x_linux64v1 :
1026 tdesc_s390x_linux64);
1027
1028 if (hwcap & HWCAP_S390_HIGH_GPRS)
1029 return (have_regset_gs ? tdesc_s390_gs_linux64 :
1030 have_regset_vxrs ?
1031 (have_regset_tdb ? tdesc_s390_tevx_linux64 :
1032 tdesc_s390_vx_linux64) :
1033 have_regset_tdb ? tdesc_s390_te_linux64 :
1034 have_regset_system_call ? tdesc_s390_linux64v2 :
1035 have_regset_last_break ? tdesc_s390_linux64v1 :
1036 tdesc_s390_linux64);
1037 }
1038 #endif
1039
1040 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1041 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1042 mode, report s390 architecture with 32-bit GPRs. */
1043 return (have_regset_system_call? tdesc_s390_linux32v2 :
1044 have_regset_last_break? tdesc_s390_linux32v1 :
1045 tdesc_s390_linux32);
1046 }
1047
1048 void _initialize_s390_nat ();
1049 void
_initialize_s390_nat()1050 _initialize_s390_nat ()
1051 {
1052 /* Register the target. */
1053 linux_target = &the_s390_linux_nat_target;
1054 add_inf_child_target (&the_s390_linux_nat_target);
1055
1056 /* A maintenance command to enable showing the PER state. */
1057 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1058 &show_debug_regs, _("\
1059 Set whether to show the PER (debug) hardware state."), _("\
1060 Show whether to show the PER (debug) hardware state."), _("\
1061 Use \"on\" to enable, \"off\" to disable.\n\
1062 If enabled, the PER state is shown after it is changed by GDB,\n\
1063 and when the inferior triggers a breakpoint or watchpoint."),
1064 NULL,
1065 NULL,
1066 &maintenance_set_cmdlist,
1067 &maintenance_show_cmdlist);
1068 }
1069