Debian Codegraph @

libdrgn/arch_s390x.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <byteswap.h>
5 #include <elf.h>
6 #include <stdlib.h>
7
8 #include "error.h"
9 #include "platform.h" // IWYU pragma: associated
10 #include "program.h"
11 #include "register_state.h"
12
13 // The ABI specification can be found at https://github.com/IBM/s390x-abi.
14
15 #include "arch_s390x_defs.inc"
16
17 static const struct drgn_cfi_row default_dwarf_cfi_row_s390x = DRGN_CFI_ROW(
18 // Callee-saved registers default to DW_CFA_same_value. This isn't
19 // explicitly documented in the psABI, but it seems to be the consensus.
20 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r6)),
21 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r7)),
22 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r8)),
23 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r9)),
24 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r10)),
25 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r11)),
26 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r12)),
27 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r13)),
28 // r14 is the return address, which also defaults to DW_CFA_same_value
29 // by consensus.
30 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r14)),
31 DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r15)),
32 );
33
34 static struct drgn_error *
35 apply_elf_reloc_s390(const struct drgn_relocating_section *relocating,
36 uint64_t r_offset, uint32_t r_type,
37 const int64_t *r_addend, uint64_t sym_value)
38 {
39 switch (r_type) {
40 case R_390_NONE:
41 return NULL;
42 case R_390_8:
43 return drgn_reloc_add8(relocating, r_offset, r_addend,
44 sym_value);
45 case R_390_16:
46 return drgn_reloc_add16(relocating, r_offset, r_addend,
47 sym_value);
48 case R_390_32:
49 return drgn_reloc_add32(relocating, r_offset, r_addend,
50 sym_value);
51 case R_390_PC32:
52 return drgn_reloc_add32(relocating, r_offset, r_addend,
53 sym_value
54 - (relocating->addr + r_offset));
55 case R_390_PC16:
56 return drgn_reloc_add16(relocating, r_offset, r_addend,
57 sym_value
58 - (relocating->addr + r_offset));
59 case R_390_64:
60 return drgn_reloc_add64(relocating, r_offset, r_addend,
61 sym_value);
62 case R_390_PC64:
63 return drgn_reloc_add64(relocating, r_offset, r_addend,
64 sym_value
65 - (relocating->addr + r_offset));
66 default:
67 return DRGN_UNKNOWN_RELOCATION_TYPE(r_type);
68 }
69 }
70
71 static struct drgn_error *
72 pt_regs_get_initial_registers_s390x_impl(struct drgn_program *prog,
73 const void *buf,
74 struct drgn_register_state **ret)
75 {
76 struct drgn_register_state *regs =
77 drgn_register_state_create(pswa, true);
78 if (!regs)
79 return &drgn_enomem;
80 drgn_register_state_set_range_from_buffer(regs, r6, r15,
81 (uint64_t *)buf + 9);
82 drgn_register_state_set_range_from_buffer(regs, r0, r5,
83 (uint64_t *)buf + 3);
84 drgn_register_state_set_range_from_buffer(regs, pswm, pswa,
85 (uint64_t *)buf + 1);
86 drgn_register_state_set_pc_from_register(prog, regs, pswa);
87 *ret = regs;
88 return NULL;
89 }
90
91 static struct drgn_error *
92 fallback_unwind_s390x(struct drgn_program *prog,
93 struct drgn_register_state *regs,
94 struct drgn_register_state **ret)
95 {
96 struct drgn_error *err;
97
98 // For userspace, we can't rely on the backchain entry because it is
99 // normally compiled without -mbackchain.
100 if (!(prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL))
101 return &drgn_stop;
102
103 // For the Linux kernel, we assume -mpacked-stack.
104
105 struct optional_uint64 r15 = drgn_register_state_get_u64(prog, regs,
106 r15);
107 if (!r15.has_value)
108 return &drgn_stop;
109
110 static const size_t stack_frame_backchain_offset = 152;
111 uint64_t backchain;
112 err = drgn_program_read_u64(prog,
113 r15.value + stack_frame_backchain_offset,
114 false, &backchain);
115 if (err)
116 goto err;
117
118 if (!backchain) {
119 // The Linux kernel saves a struct stack_frame with back_chain =
120 // 0 and a struct pt_regs on the stack when entering program
121 // check handler, irq handlers, or the system call handler.
122 uint64_t buf[19];
123 err = drgn_program_read_memory(prog, buf, r15.value + 160,
124 sizeof(buf), false);
125 if (err)
126 goto err;
127 return pt_regs_get_initial_registers_s390x_impl(prog, buf, ret);
128 }
129
130 // r14 and r15.
131 uint64_t buf[2];
132 static const size_t stack_frame_r14_offset = 136;
133 err = drgn_program_read_memory(prog, buf,
134 backchain + stack_frame_r14_offset,
135 sizeof(buf), false);
136 if (err)
137 goto err;
138
139 struct drgn_register_state *unwound =
140 drgn_register_state_create(r15, false);
141 if (!unwound)
142 return &drgn_enomem;
143 drgn_register_state_set_range_from_buffer(unwound, r14, r15, buf);
144 drgn_register_state_set_pc_from_register(prog, unwound, r14);
145 *ret = unwound;
146 return NULL;
147
148 err:
149 if (err->code == DRGN_ERROR_FAULT) {
150 drgn_error_destroy(err);
151 return &drgn_stop;
152 }
153 return err;
154 }
155
156 static struct drgn_error *
157 pt_regs_get_initial_registers_s390x(const struct drgn_object *obj,
158 struct drgn_register_state **ret)
159 {
160 if (drgn_object_size(obj) < 152) {
161 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
162 "registers are truncated");
163 }
164 return pt_regs_get_initial_registers_s390x_impl(drgn_object_program(obj),
165 drgn_object_buffer(obj),
166 ret);
167 }
168
169 // On s390x, elf_gregset_t (a.k.a. s390_regs) is different from struct pt_regs.
170 static struct drgn_error *
171 prstatus_get_initial_registers_s390x(struct drgn_program *prog,
172 const void *prstatus, size_t size,
173 struct drgn_register_state **ret)
174 {
175 if (size < 208) {
176 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
177 "registers are truncated");
178 }
179
180 // offsetof(struct elf_prstatus, pr_reg)
181 static const size_t pr_reg_offset = 112;
182 const uint64_t *buf =
183 (const uint64_t *)((const char *)prstatus + pr_reg_offset);
184
185 struct drgn_register_state *regs =
186 drgn_register_state_create(a15, true);
187 if (!regs)
188 return &drgn_enomem;
189 drgn_register_state_set_range_from_buffer(regs, r0, r5, buf + 2);
190 drgn_register_state_set_range_from_buffer(regs, r6, r15, buf + 8);
191 drgn_register_state_set_range_from_buffer(regs, pswm, pswa, buf);
192 drgn_register_state_set_range_from_buffer(regs, a0, a15, buf + 18);
193 drgn_register_state_set_pc_from_register(prog, regs, pswa);
194 *ret = regs;
195 return NULL;
196 }
197
198 // The Linux kernel saves the callee-saved registers in a struct stack_frame and
199 // saves this address to struct task_struct.thread.ksp. See __switch_to() in
200 // arch/s390/kernel/entry.S.
201 static struct drgn_error *
202 linux_kernel_get_initial_registers_s390x(const struct drgn_object *task_obj,
203 struct drgn_register_state **ret)
204 {
205 struct drgn_program *prog = drgn_object_program(task_obj);
206 struct drgn_error *err;
207
208 DRGN_OBJECT(ctx, prog);
209
210 err = drgn_object_member_dereference(&ctx, task_obj, "thread");
211 if (err)
212 return err;
213 err = drgn_object_member(&ctx, &ctx, "ksp");
214 if (err)
215 return err;
216 uint64_t ksp;
217 err = drgn_object_read_unsigned(&ctx, &ksp);
218 if (err)
219 return err;
220
221 // r6-r15
222 uint64_t buf[10];
223 static const size_t stack_frame_gprs_offset = 72;
224 err = drgn_program_read_memory(prog, buf, ksp + stack_frame_gprs_offset,
225 sizeof(buf), false);
226 if (err)
227 return err;
228
229 struct drgn_register_state *regs =
230 drgn_register_state_create(r15, false);
231 if (!regs)
232 return &drgn_enomem;
233 drgn_register_state_set_range_from_buffer(regs, r6, r15, buf);
234 drgn_register_state_set_pc_from_register(prog, regs, r14);
235 *ret = regs;
236 return NULL;
237 }
238
239 struct pgtable_data {
240 uint64_t entries[2048];
241 uint64_t addr;
242 int length;
243 int offset;
244 };
245
246 struct pgtable_iterator_s390x {
247 struct pgtable_iterator it;
248 struct pgtable_data pagetable[5];
249 int levels;
250 };
251
252 struct dat_level {
253 int bits;
254 int shift;
255 int entries;
256 };
257
258 static const struct dat_level dat_levels[] = {
259 { .bits = 8, .shift = 12, .entries = 256 }, /* PTE */
260 { .bits = 11, .shift = 20, .entries = 2048 }, /* STE */
261 { .bits = 11, .shift = 31, .entries = 2048 }, /* RTTE */
262 { .bits = 11, .shift = 42, .entries = 2048 }, /* RSTE */
263 { .bits = 11, .shift = 53, .entries = 2048 }, /* RFTE */
264 };
265
266 #define REGION_INVALID 0x20
267 #define SEGMENT_INVALID 0x20
268 #define PAGE_INVALID 0x400
269
270 #define REGION_LARGE 0x400
271 #define SEGMENT_LARGE 0x400
272 #define PAGE_LARGE 0x800
273
274 static struct drgn_error *
275 linux_kernel_pgtable_iterator_create_s390x(struct drgn_program *prog,
276 struct pgtable_iterator **ret)
277 {
278 struct pgtable_iterator_s390x *it = malloc(sizeof(*it));
279 if (!it)
280 return &drgn_enomem;
281
282 *ret = &it->it;
283 return NULL;
284 }
285
286 static void
287 linux_kernel_pgtable_iterator_destroy_s390x(struct pgtable_iterator *_it)
288 {
289 free(container_of(_it, struct pgtable_iterator_s390x, it));
290 }
291
292 static void
293 linux_kernel_pgtable_iterator_init_s390x(struct drgn_program *prog,
294 struct pgtable_iterator *_it)
295 {
296 struct pgtable_iterator_s390x *it =
297 container_of(_it, struct pgtable_iterator_s390x, it);
298 for (int i = 0; i < 5; i++)
299 it->pagetable[i].addr = UINT64_MAX;
300 it->levels = 3;
301 }
302
303 static bool
304 entry_is_invalid(uint64_t entry, int level)
305 {
306 switch (level) {
307 case 0:
308 return entry & PAGE_INVALID;
309 case 1:
310 return entry & SEGMENT_INVALID;
311 case 2:
312 case 3:
313 case 4:
314 return entry & REGION_INVALID;
315 default:
316 return true;
317 }
318 }
319
320 static int
321 get_mask(struct pgtable_iterator_s390x *it, int level)
322 {
323 return (1 << dat_levels[level].bits) - 1;
324 }
325
326 static int
327 get_index(struct pgtable_iterator_s390x *it, int level, uint64_t va)
328 {
329 return (va >> dat_levels[level].shift) & get_mask(it, level);
330 }
331
332 static int
333 get_table_length(uint64_t entry, int level)
334 {
335 switch(level) {
336 case 2:
337 case 3:
338 case 4:
339 return ((entry & 3) + 1) << 9;
340 default:
341 return 2048;
342 }
343 }
344
345 static int
346 get_table_offset(uint64_t entry, int level)
347 {
348 switch(level) {
349 case 2:
350 case 3:
351 case 4:
352 return ((entry >> 6) & 3) << 9;
353 default:
354 return 0;
355 }
356 }
357
358 static uint64_t
359 get_table_address(uint64_t entry, int level, bool *is_large)
360 {
361 *is_large = false;
362 switch (level) {
363 case 1: /* STE */
364 if (entry & SEGMENT_LARGE) {
365 *is_large = true;
366 return entry & ~((UINT64_C(1) << 20) - 1);
367 } else {
368 return entry & ~UINT64_C(0x7ff);
369 }
370 case 2: /* RTTE */
371 if (entry & REGION_LARGE) {
372 *is_large = true;
373 return entry & ~((UINT64_C(1) << 31) - 1);
374 } else {
375 return entry & ~UINT64_C(0xfff);
376 }
377 default:
378 return entry & ~UINT64_C(0xfff);
379 }
380 }
381
382 static uint64_t get_level_mask(int level)
383 {
384 return ~((UINT64_C(1) << dat_levels[level].shift) - 1);
385 }
386
387 static struct drgn_error *
388 linux_kernel_pgtable_iterator_next_s390x(struct drgn_program *prog,
389 struct pgtable_iterator *_it,
390 uint64_t *virt_addr_ret,
391 uint64_t *phys_addr_ret)
392 {
393 struct pgtable_iterator_s390x *it =
394 container_of(_it, struct pgtable_iterator_s390x, it);
395 const uint64_t va = it->it.virt_addr;
396 uint64_t table = _it->pgtable & ~UINT64_C(0xfff);
397 bool table_physical = false;
398 int level, length = 2048, offset = 0;
399 uint64_t entry;
400
401 /*
402 * Note: we need the ASCE bits to determine the levels of paging in use,
403 * but we only get the pgd address from drgn. Therefore do the same what
404 * the linux kernel does: read the first level entry, and deduct the
405 * number of levels from the TT bits.
406 */
407 struct drgn_error *err = drgn_program_read_u64(prog, table, false,
408 &entry);
409 if (err)
410 return err;
411
412 level = 2 + ((entry >> 2) & 3);
413
414 while(level-- > 0) {
415 int index = get_index(it, level, va);
416
417 if (index < offset || index - offset > length) {
418 uint64_t mask = get_level_mask(level);
419 *phys_addr_ret = UINT64_MAX;
420 it->it.virt_addr = (va | ~mask) + 1;
421 return NULL;
422 }
423
424 index -= offset;
425 if (it->pagetable[level].addr != table ||
426 it->pagetable[level].length != length ||
427 it->pagetable[level].offset != offset) {
428 /*
429 * It's only marginally more expensive to read 4096
430 * bytes than 8 bytes, so we always read the full table.
431 */
432 err = drgn_program_read_memory(prog,
433 it->pagetable[level].entries,
434 table, length * 8,
435 table_physical);
436 if (err)
437 return err;
438
439 it->pagetable[level].addr = table;
440 it->pagetable[level].length = length;
441 it->pagetable[level].offset = offset;
442 }
443
444 entry = it->pagetable[level].entries[index];
445 if (drgn_platform_bswap(&prog->platform))
446 entry = bswap_64(entry);
447
448 length = get_table_length(entry, level);
449 offset = get_table_offset(entry, level);
450 if (entry_is_invalid(entry, level)) {
451 *phys_addr_ret = UINT64_MAX;
452 return NULL;
453 }
454
455 bool is_large;
456 table = get_table_address(entry, level, &is_large);
457 table_physical = true;
458
459 if (level == 0 || is_large) {
460 uint64_t mask = get_level_mask(level);
461 *phys_addr_ret = table;
462 *virt_addr_ret = va & mask;
463 it->it.virt_addr = (va | ~mask) + 1;
464 return NULL;
465 }
466 }
467 return &drgn_enomem;
468 }
469
470 static int
471 linux_kernel_section_size_bits_fallback_s390x(struct drgn_program *prog)
472 {
473 // This changed in Linux kernel commit e3a6970b7daf ("s390/sparsemem:
474 // Reduce section size to 128 MiB") (in v6.13), but that was after
475 // SECTION_SIZE_BITS was added to VMCOREINFO. Before that, it didn't
476 // change since Linux kernel commit 421c175c4d60 ("[S390] Add support
477 // for memory hot-add.") (in v2.6.27).
478 return 28;
479 }
480
481 const struct drgn_architecture_info arch_info_s390x = {
482 .name = "s390x",
483 .arch = DRGN_ARCH_S390X,
484 .default_flags = DRGN_PLATFORM_IS_64_BIT,
485 .scalar_alignment = { 1, 2, 4, 8, 8 },
486 DRGN_ARCHITECTURE_REGISTERS,
487 .default_dwarf_cfi_row = &default_dwarf_cfi_row_s390x,
488 .fallback_unwind = fallback_unwind_s390x,
489 .pt_regs_get_initial_registers = pt_regs_get_initial_registers_s390x,
490 .prstatus_get_initial_registers = prstatus_get_initial_registers_s390x,
491 .linux_kernel_get_initial_registers =
492 linux_kernel_get_initial_registers_s390x,
493 .apply_elf_reloc = apply_elf_reloc_s390,
494 .linux_kernel_pgtable_iterator_create =
495 linux_kernel_pgtable_iterator_create_s390x,
496 .linux_kernel_pgtable_iterator_destroy =
497 linux_kernel_pgtable_iterator_destroy_s390x,
498 .linux_kernel_pgtable_iterator_init =
499 linux_kernel_pgtable_iterator_init_s390x,
500 .linux_kernel_pgtable_iterator_next =
501 linux_kernel_pgtable_iterator_next_s390x,
502 .linux_kernel_section_size_bits_fallback =
503 linux_kernel_section_size_bits_fallback_s390x,
504 // MAX_PHYSMEM_BITS depends on CONFIG_MAX_PHYSMEM_BITS. Use the default
505 // fallback.
506 };
507
508 const struct drgn_architecture_info arch_info_s390 = {
509 .name = "s390",
510 .arch = DRGN_ARCH_S390,
511 .default_flags = 0,
512 .scalar_alignment = { 1, 2, 4, 8, 8 },
513 .register_by_name = drgn_register_by_name_unknown,
514 .apply_elf_reloc = apply_elf_reloc_s390,
515 };