// Copyright (c) Meta Platforms, Inc. and affiliates. // SPDX-License-Identifier: LGPL-2.1-or-later #include #include "cfi.h" #include "error.h" #include "helpers.h" #include "platform.h" // IWYU pragma: associated #include "program.h" #include "register_state.h" /* * The ABI specification can be found at: * https://developer.arm.com/architectures/system-architectures/software-standards/abi * https://github.com/ARM-software/abi-aa/releases */ #include "arch_arm_defs.inc" static const struct drgn_cfi_row default_dwarf_cfi_row_arm = DRGN_CFI_ROW( // The psABI defines the CFA as the value of the stack pointer in the // calling frame. [DRGN_REGISTER_NUMBER(r13)] = { DRGN_CFI_RULE_CFA_PLUS_OFFSET }, // The psABI defines that callee-saved registers default to // DW_CFA_same_value. DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r4)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r5)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r6)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r7)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r8)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r9)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r10)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r11)), DRGN_CFI_SAME_VALUE_INIT(DRGN_REGISTER_NUMBER(r14)), ); static struct drgn_error *fallback_unwind_arm(struct drgn_program *prog, struct drgn_register_state *regs, struct drgn_register_state **ret) { // GCC and Clang generate different frame pointer layouts. See "GCC/LLVM // frame pointer incompatibility on ARM" [1] and Linux kernel commit // b4d5ec9b39f8 ("ARM: 8992/1: Fix unwind_frame for clang-built // kernels"). For now, let's not bother with it. // // 1: https://discourse.llvm.org/t/gcc-llvm-frame-pointer-incompatibility-on-arm/32906 return &drgn_stop; } // elf_gregset_t (in PRSTATUS) and struct pt_regs are identical. static struct drgn_error * get_initial_registers_from_struct_arm(struct drgn_program *prog, const void *buf, size_t size, struct drgn_register_state **ret) { if (size < 68) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "registers are truncated"); } struct drgn_register_state *regs = drgn_register_state_create(cpsr, true); if (!regs) return &drgn_enomem; drgn_register_state_set_range_from_buffer(regs, r13, r14, (uint32_t *)buf + 13); drgn_register_state_set_range_from_buffer(regs, r4, r11, (uint32_t *)buf + 4); drgn_register_state_set_range_from_buffer(regs, r0, r3, buf); drgn_register_state_set_from_buffer(regs, r12, (uint32_t *)buf + 12); drgn_register_state_set_range_from_buffer(regs, r15, cpsr, (uint32_t *)buf + 15); drgn_register_state_set_pc_from_register(prog, regs, r15); *ret = regs; return NULL; } static struct drgn_error * pt_regs_get_initial_registers_arm(const struct drgn_object *obj, struct drgn_register_state **ret) { return get_initial_registers_from_struct_arm(drgn_object_program(obj), drgn_object_buffer(obj), drgn_object_size(obj), ret); } static struct drgn_error * prstatus_get_initial_registers_arm(struct drgn_program *prog, const void *prstatus, size_t size, struct drgn_register_state **ret) { // offsetof(struct elf_prstatus, pr_reg) static const size_t pr_reg_offset = 72; if (size < pr_reg_offset) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "NT_PRSTATUS is truncated"); } return get_initial_registers_from_struct_arm(prog, (char *)prstatus + pr_reg_offset, size - pr_reg_offset, ret); } // The Linux kernel saves the callee-saved registers in // task_thread_info(task)->cpu_context (with type struct cpu_context_save). See // __switch_to() in arch/arm/kernel/entry-armv.S (as of Linux v6.12). static struct drgn_error * linux_kernel_get_initial_registers_arm(const struct drgn_object *task_obj, struct drgn_register_state **ret) { struct drgn_error *err; struct drgn_program *prog = drgn_object_program(task_obj); DRGN_OBJECT(cpu_context_obj, prog); err = linux_helper_task_thread_info(&cpu_context_obj, task_obj); if (err) return err; err = drgn_object_member_dereference(&cpu_context_obj, &cpu_context_obj, "cpu_context"); if (err) return err; if (cpu_context_obj.encoding != DRGN_OBJECT_ENCODING_BUFFER || drgn_object_size(&cpu_context_obj) < 40) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "cpu_context is truncated"); } err = drgn_object_read(&cpu_context_obj, &cpu_context_obj); if (err) return err; const void *buf = drgn_object_buffer(&cpu_context_obj); struct drgn_register_state *regs = drgn_register_state_create(r15, false); if (!regs) return &drgn_enomem; drgn_register_state_set_range_from_buffer(regs, r13, r14, (uint32_t *)buf + 8); drgn_register_state_set_range_from_buffer(regs, r4, r11, buf); drgn_register_state_set_pc_from_register(prog, regs, r14); *ret = regs; return NULL; } static struct drgn_error * apply_elf_reloc_arm(const struct drgn_relocating_section *relocating, uint64_t r_offset, uint32_t r_type, const int64_t *r_addend, uint64_t sym_value) { switch (r_type) { case R_ARM_NONE: return NULL; case R_ARM_ABS32: return drgn_reloc_add32(relocating, r_offset, r_addend, sym_value); case R_ARM_REL32: return drgn_reloc_add32(relocating, r_offset, r_addend, sym_value - (relocating->addr + r_offset)); default: return DRGN_UNKNOWN_RELOCATION_TYPE(r_type); } } struct pgtable_iterator_arm { struct pgtable_iterator it; union { // For LPAE. struct { uint64_t cached_entries[3]; uint32_t cached_virt_addr; }; // For non-LPAE. struct { uint32_t cached_entry; uint32_t cached_index; }; }; }; static struct drgn_error * linux_kernel_pgtable_iterator_create_arm(struct drgn_program *prog, struct pgtable_iterator **ret) { struct pgtable_iterator_arm *it = malloc(sizeof(*it)); if (!it) return &drgn_enomem; *ret = &it->it; return NULL; } static void linux_kernel_pgtable_iterator_destroy_arm(struct pgtable_iterator *it) { free(container_of(it, struct pgtable_iterator_arm, it)); } static void linux_kernel_pgtable_iterator_init_arm(struct drgn_program *prog, struct pgtable_iterator *_it) { struct pgtable_iterator_arm *it = container_of(_it, struct pgtable_iterator_arm, it); memset(it->cached_entries, 0, sizeof(it->cached_entries)); it->cached_virt_addr = 0; } static struct drgn_error * linux_kernel_pgtable_iterator_next_arm_lpae(struct drgn_program *prog, struct pgtable_iterator_arm *it, uint64_t *virt_addr_ret, uint64_t *phys_addr_ret) { struct drgn_error *err; const uint32_t virt_addr = it->it.virt_addr; const uint64_t phys_addr_mask = 0xfffffff000; uint32_t index_mask = 0x3; uint64_t table = it->it.pgtable; bool table_physical = false; for (int level = 2;; level--) { int level_shift = 12 + 9 * level; uint32_t index = (virt_addr >> level_shift) & index_mask; uint32_t cached_index = (it->cached_virt_addr >> level_shift) & index_mask; uint64_t *entry_ptr = &it->cached_entries[2 - level]; if (index != cached_index) memset(entry_ptr, 0, (level + 1) * 8); if (!*entry_ptr) { err = drgn_program_read_u64(prog, table + index * 8, table_physical, entry_ptr); if (err) return err; } uint64_t entry = *entry_ptr; index_mask = 0x1ff; table = entry & phys_addr_mask; table_physical = true; if (level == 0 || (entry & 0x3) != 0x3) { uint64_t mask = (UINT64_C(1) << level_shift) - 1; *virt_addr_ret = virt_addr & ~mask; if ((entry & 0x3) == (level == 0 ? 0x3 : 0x1)) *phys_addr_ret = table & ~mask; else *phys_addr_ret = UINT64_MAX; it->cached_virt_addr = virt_addr; it->it.virt_addr = (virt_addr | mask) + 1; return NULL; } } } static struct drgn_error * linux_kernel_pgtable_iterator_next_arm(struct drgn_program *prog, struct pgtable_iterator *_it, uint64_t *virt_addr_ret, uint64_t *phys_addr_ret) { struct drgn_error *err; struct pgtable_iterator_arm *it = container_of(_it, struct pgtable_iterator_arm, it); if (prog->vmcoreinfo.arm_lpae) { return linux_kernel_pgtable_iterator_next_arm_lpae(prog, it, virt_addr_ret, phys_addr_ret); } const uint32_t virt_addr = it->it.virt_addr; uint32_t index = virt_addr >> 20; if (it->cached_index != index || !it->cached_entry) { err = drgn_program_read_u32(prog, it->it.pgtable + index * 4, false, &it->cached_entry); if (err) return err; it->cached_index = index; } uint32_t entry = it->cached_entry; if ((entry & 0x3) != 0x1) { uint32_t mask = (UINT32_C(1) << 20) - 1; if ((entry & 0x40002) == 0x40002) { // Supersection (16MB) mask = (UINT32_C(1) << 24) - 1; *phys_addr_ret = (entry & ~mask) | ((uint64_t)(entry & 0xf00000) << 12); } else if ((entry & 0x40002) == 0x2) { // Section (1MB) *phys_addr_ret = entry & ~mask; } else { // Invalid *phys_addr_ret = UINT64_MAX; } *virt_addr_ret = virt_addr & ~mask; it->it.virt_addr = (virt_addr | mask) + 1; return NULL; } uint32_t table = entry & ~((UINT32_C(1) << 10) - 1); index = (virt_addr >> 12) & 0xff; err = drgn_program_read_u32(prog, table + index * 4, true, &entry); if (err) return err; uint32_t mask = (UINT32_C(1) << 12) - 1; if ((entry & 0x2)) { // Small page (4KB) *phys_addr_ret = entry & ~mask; } else if ((entry & 0x3) == 0x1) { // Large page (16KB) mask = (UINT32_C(1) << 16) - 1; *phys_addr_ret = entry & ~mask; } else { *phys_addr_ret = UINT64_MAX; } *virt_addr_ret = virt_addr & ~mask; it->it.virt_addr = (virt_addr | mask) + 1; return NULL; } // StrongARM 1100 and RiscPC technically use different values for // SECTION_SIZE_BITS and MAX_PHYSMEM_BITS, but it's vanishingly unlikely that // drgn will run on those platforms. Ignoring those, these haven't changed since // Linux kernel commit db57f88e4ccb ("ARM: 8411/1: Add default SPARSEMEM // settings") (in v4.6). static int linux_kernel_section_size_bits_fallback_arm(struct drgn_program *prog) { return 28; } static int linux_kernel_max_physmem_bits_fallback_arm(struct drgn_program *prog) { return 36; } const struct drgn_architecture_info arch_info_arm = { .name = "Arm", .arch = DRGN_ARCH_ARM, .default_flags = DRGN_PLATFORM_IS_LITTLE_ENDIAN, .scalar_alignment = { 1, 2, 4, 8, 8 }, DRGN_ARCHITECTURE_REGISTERS, .default_dwarf_cfi_row = &default_dwarf_cfi_row_arm, .fallback_unwind = fallback_unwind_arm, .pt_regs_get_initial_registers = pt_regs_get_initial_registers_arm, .prstatus_get_initial_registers = prstatus_get_initial_registers_arm, .linux_kernel_get_initial_registers = linux_kernel_get_initial_registers_arm, .apply_elf_reloc = apply_elf_reloc_arm, .linux_kernel_pgtable_iterator_create = linux_kernel_pgtable_iterator_create_arm, .linux_kernel_pgtable_iterator_destroy = linux_kernel_pgtable_iterator_destroy_arm, .linux_kernel_pgtable_iterator_init = linux_kernel_pgtable_iterator_init_arm, .linux_kernel_pgtable_iterator_next = linux_kernel_pgtable_iterator_next_arm, .linux_kernel_section_size_bits_fallback = linux_kernel_section_size_bits_fallback_arm, .linux_kernel_max_physmem_bits_fallback = linux_kernel_max_physmem_bits_fallback_arm, };