// Copyright (c) Meta Platforms, Inc. and affiliates. // SPDX-License-Identifier: LGPL-2.1-or-later #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "array.h" #include "binary_buffer.h" #include "binary_search.h" #include "bitmap.h" #include "cleanup.h" #include "crc32.h" #include "debug_info.h" #include "elf_file.h" #include "elf_notes.h" #include "error.h" #include "hexlify.h" #include "io.h" #include "linux_kernel.h" #include "log.h" #include "openmp.h" #include "platform.h" #include "pp.h" #include "program.h" #include "serialize.h" #include "util.h" #define _cleanup_elf_end_ _cleanup_(elf_endp) static inline void elf_endp(Elf **elfp) { elf_end(*elfp); } #if !_ELFUTILS_PREREQ(0, 175) // If we don't have dwelf_elf_begin(), this is equivalent except that it doesn't // handle compressed files. static inline Elf *dwelf_elf_begin(int fd) { return elf_begin(fd, ELF_C_READ_MMAP_PRIVATE, NULL); } #endif DEFINE_HASH_MAP_FUNCTIONS(drgn_module_section_address_map, c_string_key_hash_pair, c_string_key_eq); // This is currently always DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK. struct drgn_module_wanted_supplementary_file { struct drgn_elf_file *file; // supplementary_path and checksum are owned by file. const char *supplementary_path; const void *checksum; size_t checksum_len; // checksum_str is a separate allocation. char *checksum_str; // Used to detect when the wanted supplementary file has changed in // order to avoid redundant attempts. uint64_t generation; }; #if WITH_DEBUGINFOD #if _ELFUTILS_PREREQ(0, 179) #define DRGN_DEBUGINFOD_0_179_FUNCTIONS \ X(debuginfod_set_user_data) \ X(debuginfod_get_user_data) \ X(debuginfod_get_url) #else #define DRGN_DEBUGINFOD_0_179_FUNCTIONS #endif #define DRGN_DEBUGINFOD_FUNCTIONS \ X(debuginfod_begin) \ X(debuginfod_end) \ X(debuginfod_find_debuginfo) \ X(debuginfod_find_executable) \ X(debuginfod_set_progressfn) \ DRGN_DEBUGINFOD_0_179_FUNCTIONS #if ENABLE_DLOPEN_DEBUGINFOD #include #define X(name) static typeof(&name) drgn_##name; DRGN_DEBUGINFOD_FUNCTIONS #undef X __attribute__((__constructor__)) static void drgn_dlopen_debuginfod(void) { void *handle = dlopen(DEBUGINFOD_SONAME, RTLD_LAZY); if (handle) { #define X(name) drgn_##name = dlsym(handle, #name); DRGN_DEBUGINFOD_FUNCTIONS #undef X #define X(name) || !drgn_##name if (0 DRGN_DEBUGINFOD_FUNCTIONS) { #undef X #define X(name) drgn_##name = NULL; DRGN_DEBUGINFOD_FUNCTIONS #undef X dlclose(handle); } } } bool drgn_have_debuginfod(void) { return drgn_debuginfod_begin != NULL; } #else // GCC and Clang optimize out the function pointer. #define X(name) static const typeof(&name) drgn_##name = name; DRGN_DEBUGINFOD_FUNCTIONS #undef X #endif #undef DRGN_DEBUGINFOD_FUNCTIONS #undef DRGN_DEBUGINFOD_0_179_FUNCTIONS #endif static inline Dwarf *drgn_elf_file_dwarf_key(struct drgn_elf_file * const *entry) { return (*entry)->_dwarf; } DEFINE_HASH_TABLE_FUNCTIONS(drgn_elf_file_dwarf_table, drgn_elf_file_dwarf_key, ptr_key_hash_pair, scalar_key_eq); DEFINE_VECTOR(drgn_module_vector, struct drgn_module *); static inline const char *drgn_module_entry_name(struct drgn_module * const *entry) { return (*entry)->name; } DEFINE_HASH_TABLE_FUNCTIONS(drgn_module_table, drgn_module_entry_name, c_string_key_hash_pair, c_string_key_eq); static inline uint64_t drgn_module_address_range_key(const struct drgn_module_address_range *entry) { return entry->start; } DEFINE_BINARY_SEARCH_TREE_FUNCTIONS(drgn_module_address_tree, node, drgn_module_address_range_key, binary_search_tree_scalar_cmp, splay); static void drgn_module_free_section_addresses(struct drgn_module *module) { hash_table_for_each(drgn_module_section_address_map, it, &module->section_addresses) free(it.entry->key); } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_by_name(struct drgn_program *prog, const char *name) { struct drgn_module_table_iterator it = drgn_module_table_search(&prog->dbinfo.modules, &name); return it.entry ? *it.entry : NULL; } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_by_address(struct drgn_program *prog, uint64_t address) { struct drgn_module_address_tree_iterator it = drgn_module_address_tree_search_le(&prog->dbinfo.modules_by_address, &address); if (!it.entry || address >= it.entry->end) return NULL; return it.entry->module; } static struct drgn_module *drgn_module_find(struct drgn_program *prog, enum drgn_module_kind kind, const char *name, uint64_t info) { struct drgn_module_table_iterator it = drgn_module_table_search(&prog->dbinfo.modules, &name); if (!it.entry) return NULL; struct drgn_module *module = *it.entry; while (module->kind != kind || module->info != info) { module = module->next_same_name; if (!module) break; } return module; } static struct drgn_error * drgn_module_find_or_create(struct drgn_program *prog, enum drgn_module_kind kind, const char *name, uint64_t info, struct drgn_module **ret, bool *new_ret) { struct drgn_error *err; struct hash_pair hp; struct drgn_module_table_iterator it; if (kind == DRGN_MODULE_MAIN) { if (prog->dbinfo.main_module) { if (strcmp(prog->dbinfo.main_module->name, name) != 0) { return drgn_error_create(DRGN_ERROR_LOOKUP, "main module already exists with different name"); } *ret = prog->dbinfo.main_module; if (new_ret) *new_ret = false; return NULL; } hp = drgn_module_table_hash(&name); it.entry = NULL; } else { hp = drgn_module_table_hash(&name); it = drgn_module_table_search_hashed(&prog->dbinfo.modules, &name, hp); if (it.entry) { struct drgn_module *module = *it.entry; do { if (module->kind == kind && module->info == info) { *ret = module; if (new_ret) *new_ret = false; return NULL; } module = module->next_same_name; } while (module); } } struct drgn_module *module = calloc(1, sizeof(*module)); if (!module) return &drgn_enomem; module->prog = prog; module->kind = kind; module->info = info; drgn_object_init(&module->object, prog); // Linux userspace core dumps usually filter out file-backed mappings // (see coredump_filter in core(5)), so we need the loaded file to read // the text. Additionally, .eh_frame is in the loaded file and not the // debug file. // // Linux kernel core dumps preserve the main kernel and kernel module // text, and the kernel doesn't use .eh_frame, so we don't need the // loaded file for the kernel. if (prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL && (kind == DRGN_MODULE_MAIN || kind == DRGN_MODULE_RELOCATABLE)) module->loaded_file_status = DRGN_MODULE_FILE_DONT_NEED; else module->loaded_file_status = DRGN_MODULE_FILE_WANT; module->debug_file_status = DRGN_MODULE_FILE_WANT; module->name = strdup(name); if (!module->name) { err = &drgn_enomem; goto err_module; } if (it.entry) { module->next_same_name = *it.entry; *it.entry = module; } else if (drgn_module_table_insert_searched(&prog->dbinfo.modules, &module, hp, NULL) < 0) { err = &drgn_enomem; goto err_name; } if (kind == DRGN_MODULE_MAIN) prog->dbinfo.main_module = module; prog->dbinfo.modules_generation++; drgn_elf_file_dwarf_table_init(&module->split_dwarf_files); drgn_module_section_address_map_init(&module->section_addresses); SWITCH_ENUM(module->kind) { case DRGN_MODULE_MAIN: drgn_log_debug(prog, "created main module %s", module->name); break; case DRGN_MODULE_SHARED_LIBRARY: drgn_log_debug(prog, "created shared library module %s@0x%" PRIx64, module->name, module->info); break; case DRGN_MODULE_VDSO: drgn_log_debug(prog, "created vDSO module %s@0x%" PRIx64, module->name, module->info); break; case DRGN_MODULE_RELOCATABLE: drgn_log_debug(prog, "created relocatable module %s@0x%" PRIx64, module->name, module->info); break; case DRGN_MODULE_EXTRA: drgn_log_debug(prog, "created extra module %s 0x%" PRIx64, module->name, module->info); break; default: UNREACHABLE(); } *ret = module; if (new_ret) *new_ret = true; return NULL; err_name: free(module->name); err_module: drgn_object_deinit(&module->object); free(module); return err; } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_main(struct drgn_program *prog, const char *name) { if (name && prog->dbinfo.main_module && strcmp(prog->dbinfo.main_module->name, name) != 0) return NULL; return prog->dbinfo.main_module; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_find_or_create_main(struct drgn_program *prog, const char *name, struct drgn_module **ret, bool *new_ret) { return drgn_module_find_or_create(prog, DRGN_MODULE_MAIN, name, 0, ret, new_ret); } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_shared_library(struct drgn_program *prog, const char *name, uint64_t dynamic_address) { return drgn_module_find(prog, DRGN_MODULE_SHARED_LIBRARY, name, dynamic_address); } LIBDRGN_PUBLIC struct drgn_error * drgn_module_find_or_create_shared_library(struct drgn_program *prog, const char *name, uint64_t dynamic_address, struct drgn_module **ret, bool *new_ret) { return drgn_module_find_or_create(prog, DRGN_MODULE_SHARED_LIBRARY, name, dynamic_address, ret, new_ret); } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_vdso(struct drgn_program *prog, const char *name, uint64_t dynamic_address) { return drgn_module_find(prog, DRGN_MODULE_VDSO, name, dynamic_address); } LIBDRGN_PUBLIC struct drgn_error *drgn_module_find_or_create_vdso(struct drgn_program *prog, const char *name, uint64_t dynamic_address, struct drgn_module **ret, bool *new_ret) { return drgn_module_find_or_create(prog, DRGN_MODULE_VDSO, name, dynamic_address, ret, new_ret); } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_relocatable(struct drgn_program *prog, const char *name, uint64_t address) { return drgn_module_find(prog, DRGN_MODULE_RELOCATABLE, name, address); } LIBDRGN_PUBLIC struct drgn_error * drgn_module_find_or_create_relocatable(struct drgn_program *prog, const char *name, uint64_t address, struct drgn_module **ret, bool *new_ret) { return drgn_module_find_or_create(prog, DRGN_MODULE_RELOCATABLE, name, address, ret, new_ret); } LIBDRGN_PUBLIC struct drgn_module *drgn_module_find_extra(struct drgn_program *prog, const char *name, uint64_t id) { return drgn_module_find(prog, DRGN_MODULE_EXTRA, name, id); } LIBDRGN_PUBLIC struct drgn_error *drgn_module_find_or_create_extra(struct drgn_program *prog, const char *name, uint64_t id, struct drgn_module **ret, bool *new_ret) { return drgn_module_find_or_create(prog, DRGN_MODULE_EXTRA, name, id, ret, new_ret); } static void drgn_module_clear_wanted_supplementary_debug_file(struct drgn_module *module) { struct drgn_module_wanted_supplementary_file *wanted = module->wanted_supplementary_debug_file; if (wanted) { free(wanted->checksum_str); if (wanted->file != module->loaded_file && wanted->file != module->debug_file) drgn_elf_file_destroy(wanted->file); free(wanted); module->wanted_supplementary_debug_file = NULL; } } // Note: this doesn't remove the module from the module tables. static void drgn_module_destroy(struct drgn_module *module) { drgn_module_free_section_addresses(module); drgn_module_section_address_map_deinit(&module->section_addresses); drgn_module_orc_info_deinit(module); drgn_module_dwarf_info_deinit(module); drgn_module_clear_wanted_supplementary_debug_file(module); drgn_elf_file_destroy(module->gnu_debugdata_file); drgn_elf_file_destroy(module->supplementary_debug_file); if (module->debug_file != module->loaded_file) drgn_elf_file_destroy(module->debug_file); drgn_elf_file_destroy(module->loaded_file); if (module->address_ranges != &module->single_address_range) free(module->address_ranges); free(module->build_id); free(module->name); drgn_object_deinit(&module->object); free(module); } static void drgn_module_delete_address_ranges(struct drgn_module *module) { for (size_t i = 0; i < module->num_address_ranges; i++) { drgn_module_address_tree_delete_entry(&module->prog->dbinfo.modules_by_address, &module->address_ranges[i]); } if (module->address_ranges != &module->single_address_range) free(module->address_ranges); } void drgn_module_delete(struct drgn_module *module) { assert(!module->loaded_file); assert(!module->debug_file); drgn_module_delete_address_ranges(module); // So drgn_module_destroy() doesn't free it again. module->address_ranges = NULL; const char *name = module->name; struct drgn_module_table_iterator it = drgn_module_table_search(&module->prog->dbinfo.modules, &name); if (*it.entry == module && !module->next_same_name) { drgn_module_table_delete_iterator(&module->prog->dbinfo.modules, it); } else { struct drgn_module **modulep = it.entry; while (*modulep != module) modulep = &(*modulep)->next_same_name; *modulep = module->next_same_name; } if (module->kind == DRGN_MODULE_MAIN) module->prog->dbinfo.main_module = NULL; module->prog->dbinfo.modules_generation++; drgn_module_destroy(module); } LIBDRGN_PUBLIC struct drgn_program *drgn_module_program(const struct drgn_module *module) { return module->prog; } LIBDRGN_PUBLIC enum drgn_module_kind drgn_module_kind(const struct drgn_module *module) { return module->kind; } LIBDRGN_PUBLIC const char *drgn_module_name(const struct drgn_module *module) { return module->name; } LIBDRGN_PUBLIC uint64_t drgn_module_info(const struct drgn_module *module) { return module->info; } LIBDRGN_PUBLIC bool drgn_module_num_address_ranges(const struct drgn_module *module, size_t *ret) { *ret = module->num_address_ranges; return module->address_ranges != NULL; } LIBDRGN_PUBLIC bool drgn_module_address_range(const struct drgn_module *module, size_t i, uint64_t *start_ret, uint64_t *end_ret) { if (i >= module->num_address_ranges) return false; *start_ret = module->address_ranges[i].start; *end_ret = module->address_ranges[i].end; return true; } static struct drgn_error * drgn_check_module_address_range_overlap(struct drgn_module *module, uint64_t start, uint64_t end) { for (auto it = drgn_module_address_tree_search_le(&module->prog->dbinfo.modules_by_address, &start); it.entry && it.entry->start < end; it = drgn_module_address_tree_next(it)) { if (start < it.entry->end && it.entry->module != module) { return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT, "%s [0x%" PRIx64 ", 0x%" PRIx64 ") overlaps " "%s [0x%" PRIx64 ", 0x%" PRIx64 ")", module->name, start, end, it.entry->module->name, it.entry->start, it.entry->end); } } return NULL; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_set_address_range(struct drgn_module *module, uint64_t start, uint64_t end) { struct drgn_error *err; // This is a special case instead of a wrapper around // drgn_module_set_address_ranges() so we can avoid allocating memory. // Since the old address range might be module->single_address_range, // this has to do things in a different order. if (start >= end) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "invalid module address range"); } err = drgn_check_module_address_range_overlap(module, start, end); if (err) return err; drgn_module_delete_address_ranges(module); module->single_address_range.start = start; module->single_address_range.end = end; module->single_address_range.module = module; int r = drgn_module_address_tree_insert(&module->prog->dbinfo.modules_by_address, &module->single_address_range, NULL); (void)r; assert(r > 0); // We checked for overlap. module->address_ranges = &module->single_address_range; module->num_address_ranges = 1; return NULL; } static int drgn_module_address_range_compare(const void *_a, const void *_b) { const struct drgn_module_address_range *a = _a; const struct drgn_module_address_range *b = _b; return (a->start > b->start) - (a->start < b->start); } LIBDRGN_PUBLIC struct drgn_error *drgn_module_set_address_ranges(struct drgn_module *module, uint64_t ranges[][2], size_t num_ranges) { struct drgn_error *err; if (num_ranges == 1) { return drgn_module_set_address_range(module, ranges[0][0], ranges[0][1]); } _cleanup_free_ struct drgn_module_address_range *address_ranges = NULL; if (num_ranges) { address_ranges = malloc_array(num_ranges, sizeof(*address_ranges)); if (!address_ranges) return &drgn_enomem; for (size_t i = 0; i < num_ranges; i++) { if (ranges[i][0] >= ranges[i][1]) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "invalid module address range"); } err = drgn_check_module_address_range_overlap(module, ranges[i][0], ranges[i][1]); if (err) return err; address_ranges[i].start = ranges[i][0]; address_ranges[i].end = ranges[i][1]; address_ranges[i].module = module; } qsort(address_ranges, num_ranges, sizeof(address_ranges[0]), drgn_module_address_range_compare); for (size_t i = 1; i < num_ranges; i++) { if (address_ranges[i].start < address_ranges[i - 1].end) { return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT, "%s [0x%" PRIx64 ", 0x%" PRIx64 ") overlaps " "[0x%" PRIx64 ", 0x%" PRIx64 ")", module->name, address_ranges[i - 1].start, address_ranges[i - 1].end, address_ranges[i].start, address_ranges[i].end); } } } drgn_module_delete_address_ranges(module); for (size_t i = 0; i < num_ranges; i++) { int r = drgn_module_address_tree_insert(&module->prog->dbinfo.modules_by_address, &address_ranges[i], NULL); (void)r; assert(r > 0); // We checked for overlap. } if (num_ranges) { module->address_ranges = no_cleanup_ptr(address_ranges); } else { // We need a non-NULL pointer to distinguish this from the unset // case. module->address_ranges = &module->single_address_range; } module->num_address_ranges = num_ranges; return NULL; } LIBDRGN_PUBLIC void drgn_module_unset_address_ranges(struct drgn_module *module) { drgn_module_delete_address_ranges(module); module->address_ranges = NULL; module->num_address_ranges = 0; } LIBDRGN_PUBLIC bool drgn_module_contains_address(const struct drgn_module *module, uint64_t address) { for (size_t i = 0; i < module->num_address_ranges; i++) { if (module->address_ranges[i].start <= address && address < module->address_ranges[i].end) return true; } return false; } LIBDRGN_PUBLIC const char *drgn_module_build_id(const struct drgn_module *module, const void **raw_ret, size_t *raw_len_ret) { if (raw_ret) *raw_ret = module->build_id; if (raw_len_ret) *raw_len_ret = module->build_id_len; return module->build_id_str; } static void *drgn_module_alloc_build_id(size_t build_id_len) { size_t alloc_size; if (__builtin_mul_overflow(build_id_len, 3U, &alloc_size) || __builtin_add_overflow(alloc_size, 1U, &alloc_size)) return NULL; return malloc(alloc_size); } static void drgn_module_set_build_id_impl(struct drgn_module *module, const void *build_id, size_t build_id_len, void *build_id_buf) { module->build_id = build_id_buf; memcpy(module->build_id, build_id, build_id_len); module->build_id_len = build_id_len; module->build_id_str = (char *)build_id_buf + build_id_len; hexlify(build_id, build_id_len, module->build_id_str); module->build_id_str[2 * build_id_len] = '\0'; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_set_build_id(struct drgn_module *module, const void *build_id, size_t build_id_len) { if (build_id_len == 0) { free(module->build_id); module->build_id = NULL; module->build_id_len = 0; module->build_id_str = NULL; return NULL; } char *build_id_buf = drgn_module_alloc_build_id(build_id_len); if (!build_id_buf) return &drgn_enomem; free(module->build_id); drgn_module_set_build_id_impl(module, build_id, build_id_len, build_id_buf); return NULL; } static struct drgn_error * drgn_module_section_addresses_allowed(struct drgn_module *module, bool modify) { if (module->kind != DRGN_MODULE_RELOCATABLE) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "section addresses are only supported for relocatable modules"); } if (modify && (module->loaded_file || module->debug_file)) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "section addresses cannot be modified after file is set"); } return NULL; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_get_section_address(struct drgn_module *module, const char *name, uint64_t *ret) { struct drgn_error *err = drgn_module_section_addresses_allowed(module, false); if (err) return err; struct drgn_module_section_address_map_iterator it = drgn_module_section_address_map_search(&module->section_addresses, (char **)&name); if (!it.entry) return &drgn_not_found; *ret = it.entry->value; return NULL; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_set_section_address(struct drgn_module *module, const char *name, uint64_t address) { struct drgn_error *err = drgn_module_section_addresses_allowed(module, true); if (err) return err; struct hash_pair hp = drgn_module_section_address_map_hash((char **)&name); struct drgn_module_section_address_map_iterator it = drgn_module_section_address_map_search_hashed(&module->section_addresses, (char **)&name, hp); if (it.entry) { it.entry->value = address; return NULL; } struct drgn_module_section_address_map_entry entry = { .key = strdup(name), .value = address, }; if (!entry.key) return &drgn_enomem; if (drgn_module_section_address_map_insert_searched(&module->section_addresses, &entry, hp, NULL) < 0) { free(entry.key); return &drgn_enomem; } module->section_addresses_generation++; return NULL; } struct drgn_error *drgn_module_delete_section_address(struct drgn_module *module, const char *name) { struct drgn_error *err = drgn_module_section_addresses_allowed(module, true); if (err) return err; struct hash_pair hp = drgn_module_section_address_map_hash((char **)&name); struct drgn_module_section_address_map_iterator it = drgn_module_section_address_map_search_hashed(&module->section_addresses, (char **)&name, hp); if (!it.entry) return &drgn_not_found; _cleanup_free_ _unused_ char *key_to_free = it.entry->key; drgn_module_section_address_map_delete_iterator_hashed(&module->section_addresses, it, hp); module->section_addresses_generation++; return NULL; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_num_section_addresses(struct drgn_module *module, size_t *ret) { struct drgn_error *err = drgn_module_section_addresses_allowed(module, false); if (err) return err; *ret = drgn_module_section_address_map_size(&module->section_addresses); return NULL; } struct drgn_module_section_address_iterator { struct drgn_module *module; struct drgn_module_section_address_map_iterator map_it; uint64_t generation; }; LIBDRGN_PUBLIC struct drgn_error * drgn_module_section_address_iterator_create(struct drgn_module *module, struct drgn_module_section_address_iterator **ret) { struct drgn_error *err = drgn_module_section_addresses_allowed(module, false); if (err) return err; struct drgn_module_section_address_iterator *it = malloc(sizeof(*it)); if (!it) return &drgn_enomem; it->module = module; it->map_it = drgn_module_section_address_map_first(&module->section_addresses); it->generation = module->section_addresses_generation; *ret = it; return NULL; } LIBDRGN_PUBLIC void drgn_module_section_address_iterator_destroy(struct drgn_module_section_address_iterator *it) { free(it); } LIBDRGN_PUBLIC struct drgn_module * drgn_module_section_address_iterator_module(struct drgn_module_section_address_iterator *it) { return it->module; } LIBDRGN_PUBLIC struct drgn_error * drgn_module_section_address_iterator_next(struct drgn_module_section_address_iterator *it, const char **name_ret, uint64_t *address_ret) { if (it->map_it.entry) { if (it->generation != it->module->section_addresses_generation) { return drgn_error_create(DRGN_ERROR_OTHER, "section addresses changed during iteration"); } *name_ret = it->map_it.entry->key; if (address_ret) *address_ret = it->map_it.entry->value; it->map_it = drgn_module_section_address_map_next(it->map_it); } else { *name_ret = NULL; } return NULL; } LIBDRGN_PUBLIC enum drgn_module_file_status drgn_module_loaded_file_status(const struct drgn_module *module) { return module->loaded_file_status; } static bool drgn_can_change_module_file_status(enum drgn_module_file_status old_status, enum drgn_module_file_status new_status) { SWITCH_ENUM(old_status) { case DRGN_MODULE_FILE_WANT: case DRGN_MODULE_FILE_DONT_WANT: case DRGN_MODULE_FILE_DONT_NEED: SWITCH_ENUM(new_status) { case DRGN_MODULE_FILE_WANT: case DRGN_MODULE_FILE_DONT_WANT: case DRGN_MODULE_FILE_DONT_NEED: return true; case DRGN_MODULE_FILE_HAVE: case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: default: return false; } case DRGN_MODULE_FILE_HAVE: return new_status == DRGN_MODULE_FILE_HAVE; case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: SWITCH_ENUM(new_status) { case DRGN_MODULE_FILE_WANT: case DRGN_MODULE_FILE_DONT_WANT: case DRGN_MODULE_FILE_DONT_NEED: case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: return true; case DRGN_MODULE_FILE_HAVE: default: return false; } default: UNREACHABLE(); } } LIBDRGN_PUBLIC bool drgn_module_set_loaded_file_status(struct drgn_module *module, enum drgn_module_file_status status) { if (!drgn_can_change_module_file_status(module->loaded_file_status, status)) return false; module->loaded_file_status = status; return true; } LIBDRGN_PUBLIC bool drgn_module_wants_loaded_file(const struct drgn_module *module) { SWITCH_ENUM(module->loaded_file_status) { case DRGN_MODULE_FILE_WANT: return true; case DRGN_MODULE_FILE_HAVE: case DRGN_MODULE_FILE_DONT_WANT: case DRGN_MODULE_FILE_DONT_NEED: return false; case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: default: UNREACHABLE(); } } LIBDRGN_PUBLIC enum drgn_module_file_status drgn_module_debug_file_status(const struct drgn_module *module) { return module->debug_file_status; } LIBDRGN_PUBLIC bool drgn_module_set_debug_file_status(struct drgn_module *module, enum drgn_module_file_status status) { if (!drgn_can_change_module_file_status(module->debug_file_status, status)) return false; if (module->debug_file_status == DRGN_MODULE_FILE_WANT_SUPPLEMENTARY && status != DRGN_MODULE_FILE_WANT_SUPPLEMENTARY) drgn_module_clear_wanted_supplementary_debug_file(module); module->debug_file_status = status; return true; } LIBDRGN_PUBLIC bool drgn_module_wants_debug_file(const struct drgn_module *module) { SWITCH_ENUM(module->debug_file_status) { case DRGN_MODULE_FILE_WANT: case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: return true; case DRGN_MODULE_FILE_HAVE: case DRGN_MODULE_FILE_DONT_WANT: case DRGN_MODULE_FILE_DONT_NEED: return false; default: UNREACHABLE(); } } LIBDRGN_PUBLIC const char *drgn_module_loaded_file_path(const struct drgn_module *module) { return module->loaded_file ? module->loaded_file->path : NULL; } LIBDRGN_PUBLIC uint64_t drgn_module_loaded_file_bias(const struct drgn_module *module) { return module->loaded_file_bias; } LIBDRGN_PUBLIC const char *drgn_module_debug_file_path(const struct drgn_module *module) { return module->debug_file ? module->debug_file->path : NULL; } LIBDRGN_PUBLIC uint64_t drgn_module_debug_file_bias(const struct drgn_module *module) { return module->debug_file_bias; } LIBDRGN_PUBLIC enum drgn_supplementary_file_kind drgn_module_supplementary_debug_file_kind(const struct drgn_module *module) { return module->supplementary_debug_file ? DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK : DRGN_SUPPLEMENTARY_FILE_NONE; } LIBDRGN_PUBLIC const char * drgn_module_supplementary_debug_file_path(const struct drgn_module *module) { return module->supplementary_debug_file ? module->supplementary_debug_file->path : NULL; } LIBDRGN_PUBLIC enum drgn_supplementary_file_kind drgn_module_wanted_supplementary_debug_file(struct drgn_module *module, const char **debug_file_path_ret, const char **supplementary_path_ret, const void **checksum_ret, size_t *checksum_len_ret) { struct drgn_module_wanted_supplementary_file *wanted = module->wanted_supplementary_debug_file; if (debug_file_path_ret) *debug_file_path_ret = wanted ? wanted->file->path : NULL; if (supplementary_path_ret) *supplementary_path_ret = wanted ? wanted->supplementary_path : NULL; if (checksum_ret) *checksum_ret = wanted ? wanted->checksum : NULL; if (checksum_len_ret) *checksum_len_ret = wanted ? wanted->checksum_len : 0; return wanted ? DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK : DRGN_SUPPLEMENTARY_FILE_NONE; } LIBDRGN_PUBLIC struct drgn_error * drgn_module_object(const struct drgn_module *module, struct drgn_object *ret) { return drgn_object_copy(ret, &module->object); } LIBDRGN_PUBLIC struct drgn_error * drgn_module_set_object(struct drgn_module *module, const struct drgn_object *obj) { return drgn_object_copy(&module->object, obj); } static struct drgn_error * drgn_program_register_debug_info_finder_impl(struct drgn_program *prog, struct drgn_debug_info_finder *finder, const char *name, const struct drgn_debug_info_finder_ops *ops, void *arg, size_t enable_index) { struct drgn_error *err; bool should_free = !finder; if (finder) { finder->handler.name = name; } else { finder = malloc(sizeof(*finder)); if (!finder) return &drgn_enomem; finder->handler.name = strdup(name); if (!finder->handler.name) { free(finder); return &drgn_enomem; } } finder->handler.free = should_free; finder->ops = *ops; finder->arg = arg; err = drgn_handler_list_register(&prog->dbinfo.debug_info_finders, &finder->handler, enable_index, "module debug info finder"); if (err && should_free) { free((char *)finder->handler.name); free(finder); } return err; } LIBDRGN_PUBLIC struct drgn_error * drgn_program_register_debug_info_finder(struct drgn_program *prog, const char *name, const struct drgn_debug_info_finder_ops *ops, void *arg, size_t enable_index) { return drgn_program_register_debug_info_finder_impl(prog, NULL, name, ops, arg, enable_index); } LIBDRGN_PUBLIC struct drgn_error * drgn_program_registered_debug_info_finders(struct drgn_program *prog, const char ***names_ret, size_t *count_ret) { return drgn_handler_list_registered(&prog->dbinfo.debug_info_finders, names_ret, count_ret); } LIBDRGN_PUBLIC struct drgn_error * drgn_program_set_enabled_debug_info_finders(struct drgn_program *prog, const char * const *names, size_t count) { return drgn_handler_list_set_enabled(&prog->dbinfo.debug_info_finders, names, count, "module debug info finder"); } LIBDRGN_PUBLIC struct drgn_error * drgn_program_enabled_debug_info_finders(struct drgn_program *prog, const char ***names_ret, size_t *count_ret) { return drgn_handler_list_enabled(&prog->dbinfo.debug_info_finders, names_ret, count_ret); } LIBDRGN_PUBLIC struct drgn_debug_info_options * drgn_program_debug_info_options(struct drgn_program *prog) { return &prog->dbinfo.options; } static struct drgn_error * drgn_module_set_wanted_gnu_debugaltlink(struct drgn_module *module, struct drgn_elf_file *file) { struct drgn_error *err; struct drgn_program *prog = module->prog; // We don't cache .gnu_debugaltlink, and it doesn't need relocation, so // don't use drgn_elf_file_read_section(). Elf_Data *data; err = read_elf_section(file->scns[DRGN_SCN_GNU_DEBUGALTLINK], &data); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, "%s: couldn't read .gnu_debugaltlink; ignoring debug info: ", file->path); drgn_error_destroy(err); err = NULL; } return err; } const char *debugaltlink = data->d_buf; const char *nul = memchr(debugaltlink, 0, data->d_size); if (!nul || nul + 1 == debugaltlink + data->d_size) { drgn_log_debug(prog, "%s: couldn't parse .gnu_debugaltlink; ignoring debug info", file->path); return NULL; } const void *build_id = nul + 1; size_t build_id_len = debugaltlink + data->d_size - (nul + 1); _cleanup_free_ char *build_id_str = ahexlify(build_id, build_id_len); if (!build_id_str) return &drgn_enomem; drgn_log_debug(prog, "%s has gnu_debugaltlink %s build ID %s", file->path, debugaltlink, build_id_str); struct drgn_module_wanted_supplementary_file *wanted = malloc(sizeof(*wanted)); if (!wanted) return &drgn_enomem; *wanted = (struct drgn_module_wanted_supplementary_file){ .file = file, .supplementary_path = debugaltlink, .checksum = build_id, .checksum_len = build_id_len, .checksum_str = no_cleanup_ptr(build_id_str), .generation = ++prog->dbinfo.supplementary_file_generation, }; drgn_module_clear_wanted_supplementary_debug_file(module); module->wanted_supplementary_debug_file = wanted; module->debug_file_status = DRGN_MODULE_FILE_WANT_SUPPLEMENTARY; return NULL; } static struct drgn_error * drgn_module_copy_section_addresses(struct drgn_module *module, struct drgn_elf_file *file) { if (!file->is_relocatable) return NULL; size_t shdrnum; if (elf_getshdrnum(file->elf, &shdrnum)) return drgn_error_libelf(); file->sections_with_address = drgn_bitmap_create(shdrnum); if (!file->sections_with_address) return &drgn_enomem; if (drgn_module_section_address_map_empty(&module->section_addresses)) return NULL; size_t shstrndx; if (elf_getshdrstrndx(file->elf, &shstrndx)) return drgn_error_libelf(); Elf_Scn *scn = NULL; while ((scn = elf_nextscn(file->elf, scn))) { GElf_Shdr *shdr, shdr_mem; shdr = gelf_getshdr(scn, &shdr_mem); if (!shdr) return drgn_error_libelf(); char *scnname = elf_strptr(file->elf, shstrndx, shdr->sh_name); if (!scnname) return drgn_error_libelf(); struct drgn_module_section_address_map_iterator it = drgn_module_section_address_map_search(&module->section_addresses, &scnname); if (!it.entry) continue; shdr->sh_addr = it.entry->value; if (!gelf_update_shdr(scn, shdr)) return drgn_error_libelf(); drgn_bitmap_set_bit(file->sections_with_address, elf_ndxscn(scn)); } return NULL; } static bool elf_main_bias(struct drgn_program *prog, Elf *elf, uint64_t *ret) { GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr(elf, &ehdr_mem); if (!ehdr) { drgn_log_debug(prog, "gelf_getehdr: %s", elf_errmsg(-1)); return false; } size_t phnum; if (elf_getphdrnum(elf, &phnum) != 0) { drgn_log_debug(prog, "elf_getphdrnum: %s", elf_errmsg(-1)); return false; } uint64_t phdr_vaddr; bool have_phdr_vaddr = false; for (size_t i = 0; i < phnum; i++) { GElf_Phdr phdr_mem, *phdr = gelf_getphdr(elf, i, &phdr_mem); if (!phdr) { drgn_log_debug(prog, "gelf_getphdr: %s", elf_errmsg(-1)); return false; } if (phdr->p_type == PT_LOAD && phdr->p_offset <= ehdr->e_phoff && ehdr->e_phoff < phdr->p_offset + phdr->p_filesz) { phdr_vaddr = ehdr->e_phoff - phdr->p_offset + phdr->p_vaddr; have_phdr_vaddr = true; } } if (!have_phdr_vaddr) { drgn_log_debug(prog, "file does not have loadable segment containing e_phoff"); return false; } *ret = prog->auxv.at_phdr - phdr_vaddr; return true; } static bool elf_dso_bias(struct drgn_program *prog, Elf *elf, uint64_t dynamic_address, uint64_t *ret) { size_t phnum; if (elf_getphdrnum(elf, &phnum) != 0) { drgn_log_debug(prog, "elf_getphdrnum: %s", elf_errmsg(-1)); return false; } for (size_t i = 0; i < phnum; i++) { GElf_Phdr phdr_mem, *phdr = gelf_getphdr(elf, i, &phdr_mem); if (!phdr) { drgn_log_debug(prog, "gelf_getphdr: %s", elf_errmsg(-1)); return false; } if (phdr->p_type == PT_DYNAMIC) { *ret = dynamic_address - phdr->p_vaddr; drgn_log_debug(prog, "got bias 0x%" PRIx64 " from PT_DYNAMIC program header", *ret); return true; } } drgn_log_debug(prog, "file does not have PT_DYNAMIC program header"); return false; } static bool drgn_module_elf_file_bias(struct drgn_module *module, struct drgn_elf_file *file, uint64_t *ret) { struct drgn_program *prog = module->prog; SWITCH_ENUM(module->kind) { case DRGN_MODULE_MAIN: if (prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL) { *ret = prog->vmcoreinfo.kaslr_offset; drgn_log_debug(prog, "got bias 0x%" PRIx64 " from VMCOREINFO", *ret); return true; } else { return elf_main_bias(prog, file->elf, ret); } case DRGN_MODULE_SHARED_LIBRARY: case DRGN_MODULE_VDSO: return elf_dso_bias(prog, file->elf, module->info, ret); case DRGN_MODULE_EXTRA: { size_t num_address_ranges; if (drgn_module_num_address_ranges(module, &num_address_ranges) && num_address_ranges == 1) { uint64_t start, end; drgn_module_address_range(module, 0, &start, &end); uint64_t elf_start, elf_end; if (!drgn_elf_file_address_range(file, &elf_start, &elf_end)) return false; if (elf_start < elf_end) { *ret = start - elf_start; drgn_log_debug(prog, "got bias 0x%" PRIx64 " from ELF start address", *ret); return true; } } fallthrough; } case DRGN_MODULE_RELOCATABLE: default: *ret = 0; return true; } } static bool drgn_module_should_set_address_range_from_elf_file(struct drgn_module *module) { if (module->address_ranges) return false; SWITCH_ENUM(module->kind) { case DRGN_MODULE_MAIN: case DRGN_MODULE_SHARED_LIBRARY: case DRGN_MODULE_VDSO: return true; case DRGN_MODULE_RELOCATABLE: case DRGN_MODULE_EXTRA: default: return false; } } // Takes ownership of file unless it is already owned by module. static struct drgn_error * drgn_module_maybe_use_elf_file(struct drgn_module *module, struct drgn_elf_file *file, bool is_gnu_debugaltlink_file) { struct drgn_error *err; struct drgn_program *prog = module->prog; struct drgn_elf_file *gnu_debugaltlink_file = NULL; bool use_loaded, has_dwarf, use_debug; if (is_gnu_debugaltlink_file) { assert(module->debug_file_status == DRGN_MODULE_FILE_WANT_SUPPLEMENTARY); gnu_debugaltlink_file = file; file = module->wanted_supplementary_debug_file->file; use_loaded = false; has_dwarf = use_debug = true; } else { // We should only be here if we want a file. assert(drgn_module_wants_file(module)); use_loaded = module->loaded_file_status == DRGN_MODULE_FILE_WANT && file->is_loadable; has_dwarf = drgn_elf_file_has_dwarf(file); use_debug = drgn_module_wants_debug_file(module) && has_dwarf; } _cleanup_free_ void *build_id_buf = NULL; if (!is_gnu_debugaltlink_file && use_debug && file->scns[DRGN_SCN_GNU_DEBUGALTLINK]) { // If we're trying to reuse a debug file that wants a // supplementary file, then don't reset it, otherwise we'll free // the file that we're trying to reuse. if (!module->wanted_supplementary_debug_file || module->wanted_supplementary_debug_file->file != file) { err = drgn_module_set_wanted_gnu_debugaltlink(module, file); if (err) goto unused; } if (!use_loaded && module->wanted_supplementary_debug_file && module->wanted_supplementary_debug_file->file == file) return NULL; use_debug = false; } if (!use_loaded && !use_debug) { if (file->is_loadable) { drgn_log_debug(prog, "%s is loadable, but don't want loaded file; ignoring", file->path); } else if (has_dwarf) { drgn_log_debug(prog, "%s has debug info, but don't want debug info; ignoring", file->path); } else { drgn_log_debug(prog, "%s is not loadable and no debug info; ignoring", file->path); } err = NULL; goto unused; } // Get everything that might fail before we commit to using the file. const void *elf_build_id; ssize_t elf_build_id_len = 0; if (module->build_id_len == 0) { elf_build_id_len = drgn_elf_gnu_build_id(file->elf, &elf_build_id); if (elf_build_id_len < 0) { drgn_log_debug(prog, "%s: %s", file->path, elf_errmsg(-1)); err = NULL; goto unused; } if (elf_build_id_len > 0) { build_id_buf = drgn_module_alloc_build_id(elf_build_id_len); if (!build_id_buf) { err = &drgn_enomem; goto unused; } } } if (file != module->loaded_file && file != module->debug_file) { err = drgn_module_copy_section_addresses(module, file); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, "%s: ", file->path); drgn_error_destroy(err); err = NULL; } goto unused; } } uint64_t bias; if (!drgn_module_elf_file_bias(module, file, &bias)) { err = NULL; goto unused; } uint64_t elf_start = 0, elf_end = 0; if (drgn_module_should_set_address_range_from_elf_file(module)) { if (!drgn_elf_file_address_range(file, &elf_start, &elf_end)) { drgn_log_debug(prog, "%s: %s", file->path, elf_errmsg(-1)); err = NULL; goto unused; } elf_start += bias; elf_end += bias; if (elf_start >= elf_end) { drgn_log_debug(prog, "%s: address range is invalid", file->path); } } // At this point, we've committed to using the file. Nothing after this // is allowed to fail. if (use_loaded && use_debug) { drgn_log_info(prog, "%s: using loadable file with debug info %s", module->name, file->path); } else if (use_loaded) { drgn_log_info(prog, "%s: using loadable file %s", module->name, file->path); } else if (is_gnu_debugaltlink_file) { drgn_log_info(prog, "%s: using debug info file %s with supplementary file %s", module->name, file->path, gnu_debugaltlink_file->path); } else { drgn_log_info(prog, "%s: using debug info file %s", module->name, file->path); } // If we got a build ID or address range earlier, install them. if (elf_build_id_len > 0) { drgn_module_set_build_id_impl(module, elf_build_id, elf_build_id_len, no_cleanup_ptr(build_id_buf)); drgn_log_debug(prog, "%s: set build ID %s from file", module->name, module->build_id_str); } if (elf_start < elf_end) { drgn_log_debug(prog, "%s: set address range 0x%" PRIx64 "-0x%" PRIx64 " from file", module->name, elf_start, elf_end); err = drgn_module_set_address_range(module, elf_start, elf_end); // This can only fail if the address range is invalid, which we // just checked for. assert(!err); } if (use_loaded) { module->loaded_file = file; module->loaded_file_bias = bias; module->loaded_file_status = DRGN_MODULE_FILE_HAVE; module->elf_symtab_pending_files |= DRGN_MODULE_FILE_MASK_LOADED; } if (use_debug) { module->debug_file = file; module->debug_file_bias = bias; module->supplementary_debug_file = gnu_debugaltlink_file; drgn_module_clear_wanted_supplementary_debug_file(module); module->debug_file_status = DRGN_MODULE_FILE_HAVE; module->pending_indexing_next = prog->dbinfo.modules_pending_indexing; prog->dbinfo.modules_pending_indexing = module; prog->tried_main_language = false; module->elf_symtab_pending_files |= DRGN_MODULE_FILE_MASK_DEBUG; // In case primitive types have been created by drgn before // loading the main debug file (e.g. by reading VMCOREINFO), // clear this cache so we can look them up from the debug info. // See https://github.com/osandov/drgn/issues/569 for more // details. if (module->kind == DRGN_MODULE_MAIN) memset(module->prog->primitive_types, 0, sizeof(module->prog->primitive_types)); } if (!prog->has_platform) { drgn_log_debug(prog, "setting program platform from %s", file->path); drgn_program_set_platform(prog, &file->platform); } return NULL; unused: drgn_elf_file_destroy(gnu_debugaltlink_file); if (module->wanted_supplementary_debug_file && file == module->wanted_supplementary_debug_file->file) { module->wanted_supplementary_debug_file->file = NULL; drgn_module_clear_wanted_supplementary_debug_file(module); module->debug_file_status = DRGN_MODULE_FILE_WANT; } if (file != module->loaded_file && file != module->debug_file) drgn_elf_file_destroy(file); return err; } // Always takes ownership of fd_. Attempts to resolve the real path of path. static struct drgn_error * drgn_module_try_file_internal(struct drgn_module *module, const char *path, int fd_, bool check_build_id, const uint32_t *expected_crc) { struct drgn_error *err; struct drgn_program *prog = module->prog; _cleanup_close_ int fd = fd_; if (fd >= 0) { if (path) { drgn_log_debug(prog, "%s: trying %s with fd %d", module->name, path, fd); } else { drgn_log_debug(prog, "%s: trying fd %d", module->name, fd); } } else { fd = open(path, O_RDONLY); if (fd < 0) { drgn_log_debug(prog, "%s: %m", path); return NULL; } drgn_log_debug(prog, "%s: trying %s", module->name, path); } _cleanup_free_ char *canonical_path = fd_canonical_path(fd, path); if (!canonical_path) return &drgn_enomem; if (drgn_log_is_enabled(prog, DRGN_LOG_DEBUG) && (!path || strcmp(path, canonical_path) != 0)) drgn_log_debug(prog, "canonical path is %s", canonical_path); path = canonical_path; _cleanup_elf_end_ Elf *elf = dwelf_elf_begin(fd); if (!elf) { drgn_log_debug(prog, "%s: %s", path, elf_errmsg(-1)); return NULL; } if (elf_kind(elf) != ELF_K_ELF) { drgn_log_debug(prog, "%s: not an ELF file", path); return NULL; } // This code assumes that DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK is // the only kind of supplementary file, which is currently true. bool log_build_id = check_build_id || drgn_log_is_enabled(prog, DRGN_LOG_DEBUG); const void *elf_build_id; ssize_t elf_build_id_len; if (module->debug_file_status == DRGN_MODULE_FILE_WANT_SUPPLEMENTARY || (log_build_id && module->build_id_len > 0)) { elf_build_id_len = drgn_elf_gnu_build_id(elf, &elf_build_id); if (elf_build_id_len < 0) { drgn_log_debug(prog, "%s: %s%s", path, elf_errmsg(-1), check_build_id ? "" : "; ignoring build ID"); } } bool is_gnu_debugaltlink_file = false; if (module->debug_file_status == DRGN_MODULE_FILE_WANT_SUPPLEMENTARY && elf_build_id_len >= 0 && elf_build_id_len == module->wanted_supplementary_debug_file->checksum_len && memcmp(elf_build_id, module->wanted_supplementary_debug_file->checksum, elf_build_id_len) == 0) { drgn_log_debug(prog, "%s: %s build ID matches gnu_debugaltlink", module->name, path); is_gnu_debugaltlink_file = true; } else if (log_build_id && module->build_id_len > 0) { if (elf_build_id_len < 0) { if (check_build_id) return NULL; } else if (elf_build_id_len == module->build_id_len && memcmp(elf_build_id, module->build_id, elf_build_id_len) == 0) { drgn_log_debug(prog, "%s: %s build ID matches", module->name, path); } else { if (elf_build_id_len == 0) { drgn_log_debug(prog, "%s: %s is missing build ID%s", module->name, path, check_build_id ? "" : "; forcing"); } else { drgn_log_debug(prog, "%s: %s build ID does not match%s", module->name, path, check_build_id ? "" : "; forcing"); } if (check_build_id) return NULL; } } if (expected_crc) { size_t size; const void *rawfile = elf_rawfile(elf, &size); if (!rawfile) { drgn_log_debug(prog, "%s: %s", path, elf_errmsg(-1)); return NULL; } uint32_t crc = ~crc32_update(-1, rawfile, size); if (crc != *expected_crc) { drgn_log_debug(prog, "%s: %s CRC 0x%08" PRIx32 " does not match", module->name, path, crc); return NULL; } drgn_log_debug(prog, "%s: %s CRC matches", module->name, path); } struct drgn_elf_file *file; err = drgn_elf_file_create(module, path, fd, NULL, elf, &file); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, ""); drgn_error_destroy(err); err = NULL; } return err; } // fd and elf are owned by the drgn_elf_file now. fd = -1; elf = NULL; return drgn_module_maybe_use_elf_file(module, file, is_gnu_debugaltlink_file); } // Arbitrary limit on the number of bytes we'll allocate and read from the // program's memory at once when finding modules/debug info. static const uint64_t MAX_MEMORY_READ_FOR_DEBUG_INFO = UINT64_C(1048576); #define drgn_module_try_files_log(module, how_format, ...) \ ({ \ struct drgn_module *_module = (module); \ bool _want_loaded = _module->loaded_file_status == DRGN_MODULE_FILE_WANT;\ bool _want_debug = _module->debug_file_status == DRGN_MODULE_FILE_WANT; \ bool _want_supplementary_debug = _module->debug_file_status \ == DRGN_MODULE_FILE_WANT_SUPPLEMENTARY;\ drgn_log_debug(_module->prog, \ "%s (%s%s): " how_format " %s%s%s file%s", _module->name,\ _module->build_id_str ? "build ID " : "no build ID", \ _module->build_id_str ?: "", \ ## __VA_ARGS__, \ _want_loaded ? "loaded" : "", \ _want_loaded && (_want_debug || _want_supplementary_debug)\ ? " and " : "", \ _want_debug ? "debug" \ : _want_supplementary_debug ? "supplementary debug" : "",\ _want_loaded && (_want_debug || _want_supplementary_debug)\ ? "s" : ""); \ }) static struct drgn_error * drgn_module_try_vdso_in_core(struct drgn_module *module, const struct drgn_debug_info_options *options) { struct drgn_error *err; struct drgn_program *prog = module->prog; if (!options->try_embedded_vdso) return NULL; // The Linux kernel has included the entire vDSO in core dumps since // Linux kernel commit f47aef55d9a1 ("[PATCH] i386 vDSO: use // VM_ALWAYSDUMP") (in v2.6.20). Try to read it from program memory. // The vDSO in memory is always stripped. if (module->loaded_file_status != DRGN_MODULE_FILE_WANT) return NULL; size_t num_address_ranges; if (!drgn_module_num_address_ranges(module, &num_address_ranges)) { drgn_log_debug(prog, "vDSO address range is not known; " "can't read from program"); return NULL; } if (num_address_ranges != 1) { drgn_log_debug(prog, "vDSO has %s; can't read from program", num_address_ranges ? "multiple address ranges" : "empty address range"); return NULL; } uint64_t start, end; drgn_module_address_range(module, 0, &start, &end); uint64_t size = end - start; if (size > MAX_MEMORY_READ_FOR_DEBUG_INFO) { drgn_log_debug(prog, "vDSO is unreasonably large (%" PRIu64 " bytes); " "not reading from program", size); return NULL; } _cleanup_free_ char *image = malloc(size); if (!image) return &drgn_enomem; err = drgn_program_read_memory(prog, image, start, size, false); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, "couldn't read vDSO: "); drgn_error_destroy(err); err = NULL; } return err; } _cleanup_elf_end_ Elf *elf = elf_memory(image, size); if (!elf) { drgn_log_debug(prog, "couldn't read vDSO: %s", elf_errmsg(-1)); return NULL; } struct drgn_elf_file *file; err = drgn_elf_file_create(module, "[vdso]", -1, image, elf, &file); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, ""); drgn_error_destroy(err); err = NULL; } return err; } // image and elf are owned by the drgn_elf_file now. image = NULL; elf = NULL; drgn_log_debug(prog, "trying vDSO in %s", (module->prog->flags & DRGN_PROGRAM_IS_LIVE) ? "memory" : "core"); return drgn_module_maybe_use_elf_file(module, file, false); } static void drgn_module_try_supplementary_debug_file_log(struct drgn_module *module, const char *how) { const char *debug_file_path; const char *debugaltlink_path; if (drgn_module_wanted_supplementary_debug_file(module, &debug_file_path, &debugaltlink_path, NULL, NULL) != DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK) return; const char *debugaltlink_build_id_str = module->wanted_supplementary_debug_file->checksum_str; drgn_log_debug(module->prog, "%s: %s gnu_debugaltlink %s build ID %s in file %s", module->name, how, debugaltlink_path, debugaltlink_build_id_str, debug_file_path); } static struct drgn_error * drgn_module_try_standard_supplementary_files(struct drgn_module *module, const struct drgn_debug_info_options *options) { struct drgn_error *err; if (!options->try_supplementary) return NULL; const char *debug_file_path; const char *debugaltlink_path; if (drgn_module_wanted_supplementary_debug_file(module, &debug_file_path, &debugaltlink_path, NULL, NULL) != DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK) return NULL; drgn_module_try_supplementary_debug_file_log(module, "trying standard paths for"); STRING_BUILDER(sb); const char *slash; if (debugaltlink_path[0] == '/' || !(slash = strrchr(debug_file_path, '/'))) { // debugaltlink is absolute, or the debug file doesn't have a // directory component and is therefore in the current working // directory. Try debugaltlink directly. err = drgn_module_try_file_internal(module, debugaltlink_path, -1, true, NULL); } else { // Try $(dirname $path)/$debugaltlink. if (!string_builder_appendn(&sb, debug_file_path, slash + 1 - debug_file_path) || !string_builder_append(&sb, debugaltlink_path) || !string_builder_null_terminate(&sb)) return &drgn_enomem; err = drgn_module_try_file_internal(module, sb.str, -1, true, NULL); } if (err || module->debug_file_status != DRGN_MODULE_FILE_WANT_SUPPLEMENTARY) return err; // All of the Linux distributions that use gnu_debugaltlink that I'm // aware of (Debian, Fedora, SUSE, and their derivatives) put // gnu_debugaltlink files in a ".dwz" subdirectory under the debug // directory (e.g., "/usr/lib/debug/.dwz"). Try the path starting with // the ".dwz" directory under all of the configured debug directories. // This can help in a couple of cases: // // 1. When the gnu_debugaltlink path is absolute (which is the case on // Debian and its derivatives as of Debian 12/Ubuntu 23.10) and the // debug directory has been copied to a different path. See // https://bugs.launchpad.net/ubuntu/+source/gdb/+bug/1818918. // 2. When the gnu_debugaltlink path is relative (which is the case on // Fedora, SUSE, and their derivatives) and the debug file was found // outside of the debug directory. const char *dwz = strstr(debugaltlink_path, "/.dwz/"); if (dwz) { for (size_t i = 0; options->directories[i]; i++) { const char *debug_dir = options->directories[i]; sb.len = 0; if (!string_builder_append(&sb, debug_dir) || !string_builder_append(&sb, dwz) || !string_builder_null_terminate(&sb)) return &drgn_enomem; // Don't bother trying debugaltlink directly again. if (strcmp(sb.str, debugaltlink_path) == 0) continue; err = drgn_module_try_file_internal(module, sb.str, -1, true, NULL); if (err || module->debug_file_status != DRGN_MODULE_FILE_WANT_SUPPLEMENTARY) return err; } } return NULL; } static bool drgn_module_wanted_supplementary_debug_file_is_new(struct drgn_module *module, uint64_t orig_supplementary_file_generation) { return module->wanted_supplementary_debug_file && module->wanted_supplementary_debug_file->generation > orig_supplementary_file_generation; } struct drgn_error * drgn_module_try_standard_file(struct drgn_module *module, const struct drgn_debug_info_options *options, const char *path, int fd, bool check_build_id, const uint32_t *expected_crc) { struct drgn_error *err; uint64_t orig_supplementary_file_generation = module->prog->dbinfo.supplementary_file_generation; err = drgn_module_try_file_internal(module, path, fd, check_build_id, expected_crc); if (err) return err; // If the wanted supplementary debug file changed, try finding it again. if (drgn_module_wanted_supplementary_debug_file_is_new(module, orig_supplementary_file_generation)) { err = drgn_module_try_standard_supplementary_files(module, options); if (err) return err; } return NULL; } // An entry in /proc/$pid/map_files. struct drgn_map_files_segment { uint64_t start; uint64_t end; }; DEFINE_VECTOR(drgn_map_files_segment_vector, struct drgn_map_files_segment); static inline int drgn_map_files_segment_compare(const void *_a, const void *_b) { const struct drgn_map_files_segment *a = _a; const struct drgn_map_files_segment *b = _b; return (a->start > b->start) - (a->start < b->start); } static void drgn_debug_info_set_map_files_segments(struct drgn_debug_info *dbinfo, struct drgn_map_files_segment_vector *segments, bool sorted) { free(dbinfo->map_files_segments); drgn_map_files_segment_vector_shrink_to_fit(segments); drgn_map_files_segment_vector_steal(segments, &dbinfo->map_files_segments, &dbinfo->num_map_files_segments); // The Linux kernel always returns these entries in order, but sort it // just in case. if (!sorted) { qsort(dbinfo->map_files_segments, dbinfo->num_map_files_segments, sizeof(dbinfo->map_files_segments[0]), drgn_map_files_segment_compare); } } static struct drgn_error * drgn_module_try_proc_files_for_shared_library(struct drgn_module *module, const struct drgn_debug_info_options *options, bool *tried) { struct drgn_error *err; struct drgn_program *prog = module->prog; const uint64_t address = module->info; #define DIR_FORMAT "/proc/%ld/map_files" #define ENTRY_FORMAT "/%" PRIx64 "-%" PRIx64 char path[sizeof(DIR_FORMAT ENTRY_FORMAT) - (sizeof("%ld") - 1) + max_decimal_length(long) - 2 * (sizeof("%" PRIx64) - 1) + 2 * 16]; int dir_len = sprintf(path, DIR_FORMAT, (long)prog->pid); // Check the cache first. #define less_than_start(a, b) (*(a) < (b)->start) size_t cache_index = binary_search_gt(prog->dbinfo.map_files_segments, prog->dbinfo.num_map_files_segments, &address, less_than_start); #undef less_than_start if (cache_index > 0 && address < prog->dbinfo.map_files_segments[cache_index - 1].end) { struct drgn_map_files_segment *cache = &prog->dbinfo.map_files_segments[cache_index - 1]; sprintf(path + dir_len, ENTRY_FORMAT, cache->start, cache->end); drgn_log_debug(prog, "found %s containing dynamic section 0x%" PRIx64 " in map_files cache", path, address); int fd = open(path, O_RDONLY); if (fd >= 0) { *tried = true; return drgn_module_try_standard_file(module, options, path, fd, false, NULL); } else { // We found a match in the cache, but we couldn't open // it. If it doesn't exist anymore, then we need to // rebuild the cache. If it failed for any other reason, // ignore it like we do in the cache miss case. bool rebuild_cache = errno == ENOENT; drgn_log_debug(prog, "%s: %m", path); if (!rebuild_cache) return NULL; } drgn_log_debug(prog, "rebuilding map_files cache"); path[dir_len] = '\0'; } #undef ENTRY_FORMAT #undef DIR_FORMAT // Walk /proc/$pid/map_files, caching it while looking for a match. _cleanup_closedir_ DIR *dir = opendir(path); if (!dir) { if (errno != ENOENT) return drgn_error_create_os("opendir", errno, path); drgn_log_debug(prog, "%s: %m", path); return NULL; } VECTOR(drgn_map_files_segment_vector, segments); bool sorted = true; bool found = false; struct dirent *ent; while ((errno = 0, ent = readdir(dir))) { struct drgn_map_files_segment segment; if (sscanf(ent->d_name, "%" SCNx64 "-%" SCNx64, &segment.start, &segment.end) != 2) continue; if (!drgn_map_files_segment_vector_empty(&segments) && segment.start < drgn_map_files_segment_vector_last(&segments)->start) sorted = false; if (!drgn_map_files_segment_vector_append(&segments, &segment)) return &drgn_enomem; if (segment.start <= address && address < segment.end && !found && strlen(ent->d_name) + 1 < sizeof(path) - dir_len) { found = true; path[dir_len] = '/'; memcpy(path + dir_len + 1, ent->d_name, strlen(ent->d_name) + 1); drgn_log_debug(prog, "found %s containing dynamic section 0x%" PRIx64, path, address); int fd = openat(dirfd(dir), ent->d_name, O_RDONLY); if (fd >= 0) { *tried = true; err = drgn_module_try_standard_file(module, options, path, fd, false, NULL); if (err) return err; } else { drgn_log_debug(prog, "%s: %m", path); } path[dir_len] = '\0'; } } if (errno) return drgn_error_create_os("readdir", errno, path); drgn_debug_info_set_map_files_segments(&prog->dbinfo, &segments, sorted); if (!found) { drgn_log_debug(prog, "didn't find entry in %s containing dynamic section 0x%" PRIx64, path, address); } return NULL; } static struct drgn_error *drgn_module_try_proc_files(struct drgn_module *module, const struct drgn_debug_info_options *options, bool *tried) { struct drgn_program *prog = module->prog; if (!options->try_procfs) return NULL; *tried = false; if (module->kind == DRGN_MODULE_MAIN) { #define FORMAT "/proc/%ld/exe" char path[sizeof(FORMAT) - (sizeof("%ld") - 1) + max_decimal_length(long)]; snprintf(path, sizeof(path), FORMAT, (long)prog->pid); #undef FORMAT int fd = open(path, O_RDONLY); if (fd < 0) { drgn_log_debug(prog, "%s: %m", path); return NULL; } *tried = true; return drgn_module_try_standard_file(module, options, path, fd, false, NULL); } else if (module->kind == DRGN_MODULE_SHARED_LIBRARY) { return drgn_module_try_proc_files_for_shared_library(module, options, tried); } else { return NULL; } } static struct drgn_error * drgn_module_try_files_by_build_id(struct drgn_module *module, const struct drgn_debug_info_options *options) { struct drgn_error *err; if (!options->try_build_id) return NULL; size_t build_id_len; const char *build_id_str = drgn_module_build_id(module, NULL, &build_id_len); // We need at least 2 bytes (4 hex characters) to build the paths. if (build_id_len < 2) return NULL; STRING_BUILDER(sb); for (size_t i = 0; options->directories[i]; i++) { const char *debug_dir = options->directories[i]; if (!string_builder_append(&sb, debug_dir) || !string_builder_appendf(&sb, "/.build-id/%c%c/%s.debug", build_id_str[0], build_id_str[1], &build_id_str[2]) || !string_builder_null_terminate(&sb)) return &drgn_enomem; // We trust the build ID encoded in the path and don't check it // again. if (module->debug_file_status == DRGN_MODULE_FILE_WANT) { err = drgn_module_try_standard_file(module, options, sb.str, -1, false, NULL); if (err || !drgn_module_wants_file(module)) return err; } if (module->loaded_file_status == DRGN_MODULE_FILE_WANT) { // Remove the ".debug" extension. sb.str[sb.len - sizeof(".debug") + 1] = '\0'; err = drgn_module_try_standard_file(module, options, sb.str, -1, false, NULL); if (err || !drgn_module_wants_file(module)) return err; } sb.len = 0; } return NULL; } // Return the first occurrence of either $ORIGIN followed by a word boundary or // ${ORIGIN}, and set *end_ret to the character after that occurrence. Return // NULL if not found (and *end_ret is not modified). static const char *find_dollar_origin(const char *s, const char **end_ret) { const char *dollar; while ((dollar = strchr(s, '$'))) { if (strstartswith(dollar + 1, "ORIGIN")) { s = dollar + (sizeof("$ORIGIN") - 1); // Skip it if it doesn't end at a word boundary. if (*s == '_' || isalnum(*s)) continue; *end_ret = s; break; } else if (strstartswith(dollar + 1, "{ORIGIN}")) { *end_ret = dollar + (sizeof("${ORIGIN}") - 1); break; } else { s = dollar + 1; } } return dollar; } static struct drgn_error * drgn_module_try_files_by_gnu_debuglink(struct drgn_module *module, const struct drgn_debug_info_options *options) { struct drgn_error *err; struct drgn_program *prog = module->prog; if (!options->try_debug_link) return NULL; struct drgn_elf_file *file = module->loaded_file; if (!file || !file->scns[DRGN_SCN_GNU_DEBUGLINK]) return NULL; // We don't cache .gnu_debuglink, and it doesn't need relocation, so // don't use drgn_elf_file_read_section(). Elf_Data *data; err = read_elf_section(file->scns[DRGN_SCN_GNU_DEBUGLINK], &data); if (err) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, "%s: couldn't read .gnu_debuglink: ", file->path); drgn_error_destroy(err); err = NULL; } return err; } struct drgn_elf_file_section_buffer buffer; drgn_elf_file_section_buffer_init(&buffer, file, file->scns[DRGN_SCN_GNU_DEBUGLINK], data); const char *debuglink; size_t debuglink_len; uint32_t crc; if ((err = binary_buffer_next_string(&buffer.bb, &debuglink, &debuglink_len)) // Align up to 4-byte boundary. || (err = binary_buffer_skip(&buffer.bb, -(debuglink_len + 1) & 3)) || (err = binary_buffer_next_u32(&buffer.bb, &crc))) { if (!drgn_error_is_fatal(err)) { drgn_error_log_debug(prog, err, ""); drgn_error_destroy(err); err = NULL; } return err; } drgn_log_debug(prog, "%s has debuglink %s CRC 0x%08" PRIx32, file->path, debuglink, crc); STRING_BUILDER(sb); if (debuglink[0] == '/') { // debuglink is absolute. Try it directly. return drgn_module_try_standard_file(module, options, debuglink, -1, false, &crc); } if (!debuglink[0] || file->path[0] != '/') { // debuglink is empty or file path is not absolute. Ignore it. return NULL; } // debuglink is relative. Try it in the debug link directories. const char *slash = strrchr(file->path, '/'); // We just checked that the file path is absolute, so there must be a // slash. Also trim extra slashes just in case. while (slash != file->path && slash[-1] == '/') slash--; size_t dir_len = slash - file->path; const char * const *next_debug_link_dir = options->debug_link_directories; const char * const *next_debug_dir = NULL; for (;;) { if (next_debug_dir) { const char *debug_dir = *next_debug_dir++; if (!debug_dir) { next_debug_dir = NULL; continue; } if (!string_builder_append(&sb, debug_dir) || !string_builder_appendn(&sb, file->path, dir_len)) return &drgn_enomem; } else { const char *debug_link_dir = *next_debug_link_dir++; if (!debug_link_dir) return NULL; if (!debug_link_dir[0]) { // Empty path. Try under the debug directories. next_debug_dir = options->directories; continue; } const char *s = debug_link_dir; const char *dollar, *end; while ((dollar = find_dollar_origin(s, &end))) { if (!string_builder_appendn(&sb, s, dollar - s) || !string_builder_appendn(&sb, file->path, dir_len)) return &drgn_enomem; s = end; } if (!string_builder_append(&sb, s)) return &drgn_enomem; } if (!string_builder_appendc(&sb, '/') || !string_builder_appendn(&sb, debuglink, debuglink_len) || !string_builder_null_terminate(&sb)) return &drgn_enomem; err = drgn_module_try_standard_file(module, options, sb.str, -1, false, &crc); if (err || !drgn_module_wants_file(module)) return err; sb.len = 0; } } static struct drgn_error * drgn_module_try_standard_files(struct drgn_module *module, const struct drgn_debug_info_options *options, struct drgn_standard_debug_info_find_state *state) { struct drgn_error *err; struct drgn_program *prog = module->prog; // This can't happen when called from the standard debug info finder, // but it can from drgn_find_standard_debug_info(). if (!drgn_module_wants_file(module)) return NULL; drgn_module_try_files_log(module, "trying standard paths for"); // If we need a supplementary file, try that first. err = drgn_module_try_standard_supplementary_files(module, options); if (err || !drgn_module_wants_file(module)) return err; // If a previous attempt used a loadable file with debug info but didn't // want both, we might be able to reuse it. if (options->try_reuse && module->loaded_file_status == DRGN_MODULE_FILE_WANT) { struct drgn_elf_file *reuse_file = NULL; if (module->debug_file && module->debug_file->is_loadable) reuse_file = module->debug_file; else if (module->wanted_supplementary_debug_file && module->wanted_supplementary_debug_file->file->is_loadable) reuse_file = module->wanted_supplementary_debug_file->file; if (reuse_file) { drgn_log_debug(prog, "reusing loadable debug file %s as loaded file", reuse_file->path); err = drgn_module_maybe_use_elf_file(module, reuse_file, false); if (err || !drgn_module_wants_file(module)) return err; } } if (options->try_reuse && module->debug_file_status == DRGN_MODULE_FILE_WANT && module->loaded_file && drgn_elf_file_has_dwarf(module->loaded_file)) { drgn_log_debug(prog, "reusing loaded file with debug info %s as debug file", module->loaded_file->path); err = drgn_module_maybe_use_elf_file(module, module->loaded_file, false); if (err || !drgn_module_wants_file(module)) return err; } // First, try methods that are guaranteed to find the right file: // reading a vDSO from the core dump and opening a file via a magic // symlink in /proc. bool tried_proc_symlink = false; if (module->kind == DRGN_MODULE_VDSO) { err = drgn_module_try_vdso_in_core(module, options); if (err || !drgn_module_wants_file(module)) return err; } else if (drgn_program_is_userspace_process(prog)) { err = drgn_module_try_proc_files(module, options, &tried_proc_symlink); if (err || !drgn_module_wants_file(module)) return err; } // If we already have the build ID, try it now before wasting time with // the expected paths. If this is a Linux kernel loadable module, this // can save us from needing the depmod index. If not, it can still save // us from trying a file with the wrong build ID. const bool had_build_id = module->build_id_len > 0; if (had_build_id) { err = drgn_module_try_files_by_build_id(module, options); if (err || !drgn_module_wants_file(module)) return err; } // Next, try opening things at their expected paths. If this is the // Linux kernel or a Linux kernel loadable module, try some well-known // paths. if (module->kind == DRGN_MODULE_MAIN && (module->prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL)) { err = drgn_module_try_vmlinux_files(module, options); if (err || !drgn_module_wants_file(module)) return err; } else if (module->kind == DRGN_MODULE_RELOCATABLE && (module->prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL)) { err = drgn_module_try_linux_kmod_files(module, options, state); if (err || !drgn_module_wants_file(module)) return err; // Otherwise, if the module name looks like a path (i.e., it contains a // slash), try it. The vDSO is embedded in the kernel and isn't on disk, // so there's no point in trying it. Additionally, if we already tried a // /proc symlink, then we already tried the file that the path is // supposed to refer to, so don't try again. } else if (module->kind != DRGN_MODULE_VDSO && options->try_module_name && !tried_proc_symlink && strchr(module->name, '/')) { err = drgn_module_try_standard_file(module, options, module->name, -1, true, NULL); if (err || !drgn_module_wants_file(module)) return err; } // If we didn't have the build ID before, we might have found the loaded // file and gotten a build ID from it. Try to find the debug file by // build ID now. if (!had_build_id) { err = drgn_module_try_files_by_build_id(module, options); if (err || !drgn_module_wants_file(module)) return err; } // We might have a loaded file with a .gnu_debuglink. Try to find the // corresponding debug file. return drgn_module_try_files_by_gnu_debuglink(module, options); } static struct drgn_error * drgn_standard_debug_info_find(struct drgn_module * const *modules, size_t num_modules, void *arg) { struct drgn_error *err; struct drgn_debug_info_options *options = arg; if (drgn_log_is_enabled(modules[0]->prog, DRGN_LOG_DEBUG)) { _cleanup_free_ char *options_str = drgn_format_debug_info_options(options); if (!options_str) return &drgn_enomem; drgn_log_debug(modules[0]->prog, "trying standard debug info finder with %s%s", options == &modules[0]->prog->dbinfo.options ? "" : "given ", options_str); } _cleanup_(drgn_standard_debug_info_find_state_deinit) struct drgn_standard_debug_info_find_state state = { .modules = modules, .num_modules = num_modules, .kmod_walk = { .modules = HASH_TABLE_INIT, .stack = VECTOR_INIT, .path = STRING_BUILDER_INIT, .visited_dirs = HASH_TABLE_INIT, .next_kernel_dir = options->kernel_directories, }, }; for (size_t i = 0; i < num_modules; i++) { err = drgn_module_try_standard_files(modules[i], options, &state); if (err) return err; } return NULL; } LIBDRGN_PUBLIC struct drgn_error * drgn_find_standard_debug_info(struct drgn_module * const *modules, size_t num_modules, struct drgn_debug_info_options *options) { if (num_modules == 0) return NULL; struct drgn_program *prog = modules[0]->prog; for (size_t i = 0; i < num_modules; i++) { if (modules[i]->prog != prog) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "modules are from different programs"); } } if (!options) options = &modules[0]->prog->dbinfo.options; return drgn_standard_debug_info_find(modules, num_modules, options); } #if WITH_DEBUGINFOD static int count_columns(const char *s, size_t n) { int columns = 0; while (n > 0) { mbstate_t ps; memset(&ps, 0, sizeof(ps)); do { wchar_t wc; size_t r = mbrtowc(&wc, s, n, &ps); if (r == (size_t)-1) // Invalid multibyte sequence. return -1; if (r == (size_t)-2) // Incomplete multibyte character. return -2; if (r == 0) // Null wide character. r = 1; int w = wcwidth(wc); if (w < 0) // Nonprintable wide character. return -3; s += r; n -= r; columns += w; } while (!mbsinit(&ps)); } return columns; } static int truncate_columns(struct string_builder *sb, size_t start, size_t end, int max_columns) { int columns = 0; size_t truncate_len = start; int truncate_column = 0; mbstate_t truncate_ps; memset(&truncate_ps, 0, sizeof(truncate_ps)); while (start < end) { mbstate_t ps; memset(&ps, 0, sizeof(ps)); do { wchar_t wc; size_t r = mbrtowc(&wc, &sb->str[start], end - start, &ps); if (r == (size_t)-1) // Invalid multibyte sequence. return -1; if (r == (size_t)-2) // Incomplete multibyte character. return -2; if (r == 0) // Null wide character. r = 1; int w = wcwidth(wc); if (w < 0) // Nonprintable wide character. return -3; if (w > max_columns - columns) { int dots = min(max_columns, 3); char reset[MB_LEN_MAX]; size_t reset_len = 0; if (!mbsinit(&truncate_ps)) { reset_len = wcrtomb(reset, L'\0', &truncate_ps) - 1; } size_t new_len = (truncate_len + reset_len + dots + (sb->len - end)); if (!string_builder_reserve(sb, new_len)) return INT_MIN; memmove(&sb->str[truncate_len + reset_len + dots], &sb->str[end], sb->len - end); memset(&sb->str[truncate_len + reset_len], '.', dots); memcpy(&sb->str[truncate_len], reset, reset_len); sb->len = new_len; return truncate_column + dots; } start += r; columns += w; if (columns <= max_columns - 3) { truncate_len = start; truncate_column = columns; memcpy(&truncate_ps, &ps, sizeof(ps)); } } while (!mbsinit(&ps)); } return columns; } static void reset_shift_state(struct string_builder *sb, mbstate_t *ps) { if (!mbsinit(ps)) sb->len += wcrtomb(&sb->str[sb->len], L'\0', ps) - 1; } static bool write_unicode_progress_bar(struct string_builder *sb, int columns, double ratio) { size_t orig_len = sb->len; mbstate_t ps; memset(&ps, 0, sizeof(ps)); // "Right one eighth block" character. size_t r = wcrtomb(&sb->str[sb->len], L'\u2595', &ps); if (r == (size_t)-1) return false; sb->len += r; // + 0.25 so that we round up if the piece would be at least 75% full. int eighths = columns * ratio * 8.0 + 0.25; int blocks = eighths / 8; int i; for (i = 0; i < blocks; i++) { // "Full block" character. r = wcrtomb(&sb->str[sb->len], L'\u2588', &ps); if (r == (size_t)-1) goto undo; sb->len += r; } // "Left one eighth block" through "left seven eighths block" // characters. static const wchar_t eighths_blocks[7] = L"\u258f\u258e\u258d\u258c\u258b\u258a\u2589"; if (eighths % 8 != 0) { r = wcrtomb(&sb->str[sb->len], eighths_blocks[eighths % 8 - 1], &ps); if (r == (size_t)-1) goto undo; sb->len += r; i++; } for (; i < columns; i++) { r = wcrtomb(&sb->str[sb->len], L' ', &ps); if (r == (size_t)-1) goto undo; sb->len += r; } // "Left one eighth block" character. r = wcrtomb(&sb->str[sb->len], L'\u258f', &ps); if (r == (size_t)-1) goto undo; sb->len += r; reset_shift_state(sb, &ps); return true; undo: sb->len = orig_len; return false; } static void write_ascii_progress_bar(struct string_builder *sb, int columns, double ratio) { sb->str[sb->len++] = '['; // + 0.25 so that we round up if the block would be at least 75% full. int blocks = columns * ratio + 0.25; memset(&sb->str[sb->len], '#', blocks); sb->len += blocks; memset(&sb->str[sb->len], ' ', columns - blocks); sb->len += columns - blocks; sb->str[sb->len++] = ']'; } static bool write_unicode_spinner(struct string_builder *sb, int pos) { static const wchar_t spinner[] = { L'\u2596', // Quadrant lower left L'\u2598', // Quadrant upper left L'\u259d', // Quadrant upper right L'\u2597', // Quadrant lower right }; mbstate_t ps; memset(&ps, 0, sizeof(ps)); size_t r = wcrtomb(&sb->str[sb->len], spinner[pos % array_size(spinner)], &ps); if (r == (size_t)-1) return false; sb->len += r; reset_shift_state(sb, &ps); return true; } static void write_ascii_spinner(struct string_builder *sb, int pos) { static const char spinner[] = { '|', '/', '-', '\\' }; sb->str[sb->len++] = spinner[pos % array_size(spinner)]; } // debuginfod_set_user_data() and debuginfod_get_user_data() were added in // elfutils 0.179. Before that, we emulate them with a thread-local variable. #if !_ELFUTILS_PREREQ(0, 179) static _Thread_local void *drgn_debuginfod_user_data; #endif // This is called with: // - a >= 0 && b == 0 while cleaning the debuginfod cache, where a is the number // of files in the cache that have been checked. // - a >= 0 && b == 0 while waiting to read the first chunk of data from a // debuginfod server, where a is an increasing counter. Note that this cannot // be distinguished from the previous case. // - a >= 0 && b > 0 while downloading, where a is the number of bytes // downloaded and b is the total size to download in bytes. // - a >= 0 && b <= 0 while downloading, where a is the number of bytes // downloaded and the total size is not known. This can be distinguished from // the first two cases because debuginfod_get_url() will return non-NULL. // - a < 0 && b >= 0 when the download has finished successfully. b is the // downloaded file descriptor. // - a < 0 && b < 0 when the download failed. b is a negative errno. static void drgn_log_debuginfod_progress(debuginfod_client *client, long a, long b) { #if _ELFUTILS_PREREQ(0, 179) struct drgn_program *prog = drgn_debuginfod_get_user_data(client); #else struct drgn_program *prog = drgn_debuginfod_user_data; #endif const bool done = a < 0; // If we already started logging progress for this download when it // failed, we log the error like progress below. Otherwise, the download // failed very early, so we only log a debug message. if (done && b < 0 && !prog->dbinfo.logged_debuginfod_progress) { if (b != -ENOSYS) { errno = -b; drgn_log_debug(prog, "%s: couldn't download%s from debuginfod: %m", prog->dbinfo.debuginfod_current_name, prog->dbinfo.debuginfod_current_type); } else if (!prog->dbinfo.logged_no_debuginfod) { drgn_log_debug(prog, "no debuginfod servers configured; " "try setting the DEBUGINFOD_URLS environment variable"); prog->dbinfo.logged_no_debuginfod = true; } return; } prog->dbinfo.logged_debuginfod_progress = true; int columns; FILE *file = drgn_program_get_progress_file(prog, &columns); // ANSI escape sequence to clear the current line and return the cursor // to the beginning of the line. static const char ansi_erase_line[] = "\33[2K\r"; // Once we know what URL we are downloading from, log it. if (!prog->dbinfo.debuginfod_have_url) { // debuginfod_get_url() was added in elfutils 0.179. Before // that, we have to assume that we have a URL. #if _ELFUTILS_PREREQ(0, 179) const char *url = drgn_debuginfod_get_url(client); if (url) { prog->dbinfo.debuginfod_have_url = true; // Erase the current line since we may have logged // progress. if (columns >= 0) { fwrite(ansi_erase_line, 1, sizeof(ansi_erase_line) - 1, file); fflush(file); } drgn_log_debug(prog, "downloading from debuginfod at %s", url); } #else prog->dbinfo.debuginfod_have_url = true; #endif } // If we succeeded without ever getting a URL, it must have been cached. if (done && b >= 0 && !prog->dbinfo.debuginfod_have_url) { // We may have logged download progress when we were actually // cleaning the cache. Clear it to avoid confusion. if (columns >= 0) { fwrite(ansi_erase_line, 1, sizeof(ansi_erase_line) - 1, file); fflush(file); } drgn_log_debug(prog, "%s: found%s in debuginfod cache", prog->dbinfo.debuginfod_current_name, prog->dbinfo.debuginfod_current_type); return; } if (!file) return; // We only do the progress animation if we would have at least one // column for a progress bar. Using the calculation for bar_columns // below: // // columns - (floor(columns / 2) - 10) - 2 - 4 >= 1 // => columns - floor(columns / 2) >= 17 // => ceil(columns / 2) >= 17 // => columns >= 33 bool animate = columns >= 33; const bool orig_animate = animate; STRING_BUILDER(sb); if (animate && !string_builder_appendc(&sb, '\r')) return; int fill_columns = 0; int bar_columns = 0; if (animate) { if (done) { // We need to erase anything left in the line with // spaces. fill_columns = columns; } else if (b > 0) { // Use half of the line plus a bit for the name and // download size so that it doesn't get too short in // small terminals. fill_columns = columns / 2 + 10; // Use the rest for the progress bar. bar_columns = (columns - fill_columns - 2 // Ends of progress bar - 4 // " XX%" ); } else { // Use the whole line, minus the spinner, for the name // and download size fill_columns = columns - 1; } } if (!string_builder_append(&sb, done && b >= 0 ? "Downloaded " : "Downloading ") || !string_builder_append(&sb, prog->dbinfo.debuginfod_current_name) || !string_builder_append(&sb, prog->dbinfo.debuginfod_current_type)) return; size_t download_size_start = sb.len; if (done && b < 0) { errno = -b; if (!string_builder_appendf(&sb, " failed: %m")) return; } else if (prog->dbinfo.debuginfod_have_url) { intmax_t download_size; if (done) { struct stat st; if (fstat(b, &st) < 0) { drgn_log_warning(prog, "fstat: %m"); return; } download_size = st.st_size; } else { download_size = a; } if (download_size < 2048) { if (!string_builder_appendf(&sb, " (%" PRIdMAX " B)", download_size)) return; } else { static const char prefixes[] = "KMGTPEZY"; int i = 1; while (i < sizeof(prefixes) - 1 && (download_size >> (10 * i)) >= 2048) i++; double unit = INTMAX_C(1) << (10 * i); if (!string_builder_appendf(&sb, " (%.1f %ciB)", download_size / unit, prefixes[i - 1])) return; } } if (animate) { int current_column; if (done) { // Start at byte 1 to skip the "\r". current_column = count_columns(&sb.str[1], sb.len - 1); } else { int download_size_len = sb.len - download_size_start; // Leave room for the download size and an extra space. int max_columns = max(fill_columns - download_size_len - 1, 0); // Start at byte 1 to skip the "\r". current_column = truncate_columns(&sb, 1, download_size_start, max_columns); if (current_column == INT_MIN) return; // Memory allocation failed. if (current_column >= 0) current_column += download_size_len; } if (current_column < 0) { // We either couldn't decode the string or the string // contained a nonprintable character. Give up on the // animation. animate = false; } else if (current_column < fill_columns) { if (!string_builder_reserve_for_append(&sb, fill_columns - current_column)) return; memset(&sb.str[sb.len], ' ', fill_columns - current_column); sb.len += fill_columns - current_column; } } // If we can't encode any of the following Unicode characters in the // current locale, we fall back to ASCII. if (!done && b > 0) { // Clamp the ratio in case we get bogus sizes. double ratio = a < b ? (double)a / (double)b : 1.0; if (animate) { // One multibyte character for each bar column, one for // each end, and one to reset the shift state. if (!string_builder_reserve_for_append(&sb, (bar_columns + 3) * MB_CUR_MAX)) return; if (!write_unicode_progress_bar(&sb, bar_columns, ratio)) { write_ascii_progress_bar(&sb, bar_columns, ratio); } } unsigned int percent = 100.0 * ratio; // We're not 100% done until we're called with done = true. if (percent > 99) percent = 99; if (!string_builder_appendf(&sb, " %*u%%", animate ? 2 : 0, percent)) return; } else if (!done && animate) { // One multibyte character for the spinner, one to reset the // shift state. if (!string_builder_reserve_for_append(&sb, 2 * MB_CUR_MAX)) return; unsigned int pos = prog->dbinfo.debuginfod_spinner_position++; if (!write_unicode_spinner(&sb, pos)) write_ascii_spinner(&sb, pos); } if ((done || !animate) && !string_builder_appendc(&sb, '\n')) return; // If we were originally animating but gave up, we need to skip the // "\r". fwrite(sb.str + (orig_animate && !animate ? 1 : 0), 1, sb.len - (orig_animate && !animate ? 1 : 0), file); } static struct sigaction drgn_cancel_debuginfod_oldact; static volatile sig_atomic_t drgn_cancel_debuginfod; static void drgn_cancel_debuginfod_handler(int sig) { drgn_cancel_debuginfod = 1; drgn_cancel_debuginfod_oldact.sa_handler(sig); } static void drgn_cancel_debuginfod_sigaction(int sig, siginfo_t *info, void *ucontext) { drgn_cancel_debuginfod = 1; drgn_cancel_debuginfod_oldact.sa_sigaction(sig, info, ucontext); } static bool drgn_prepare_debuginfod_find(struct drgn_program *prog) { #if !_ELFUTILS_PREREQ(0, 179) drgn_debuginfod_user_data = prog; #endif // If the application has a signal handler for SIGINT, temporarily wrap // it with our own signal handler that sets a flag for the debuginfod // progressfn. This allows Ctrl+C to interrupt a download in // applications that handle SIGINT (like the Python interpreter). drgn_cancel_debuginfod = 0; if (sigaction(SIGINT, NULL, &drgn_cancel_debuginfod_oldact) != 0) return false; struct sigaction act = drgn_cancel_debuginfod_oldact; if ((act.sa_flags & SA_SIGINFO) // SIG_DFL and SIG_IGN are meant to be assigned to sa_handler, but // the Linux kernel treats them the same for sa_sigaction. && act.sa_sigaction != (void *)SIG_DFL && act.sa_sigaction != (void *)SIG_IGN) act.sa_sigaction = drgn_cancel_debuginfod_sigaction; else if (!(act.sa_flags & SA_SIGINFO) && act.sa_handler != SIG_DFL && act.sa_handler != SIG_IGN) act.sa_handler = drgn_cancel_debuginfod_handler; else return false; return sigaction(SIGINT, &act, NULL) == 0; } static void drgn_finish_debuginfod_find(bool restore_sigaction) { if (restore_sigaction) sigaction(SIGINT, &drgn_cancel_debuginfod_oldact, NULL); } static int drgn_debuginfod_progressfn(debuginfod_client *client, long a, long b) { if (drgn_cancel_debuginfod) return 1; if (a >= 0) drgn_log_debuginfod_progress(client, a, b); return 0; } static struct drgn_error * drgn_module_try_file_from_debuginfod(struct drgn_module *module, const char *build_id_str, bool debug, bool supplementary, struct string_builder *cache_sb) { struct drgn_program *prog = module->prog; if (!string_builder_appendf(cache_sb, "/%s/%s", build_id_str, debug ? "debuginfo" : "executable") || !string_builder_null_terminate(cache_sb)) return &drgn_enomem; prog->dbinfo.debuginfod_current_name = module->name; if (supplementary) prog->dbinfo.debuginfod_current_type = " supplementary debug info"; else if (debug) prog->dbinfo.debuginfod_current_type = " debug info"; else prog->dbinfo.debuginfod_current_type = ""; prog->dbinfo.debuginfod_have_url = false; prog->dbinfo.logged_debuginfod_progress = false; bool restore_sigaction = drgn_prepare_debuginfod_find(prog); char *path; auto find = debug ? drgn_debuginfod_find_debuginfo : drgn_debuginfod_find_executable; int fd = find(prog->dbinfo.debuginfod_client, (const unsigned char *)build_id_str, 0, &path); drgn_finish_debuginfod_find(restore_sigaction); if (fd == -ENOENT && drgn_cancel_debuginfod) { // Before elfutils commit 5527216460c6 ("debuginfod-client.c: // Skip empty file creation for cancelled queries") (in elfutils // 0.190), libdebuginfod has a nasty bug that causes it to cache // a cancelled download as a negative hit. Work around it by // deleting the cache file. unlink(cache_sb->str); return drgn_error_create_os("download cancelled", EINTR, NULL); } drgn_log_debuginfod_progress(prog->dbinfo.debuginfod_client, -1, fd); if (fd >= 0) { struct drgn_error *err = drgn_module_try_file(module, path, fd, true); free(path); if (err) return err; } return NULL; } static struct drgn_error * drgn_module_try_supplementary_file_from_debuginfod(struct drgn_module *module, struct string_builder *cache_sb) { if (drgn_module_wanted_supplementary_debug_file(module, NULL, NULL, NULL, NULL) != DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK) return NULL; const char *gnu_debugaltlink_build_id_str = module->wanted_supplementary_debug_file->checksum_str; return drgn_module_try_file_from_debuginfod(module, gnu_debugaltlink_build_id_str, true, true, cache_sb); } static struct drgn_error * drgn_debuginfod_find(struct drgn_module * const *modules, size_t num_modules, void *arg) { struct drgn_error *err; struct drgn_program *prog = arg; if (!prog->dbinfo.debuginfod_client) { prog->dbinfo.debuginfod_client = drgn_debuginfod_begin(); if (!prog->dbinfo.debuginfod_client) { return drgn_error_create(DRGN_ERROR_OTHER, "couldn't create debuginfod client session"); } drgn_debuginfod_set_progressfn(prog->dbinfo.debuginfod_client, drgn_debuginfod_progressfn); #if _ELFUTILS_PREREQ(0, 179) drgn_debuginfod_set_user_data(prog->dbinfo.debuginfod_client, prog); #endif } STRING_BUILDER(sb); const char *env; if ((env = getenv("DEBUGINFOD_CACHE_PATH"))) { if (!string_builder_append(&sb, env)) return &drgn_enomem; } else { env = getenv("HOME") ?: "/"; if (!string_builder_append(&sb, env) || !string_builder_append(&sb, "/.debuginfod_client_cache") || !string_builder_null_terminate(&sb)) return &drgn_enomem; struct stat st; if (stat(sb.str, &st) < 0) { sb.len = 0; if ((env = getenv("XDG_CACHE_HOME"))) { if (!string_builder_append(&sb, env) || !string_builder_append(&sb, "/debuginfod_client")) return &drgn_enomem; } else if (!string_builder_append(&sb, getenv("HOME") ?: "/") || !string_builder_append(&sb, "/.cache/debuginfod_client")) { return &drgn_enomem; } } } size_t cache_dir_len = sb.len; for (size_t i = 0; i < num_modules; i++) { struct drgn_module *module = modules[i]; const char *build_id_str = drgn_module_build_id(module, NULL, NULL); if (!build_id_str) { drgn_module_try_files_log(module, "can't query debuginfod for"); continue; } drgn_module_try_files_log(module, "querying debuginfod for"); // If we need a supplementary file, try that first. err = drgn_module_try_supplementary_file_from_debuginfod(module, &sb); if (err) return err; sb.len = cache_dir_len; // If we need the debug file (including if we needed a // gnu_debugaltlink file and didn't find it), try that next. if (drgn_module_wants_debug_file(module)) { uint64_t orig_supplementary_file_generation = prog->dbinfo.supplementary_file_generation; err = drgn_module_try_file_from_debuginfod(module, build_id_str, true, false, &sb); if (err) return err; sb.len = cache_dir_len; // If the wanted supplementary debug file changed, try // finding it again. if (drgn_module_wanted_supplementary_debug_file_is_new(module, orig_supplementary_file_generation)) { err = drgn_module_try_supplementary_file_from_debuginfod(module, &sb); if (err) return err; sb.len = cache_dir_len; } } if (drgn_module_wants_loaded_file(module)) { err = drgn_module_try_file_from_debuginfod(module, build_id_str, false, false, &sb); if (err) return err; sb.len = cache_dir_len; } } return NULL; } #endif // WITH_DEBUGINFOD LIBDRGN_PUBLIC struct drgn_error *drgn_module_try_file(struct drgn_module *module, const char *path, int fd, bool force) { if (!drgn_module_wants_file(module)) { drgn_log_debug(module->prog, "%s: ignoring unwanted file %s", module->name, path); if (fd >= 0) close(fd); return NULL; } drgn_module_try_files_log(module, "trying provided file as"); return drgn_module_try_file_internal(module, path, fd, !force, NULL); } LIBDRGN_PUBLIC void drgn_module_iterator_destroy(struct drgn_module_iterator *it) { if (it) { if (it->destroy) it->destroy(it); else free(it); } } LIBDRGN_PUBLIC struct drgn_program * drgn_module_iterator_program(const struct drgn_module_iterator *it) { return it->prog; } LIBDRGN_PUBLIC struct drgn_error *drgn_module_iterator_next(struct drgn_module_iterator *it, struct drgn_module **ret, bool *new_ret) { if (!it->next) { *ret = NULL; return NULL; } struct drgn_error *err = it->next(it, ret, new_ret); if (err || !*ret) it->next = NULL; return err; } struct drgn_created_module_iterator { struct drgn_module_iterator it; struct drgn_module_table_iterator table_it; struct drgn_module *next_module; uint64_t generation; bool yielded_main; }; static struct drgn_error * drgn_created_module_iterator_next(struct drgn_module_iterator *_it, struct drgn_module **ret, bool *new_ret) { struct drgn_created_module_iterator *it = container_of(_it, struct drgn_created_module_iterator, it); struct drgn_debug_info *dbinfo = &it->it.prog->dbinfo; if (!it->yielded_main) { it->yielded_main = true; it->table_it = drgn_module_table_first(&dbinfo->modules); it->generation = dbinfo->modules_generation; if (dbinfo->main_module) { *ret = dbinfo->main_module; if (new_ret) *new_ret = false; return NULL; } } if (it->generation != dbinfo->modules_generation) { return drgn_error_create(DRGN_ERROR_OTHER, "modules changed during iteration"); } for (;;) { if (!it->next_module) { if (it->table_it.entry) { it->next_module = *it->table_it.entry; it->table_it = drgn_module_table_next(it->table_it); } else { *ret = NULL; return NULL; } } if (it->next_module == dbinfo->main_module) { it->next_module = it->next_module->next_same_name; } else { *ret = it->next_module; if (new_ret) *new_ret = false; it->next_module = it->next_module->next_same_name; return NULL; } } } LIBDRGN_PUBLIC struct drgn_error * drgn_created_module_iterator_create(struct drgn_program *prog, struct drgn_module_iterator **ret) { struct drgn_created_module_iterator *it = calloc(1, sizeof(*it)); if (!it) return &drgn_enomem; drgn_module_iterator_init(&it->it, prog, NULL, drgn_created_module_iterator_next); *ret = &it->it; return NULL; } struct drgn_mapped_file { const char *path; // Mapped address range containing file offset 0. This is used to find // the file header. uint64_t offset0_vaddr, offset0_size; }; static struct drgn_mapped_file *drgn_mapped_file_create(const char *path) { struct drgn_mapped_file *file = calloc(1, sizeof(*file)); if (file) file->path = path; return file; } static void drgn_mapped_file_destroy(struct drgn_mapped_file *file) { free(file); } struct drgn_mapped_file_segment { uint64_t start; uint64_t end; uint64_t file_offset; struct drgn_mapped_file *file; }; DEFINE_VECTOR(drgn_mapped_file_segment_vector, struct drgn_mapped_file_segment); struct drgn_mapped_file_segments { struct drgn_mapped_file_segment_vector vector; // Whether the segments are already sorted by start address. This should // always be true for both /proc/$pid/maps and NT_FILE, but we check and // sort afterwards if not just in case. bool sorted; }; #define DRGN_MAPPED_FILE_SEGMENTS_INIT { VECTOR_INIT, true } static void drgn_mapped_file_segments_abort(struct drgn_mapped_file_segments *segments) { drgn_mapped_file_segment_vector_deinit(&segments->vector); } static struct drgn_error * drgn_add_mapped_file_segment(struct drgn_mapped_file_segments *segments, uint64_t start, uint64_t end, uint64_t file_offset, struct drgn_mapped_file *file) { assert(start < end); if (file_offset == 0 && file->offset0_size == 0) { file->offset0_vaddr = start; file->offset0_size = end - start; } if (!drgn_mapped_file_segment_vector_empty(&segments->vector)) { struct drgn_mapped_file_segment *last = drgn_mapped_file_segment_vector_last(&segments->vector); // If the last segment is from the same file and contiguous with // this one, merge into that one. if (file == last->file && start == last->end && file_offset == last->file_offset + (last->end - last->start)) { last->end = end; return NULL; } if (start < last->start) segments->sorted = false; } struct drgn_mapped_file_segment *entry = drgn_mapped_file_segment_vector_append_entry(&segments->vector); if (!entry) return &drgn_enomem; entry->start = start; entry->end = end; entry->file_offset = file_offset; entry->file = file; return NULL; } enum { // Yield main module next. USERSPACE_LOADED_MODULE_ITERATOR_STATE_MAIN, // Yield vDSO module next. USERSPACE_LOADED_MODULE_ITERATOR_STATE_VDSO, // Get first link_map from r_debug next. USERSPACE_LOADED_MODULE_ITERATOR_STATE_R_DEBUG, // Yield module from link_map list next. USERSPACE_LOADED_MODULE_ITERATOR_STATE_LINK_MAP, // States after this are the same as // USERSPACE_LOADED_MODULE_ITERATOR_STATE_LINK_MAP but also count how // many link_map entries we've iterated. }; // Arbitrary limit on the number iterations to make through the link_map list in // order to avoid getting stuck in a cycle. static const int MAX_LINK_MAP_LIST_ITERATIONS = 10000; struct userspace_loaded_module_iterator { struct drgn_module_iterator it; int state; bool read_main_phdrs; bool have_main_dyn; bool have_vdso_dyn; struct drgn_mapped_file_segment *file_segments; size_t num_file_segments; uint64_t main_phoff; uint64_t main_bias; uint64_t main_dyn_vaddr; uint64_t main_dyn_memsz; uint64_t vdso_dyn_vaddr; uint64_t link_map; // Temporary buffer for reading program headers. void *phdrs_buf; size_t phdrs_buf_capacity; // Temporary buffer for reading segment contents. void *segment_buf; size_t segment_buf_capacity; }; static void userspace_loaded_module_iterator_deinit(struct userspace_loaded_module_iterator *it) { free(it->segment_buf); free(it->phdrs_buf); free(it->file_segments); } static inline int drgn_mapped_file_segment_compare(const void *_a, const void *_b) { const struct drgn_mapped_file_segment *a = _a; const struct drgn_mapped_file_segment *b = _b; return (a->start > b->start) - (a->start < b->start); } static void userspace_loaded_module_iterator_set_file_segments(struct userspace_loaded_module_iterator *it, struct drgn_mapped_file_segments *segments) { // Don't bother shrinking to fit since this is short-lived. drgn_mapped_file_segment_vector_steal(&segments->vector, &it->file_segments, &it->num_file_segments); if (!segments->sorted) { qsort(it->file_segments, it->num_file_segments, sizeof(it->file_segments[0]), drgn_mapped_file_segment_compare); } } static struct drgn_mapped_file_segment * find_mapped_file_segment(struct userspace_loaded_module_iterator *it, uint64_t address) { #define less_than_start(a, b) (*(a) < (b)->start) size_t i = binary_search_gt(it->file_segments, it->num_file_segments, &address, less_than_start); #undef less_than_start if (i == 0 || address >= it->file_segments[i - 1].end) return NULL; return &it->file_segments[i - 1]; } static struct drgn_error * userspace_loaded_module_iterator_read_ehdr(struct userspace_loaded_module_iterator *it, uint64_t address, GElf_Ehdr *ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; err = drgn_program_read_memory(prog, ret, address, sizeof(*ret), false); if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_debug(prog, "couldn't read ELF header at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); return &drgn_not_found; } else if (err) { return err; } if (memcmp(ret->e_ident, ELFMAG, SELFMAG) != 0) { drgn_log_debug(prog, "invalid ELF header magic"); return &drgn_not_found; } if (ret->e_ident[EI_CLASS] != (drgn_platform_is_64_bit(&prog->platform) ? ELFCLASS64 : ELFCLASS32)) { drgn_log_debug(prog, "ELF header class (%u) does not match program", ret->e_ident[EI_CLASS]); return &drgn_not_found; } if (ret->e_ident[EI_DATA] != (drgn_platform_is_little_endian(&prog->platform) ? ELFDATA2LSB : ELFDATA2MSB)) { drgn_log_debug(prog, "ELF header data encoding (%u) does not match program", ret->e_ident[EI_DATA]); return &drgn_not_found; } #define visit_elf_ehdr_members(visit_scalar_member, visit_raw_member) do { \ visit_raw_member(e_ident); \ visit_scalar_member(e_type); \ visit_scalar_member(e_machine); \ visit_scalar_member(e_version); \ visit_scalar_member(e_entry); \ visit_scalar_member(e_phoff); \ visit_scalar_member(e_shoff); \ visit_scalar_member(e_flags); \ visit_scalar_member(e_ehsize); \ visit_scalar_member(e_phentsize); \ visit_scalar_member(e_phnum); \ visit_scalar_member(e_shentsize); \ visit_scalar_member(e_shnum); \ visit_scalar_member(e_shstrndx); \ } while (0) deserialize_struct64_inplace(ret, Elf32_Ehdr, visit_elf_ehdr_members, drgn_platform_is_64_bit(&prog->platform), drgn_platform_bswap(&prog->platform)); #undef visit_elf_ehdr_members if (ret->e_phentsize != (drgn_platform_is_64_bit(&prog->platform) ? sizeof(Elf64_Phdr) : sizeof(Elf32_Phdr))) { drgn_log_debug(prog, "ELF program header entry size (%u) does not match class", ret->e_phentsize); return &drgn_not_found; } return NULL; } static struct drgn_error * userspace_loaded_module_iterator_read_phdrs(struct userspace_loaded_module_iterator *it, uint64_t address, uint16_t phnum) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; uint32_t phentsize = (drgn_platform_is_64_bit(&prog->platform) ? sizeof(Elf64_Phdr) : sizeof(Elf32_Phdr)); uint32_t phdrs_size = (uint32_t)phnum * phentsize; if (phdrs_size > MAX_MEMORY_READ_FOR_DEBUG_INFO) { drgn_log_debug(prog, "program header table is unreasonably large (%" PRIu32 " bytes); ignoring", phdrs_size); return &drgn_not_found; } if (!alloc_or_reuse(&it->phdrs_buf, &it->phdrs_buf_capacity, phdrs_size)) return &drgn_enomem; err = drgn_program_read_memory(prog, it->phdrs_buf, address, phdrs_size, false); if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_debug(prog, "couldn't read program header table at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); return &drgn_not_found; } return err; } static void userspace_loaded_module_iterator_phdr(struct userspace_loaded_module_iterator *it, size_t i, GElf_Phdr *ret) { struct drgn_program *prog = it->it.prog; size_t phentsize = (drgn_platform_is_64_bit(&prog->platform) ? sizeof(Elf64_Phdr) : sizeof(Elf32_Phdr)); #define visit_phdr_members(visit_scalar_member, visit_raw_member) do { \ visit_scalar_member(p_type); \ visit_scalar_member(p_flags); \ visit_scalar_member(p_offset); \ visit_scalar_member(p_vaddr); \ visit_scalar_member(p_paddr); \ visit_scalar_member(p_filesz); \ visit_scalar_member(p_memsz); \ visit_scalar_member(p_align); \ } while (0) deserialize_struct64(ret, Elf32_Phdr, visit_phdr_members, (char *)it->phdrs_buf + i * phentsize, drgn_platform_is_64_bit(&prog->platform), drgn_platform_bswap(&prog->platform)); #undef visit_phdr_members } static struct drgn_error * userspace_loaded_module_iterator_read_dynamic(struct userspace_loaded_module_iterator *it, uint64_t address, uint64_t size, size_t *num_dyn_ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; if (size > MAX_MEMORY_READ_FOR_DEBUG_INFO) { drgn_log_debug(prog, "dynamic section is unreasonably large (%" PRIu64 " bytes); ignoring", size); return &drgn_not_found; } size_t dyn_size = (drgn_platform_is_64_bit(&prog->platform) ? sizeof(Elf64_Dyn) : sizeof(Elf32_Dyn)); uint64_t num_dyn = size / dyn_size; *num_dyn_ret = num_dyn; if (num_dyn == 0) return NULL; if (!alloc_or_reuse(&it->segment_buf, &it->segment_buf_capacity, num_dyn * dyn_size)) return &drgn_enomem; err = drgn_program_read_memory(prog, it->segment_buf, address, num_dyn * dyn_size, false); if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_debug(prog, "couldn't read dynamic section at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); return &drgn_not_found; } return err; } static void userspace_loaded_module_iterator_dyn(struct userspace_loaded_module_iterator *it, size_t i, GElf_Dyn *ret) { struct drgn_program *prog = it->it.prog; size_t dyn_size = (drgn_platform_is_64_bit(&prog->platform) ? sizeof(Elf64_Dyn) : sizeof(Elf32_Dyn)); #define visit_elf_dyn_members(visit_scalar_member, visit_raw_member) do { \ visit_scalar_member(d_tag); \ visit_scalar_member(d_un.d_val); \ } while (0) deserialize_struct64(ret, Elf32_Dyn, visit_elf_dyn_members, (char *)it->segment_buf + i * dyn_size, drgn_platform_is_64_bit(&prog->platform), drgn_platform_bswap(&prog->platform)); #undef visit_elf_dyn_members } static struct drgn_error * userspace_loaded_module_iterator_read_main_phdrs(struct userspace_loaded_module_iterator *it) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; // The main bias is the difference between AT_PHDR and the virtual // address of the program headers in the ELF file. We determine the // latter by finding the PT_LOAD segment containing e_phoff. We would // use PT_PHDR instead, but static binaries usually don't have it, and // we can't assume a bias of 0 for static PIE binaries. // // If we couldn't find the file offset of the program headers, we can't // find anything else. if (it->main_phoff == 0) return NULL; drgn_log_debug(prog, "reading program header table from AT_PHDR"); err = userspace_loaded_module_iterator_read_phdrs(it, prog->auxv.at_phdr, prog->auxv.at_phnum); if (err == &drgn_not_found) return NULL; else if (err) return err; // Silence -Wmaybe-uninitialized false positives on dyn_vaddr and // dyn_memsz last seen with GCC 9. uint64_t phdr_vaddr, dyn_vaddr = 0, dyn_memsz = 0; bool have_phdr_vaddr = false, have_dyn = false; for (uint16_t i = 0; i < prog->auxv.at_phnum; i++) { GElf_Phdr phdr; userspace_loaded_module_iterator_phdr(it, i, &phdr); if (phdr.p_type == PT_LOAD && phdr.p_offset <= it->main_phoff && it->main_phoff < phdr.p_offset + phdr.p_filesz) { drgn_log_debug(prog, "found PT_LOAD containing program headers with p_vaddr 0x%" PRIx64 " and p_offset 0x%" PRIx64, phdr.p_vaddr, phdr.p_offset); phdr_vaddr = it->main_phoff - phdr.p_offset + phdr.p_vaddr; have_phdr_vaddr = true; } else if (phdr.p_type == PT_DYNAMIC) { drgn_log_debug(prog, "found PT_DYNAMIC with p_vaddr 0x%" PRIx64 " and p_memsz 0x%" PRIx64, phdr.p_vaddr, phdr.p_memsz); have_dyn = true; dyn_vaddr = phdr.p_vaddr; dyn_memsz = phdr.p_memsz; } } if (have_phdr_vaddr) { it->main_bias = prog->auxv.at_phdr - phdr_vaddr; drgn_log_debug(prog, "main bias is 0x%" PRIx64, it->main_bias); } else { drgn_log_debug(prog, "didn't find PT_LOAD containing program headers"); return NULL; } if (have_dyn) { it->have_main_dyn = true; it->main_dyn_vaddr = dyn_vaddr + it->main_bias; it->main_dyn_memsz = dyn_memsz; drgn_log_debug(prog, "main dynamic section is at 0x%" PRIx64, it->main_dyn_vaddr); } else { drgn_log_debug(prog, "didn't find PT_DYNAMIC program header; probably statically linked"); } it->read_main_phdrs = true; return NULL; } static struct drgn_error * identify_module_from_phdrs(struct userspace_loaded_module_iterator *it, struct drgn_module *module, size_t phnum, uint64_t bias) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; uint64_t start = UINT64_MAX, end = 0; for (size_t i = 0; i < phnum; i++) { GElf_Phdr phdr; userspace_loaded_module_iterator_phdr(it, i, &phdr); if (phdr.p_type == PT_LOAD) { // Like elf_address_range_from_min_and_max_phdr(). start = min(start, phdr.p_vaddr + bias); end = max(end, phdr.p_vaddr + phdr.p_memsz + bias); } else if (phdr.p_type == PT_NOTE && module->build_id_len == 0) { uint64_t note_size = min(phdr.p_filesz, phdr.p_memsz); if (!note_size) continue; if (note_size > MAX_MEMORY_READ_FOR_DEBUG_INFO) { drgn_log_debug(prog, "note is unreasonably large (%" PRIu64 " bytes); ignoring", note_size); continue; } if (!alloc_or_reuse(&it->segment_buf, &it->segment_buf_capacity, note_size)) return &drgn_enomem; err = drgn_program_read_memory(prog, it->segment_buf, phdr.p_vaddr + bias, note_size, false); if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_debug(prog, "couldn't read note at 0x%" PRIx64 ": %s" "; ignoring", err->address, err->message); drgn_error_destroy(err); continue; } else if (err) { return err; } const void *build_id; size_t build_id_len = parse_gnu_build_id_from_notes(it->segment_buf, note_size, phdr.p_align == 8 ? 8 : 4, drgn_platform_bswap(&prog->platform), &build_id); if (build_id_len > 0) { err = drgn_module_set_build_id(module, build_id, build_id_len); if (err) return err; drgn_log_debug(prog, "found build ID %s in note at 0x%" PRIx64, module->build_id_str, phdr.p_vaddr + bias + ((char *)build_id - (char *)it->segment_buf)); } } } if (module->build_id_len == 0) { drgn_log_debug(prog, "couldn't find build ID from mapped program headers"); } if (start < end) { err = drgn_module_set_address_range(module, start, end); if (err) return err; drgn_log_debug(prog, "got address range 0x%" PRIx64 "-0x%" PRIx64 " from mapped program headers", start, end); } else { drgn_log_debug(prog, "couldn't find address range from mapped program headers"); } return NULL; } static struct drgn_error * userspace_loaded_module_iterator_yield_main(struct userspace_loaded_module_iterator *it, struct drgn_module **ret, bool *new_ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; struct drgn_mapped_file_segment *segment = find_mapped_file_segment(it, prog->auxv.at_phdr); if (segment) { // We don't need to read the file header to get e_phoff. Instead, // determine it from the file mapping. it->main_phoff = segment->file_offset + (prog->auxv.at_phdr - segment->start); drgn_log_debug(prog, "AT_PHDR is mapped from file %s at offset 0x%" PRIx64, segment->file->path, it->main_phoff); } else { drgn_log_debug(prog, "couldn't find mapped file segment containing AT_PHDR"); } _cleanup_(drgn_module_deletep) struct drgn_module *module = NULL; bool new; err = drgn_module_find_or_create_main(prog, segment ? segment->file->path : "", &module, &new); if (err) return err; if (!new) { *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } err = userspace_loaded_module_iterator_read_main_phdrs(it); if (err) return err; if (it->read_main_phdrs) { err = identify_module_from_phdrs(it, module, prog->auxv.at_phnum, it->main_bias); if (err) return err; } *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } static struct drgn_error * userspace_loaded_module_iterator_yield_vdso(struct userspace_loaded_module_iterator *it, struct drgn_module **ret, bool *new_ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; if (!prog->auxv.at_sysinfo_ehdr) { drgn_log_debug(prog, "no vDSO"); no_vdso: *ret = NULL; return NULL; } drgn_log_debug(prog, "reading vDSO ELF header from AT_SYSINFO_EHDR"); GElf_Ehdr ehdr; err = userspace_loaded_module_iterator_read_ehdr(it, prog->auxv.at_sysinfo_ehdr, &ehdr); if (err == &drgn_not_found) goto no_vdso; else if (err) return err; drgn_log_debug(prog, "reading %" PRIu16 " program headers at 0x%" PRIx64, ehdr.e_phnum, prog->auxv.at_sysinfo_ehdr + ehdr.e_phoff); // It is effectively part of the ABI that the vDSO program headers are // mapped at AT_SYSINFO_EHDR + e_phoff (see the Linux kernel's reference // vDSO parser: vdso_init_from_sysinfo_ehdr() in // tools/testing/selftests/vDSO/parse_vdso.c, glibc: setup_vdso() in // elf/setup-vdso.h, and musl: __vdsosym() in src/internal/vdso.c). err = userspace_loaded_module_iterator_read_phdrs(it, prog->auxv.at_sysinfo_ehdr + ehdr.e_phoff, ehdr.e_phnum); if (err == &drgn_not_found) goto no_vdso; else if (err) return err; // This is based on the Linux kernel's reference vDSO parser. uint64_t bias = prog->auxv.at_sysinfo_ehdr; // Silence -Wmaybe-uninitialized false positives on dyn_vaddr and // dyn_memsz last seen with GCC 12. uint64_t dyn_vaddr = 0, dyn_memsz = 0; bool have_load = false, have_dyn = false; for (size_t i = 0; i < ehdr.e_phnum; i++) { GElf_Phdr phdr; userspace_loaded_module_iterator_phdr(it, i, &phdr); if (phdr.p_type == PT_LOAD && !have_load) { drgn_log_debug(prog, "found PT_LOAD with p_offset 0x%" PRIx64 " and p_vaddr 0x%" PRIx64, phdr.p_offset, phdr.p_vaddr); have_load = true; bias = prog->auxv.at_sysinfo_ehdr + phdr.p_offset - phdr.p_vaddr; } else if (phdr.p_type == PT_DYNAMIC) { drgn_log_debug(prog, "found PT_DYNAMIC with p_offset 0x%" PRIx64 " and p_memsz 0x%" PRIx64, phdr.p_offset, phdr.p_memsz); dyn_vaddr = prog->auxv.at_sysinfo_ehdr + phdr.p_offset; dyn_memsz = phdr.p_memsz; have_dyn = true; } } if (!have_load) { drgn_log_warning(prog, "can't find vDSO: " "no PT_LOAD header in vDSO program headers"); goto no_vdso; } drgn_log_debug(prog, "vDSO bias is 0x%" PRIx64, bias); if (!have_dyn) { drgn_log_warning(prog, "can't find vDSO: " "no PT_DYNAMIC header in vDSO program headers"); goto no_vdso; } it->vdso_dyn_vaddr = dyn_vaddr; it->have_vdso_dyn = true; drgn_log_debug(prog, "reading vDSO dynamic section at 0x%" PRIx64, dyn_vaddr); size_t num_dyn; err = userspace_loaded_module_iterator_read_dynamic(it, dyn_vaddr, dyn_memsz, &num_dyn); if (err == &drgn_not_found) goto no_vdso; else if (err) return err; // Silence -Wmaybe-uninitialized false positives on dt_strtab and // dt_soname last seen with GCC 12. uint64_t dt_strtab = 0, dt_soname = 0; bool have_dt_strtab = false, have_dt_soname = false; for (size_t i = 0; i < num_dyn; i++) { GElf_Dyn dyn; userspace_loaded_module_iterator_dyn(it, i, &dyn); if (dyn.d_tag == DT_STRTAB) { dt_strtab = dyn.d_un.d_ptr; have_dt_strtab = true; drgn_log_debug(prog, "found DT_STRTAB 0x%" PRIx64, dt_strtab); } else if (dyn.d_tag == DT_SONAME) { dt_soname = dyn.d_un.d_val; have_dt_soname = true; drgn_log_debug(prog, "found DT_SONAME 0x%" PRIx64, dt_soname); } else if (dyn.d_tag == DT_NULL) { break; } } if (!have_dt_strtab || !have_dt_soname) { drgn_log_warning(prog, "can't find vDSO: " "no %s%s%s entr%s in vDSO dynamic section", have_dt_strtab ? "" : "DT_STRTAB", have_dt_strtab || have_dt_soname ? "" : " or ", have_dt_soname ? "" : "DT_SONAME", have_dt_strtab || have_dt_soname ? "y" : "ies"); goto no_vdso; } _cleanup_free_ char *name = NULL; err = drgn_program_read_c_string(prog, dt_strtab + bias + dt_soname, false, SIZE_MAX, &name); if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_warning(prog, "can't find vDSO: " "couldn't read soname at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); goto no_vdso; } else if (err) { return err; } drgn_log_debug(prog, "read vDSO soname \"%s\"", name); _cleanup_(drgn_module_deletep) struct drgn_module *module = NULL; bool new; err = drgn_module_find_or_create_vdso(prog, name, dyn_vaddr, &module, &new); if (err) return err; if (!new) { *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } err = identify_module_from_phdrs(it, module, ehdr.e_phnum, bias); if (err) return err; *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } #define read_struct64(prog, struct64p, address, type32, visit_members) \ read_struct64_impl(prog, struct64p, address, type32, visit_members, \ PP_UNIQUE(prog), PP_UNIQUE(struct64p), \ PP_UNIQUE(is_64_bit), PP_UNIQUE(err)) #define read_struct64_impl(prog, struct64p, address, type32, visit_members, \ unique_prog, unique_struct64, unique_is_64_bit, \ unique_err) ({ \ struct drgn_program *unique_prog = (prog); \ __auto_type unique_struct64p = (struct64p); \ static_assert(sizeof(*unique_struct64p) >= sizeof(type32), \ "64-bit type is smaller than 32-bit type"); \ const bool unique_is_64_bit = \ drgn_platform_is_64_bit(&unique_prog->platform); \ struct drgn_error *unique_err = \ drgn_program_read_memory(unique_prog, unique_struct64p, \ (address), \ unique_is_64_bit \ ? sizeof(*unique_struct64p) \ : sizeof(type32), false); \ if (!unique_err) { \ deserialize_struct64_inplace(unique_struct64p, type32, \ visit_members, unique_is_64_bit, \ drgn_platform_bswap(&unique_prog->platform));\ } \ unique_err; \ }) static struct drgn_error * userspace_get_link_map(struct userspace_loaded_module_iterator *it) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; if (!it->read_main_phdrs) { err = userspace_loaded_module_iterator_read_main_phdrs(it); if (err) return err; } if (!it->have_main_dyn) return NULL; drgn_log_debug(prog, "reading main dynamic section"); size_t num_dyn; err = userspace_loaded_module_iterator_read_dynamic(it, it->main_dyn_vaddr, it->main_dyn_memsz, &num_dyn); if (err == &drgn_not_found) { drgn_log_warning(prog, "can't find shared libraries: " "couldn't read main dynamic section"); return NULL; } else if (err) { return err; } GElf_Dyn dyn; size_t i; for (i = 0; i < num_dyn; i++) { userspace_loaded_module_iterator_dyn(it, i, &dyn); if (dyn.d_tag == DT_NULL) { i = num_dyn; break; } if (dyn.d_tag == DT_DEBUG) { drgn_log_debug(prog, "found DT_DEBUG 0x%" PRIx64, dyn.d_un.d_ptr); break; } } if (i >= num_dyn) { drgn_log_warning(prog, "can't find shared libraries: " "no DT_DEBUG entry in main dynamic section"); return NULL; } struct drgn_r_debug { int32_t r_version; alignas(8) uint64_t r_map; } r_debug; struct drgn_r_debug32 { int32_t r_version; uint32_t r_map; }; #define visit_r_debug_members(visit_scalar_member, visit_raw_member) do { \ visit_scalar_member(r_version); \ visit_scalar_member(r_map); \ } while (0) err = read_struct64(prog, &r_debug, dyn.d_un.d_ptr, struct drgn_r_debug32, visit_r_debug_members); #undef visit_r_debug_members if (err && err->code == DRGN_ERROR_FAULT) { // Note: musl doesn't update DT_DEBUG for static PIE binaries // compiled with GCC (as of musl v1.2.3 and GCC 13), so that // case is known to fail here. drgn_log_warning(prog, "can't find shared libraries: " "couldn't read r_debug at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); return NULL; } else if (err) { return err; } drgn_log_debug(prog, "read r_debug = { .r_version = %" PRId32 ", .r_map = 0x%" PRIx64 " }", r_debug.r_version, r_debug.r_map); if (r_debug.r_version < 1) { drgn_log_warning(prog, "can't find shared libraries: " "invalid r_debug.r_version %" PRId32, r_debug.r_version); return NULL; } it->link_map = r_debug.r_map; return NULL; } static struct drgn_error * identify_module_from_link_map(struct userspace_loaded_module_iterator *it, struct drgn_module *module, struct drgn_mapped_file *file, uint64_t l_addr) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; // Even if it is a 32-bit file, segments should be at least a page, so // we should be able to read the 64-bit size. if (file->offset0_size < sizeof(Elf64_Ehdr)) { drgn_log_debug(prog, "didn't find mapped ELF header"); return NULL; } drgn_log_debug(prog, "reading ELF header at 0x%" PRIx64, file->offset0_vaddr); GElf_Ehdr ehdr; err = userspace_loaded_module_iterator_read_ehdr(it, file->offset0_vaddr, &ehdr); if (err == &drgn_not_found) return NULL; else if (err) return err; drgn_log_debug(prog, "reading %" PRIu16 " program headers from 0x%" PRIx64, ehdr.e_phnum, file->offset0_vaddr + ehdr.e_phoff); // e_phnum and e_phentsize are uint16_t, so this can't overflow. uint32_t phdrs_size = (uint32_t)ehdr.e_phnum * (uint32_t)ehdr.e_phentsize; if (ehdr.e_phoff > file->offset0_size || phdrs_size > file->offset0_size - ehdr.e_phoff) { drgn_log_debug(prog, "program header table is not mapped with ELF header"); return NULL; } err = userspace_loaded_module_iterator_read_phdrs(it, file->offset0_vaddr + ehdr.e_phoff, ehdr.e_phnum); if (err == &drgn_not_found) return NULL; else if (err) return err; return identify_module_from_phdrs(it, module, ehdr.e_phnum, l_addr); } // This is the public definition of struct link_map from glibc's link.h: // // struct link_map // { // /* These first few members are part of the protocol with the debugger. // This is the same format used in SVR4. */ // // ElfW(Addr) l_addr; /* Difference between the address in the ELF // file and the addresses in memory. */ // char *l_name; /* Absolute file name object was found in. */ // ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */ // struct link_map *l_next, *l_prev; /* Chain of loaded objects. */ // }; // // We don't need l_prev, so we exclude it from our definition. struct drgn_link_map { uint64_t l_addr; uint64_t l_name; uint64_t l_ld; uint64_t l_next; }; struct drgn_link_map32 { uint32_t l_addr; uint32_t l_name; uint32_t l_ld; uint32_t l_next; }; static struct drgn_error * userspace_next_link_map(struct userspace_loaded_module_iterator *it, struct drgn_link_map *ret, char **name_ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; if (!it->link_map) { drgn_log_debug(prog, "found end of link_map list"); return &drgn_stop; } if (it->state >= USERSPACE_LOADED_MODULE_ITERATOR_STATE_LINK_MAP + MAX_LINK_MAP_LIST_ITERATIONS) { drgn_log_warning(prog, "can't find remaining shared libraries: " "too many entries or cycle in link_map list"); return &drgn_stop; } it->state++; #define visit_link_map_members(visit_scalar_member, visit_raw_member) do { \ visit_scalar_member(l_addr); \ visit_scalar_member(l_name); \ visit_scalar_member(l_ld); \ visit_scalar_member(l_next); \ } while (0) err = read_struct64(prog, ret, it->link_map, struct drgn_link_map32, visit_link_map_members); #undef visit_link_map_members if (err && err->code == DRGN_ERROR_FAULT) { drgn_log_warning(prog, "can't find remaining shared libraries: " "couldn't read next link_map at 0x%" PRIx64 ": %s", err->address, err->message); drgn_error_destroy(err); return &drgn_stop; } else if (err) { return err; } it->link_map = ret->l_next; err = drgn_program_read_c_string(prog, ret->l_name, false, SIZE_MAX, name_ret); if (err && err->code == DRGN_ERROR_FAULT) *name_ret = NULL; else if (err) return err; drgn_log_debug(prog, "read link_map = { .l_addr = 0x%" PRIx64 ", .l_name = 0x%" PRIx64 "%s%s%s, .l_ld = 0x%" PRIx64 ", .l_next = 0x%" PRIx64 " }", ret->l_addr, ret->l_name, *name_ret ? " = \"" : "", *name_ret ? *name_ret : "", *name_ret ? "\"" : "", ret->l_ld, ret->l_next); if (err) { drgn_log_debug(prog, "couldn't read l_name at 0x%" PRIx64 ": %s" "; skipping", err->address, err->message); drgn_error_destroy(err); } return NULL; } static struct drgn_error * yield_from_link_map(struct userspace_loaded_module_iterator *it, struct drgn_module **ret, bool *new_ret) { struct drgn_error *err; struct drgn_program *prog = it->it.prog; for (;;) { struct drgn_link_map link_map; _cleanup_free_ char *name = NULL; err = userspace_next_link_map(it, &link_map, &name); if (err == &drgn_stop) { *ret = NULL; return NULL; } else if (err) { return err; } if (link_map.l_ld == it->main_dyn_vaddr) { drgn_log_debug(prog, "l_ld matches main dynamic section; skipping"); continue; } if (it->have_vdso_dyn && link_map.l_ld == it->vdso_dyn_vaddr) { drgn_log_debug(prog, "l_ld matches vDSO dynamic section; skipping"); continue; } if (!name) continue; _cleanup_(drgn_module_deletep) struct drgn_module *module = NULL; bool new; err = drgn_module_find_or_create_shared_library(prog, name, link_map.l_ld, &module, &new); if (err) return err; if (!new) { *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } struct drgn_mapped_file_segment *segment = find_mapped_file_segment(it, link_map.l_ld); if (segment) { err = identify_module_from_link_map(it, module, segment->file, link_map.l_addr); if (err) return err; } else { drgn_log_debug(prog, "couldn't find mapped file segment containing l_ld"); } *ret = no_cleanup_ptr(module); if (new_ret) *new_ret = new; return NULL; } } static struct drgn_error * userspace_loaded_module_iterator_next(struct drgn_module_iterator *_it, struct drgn_module **ret, bool *new_ret) { struct drgn_error *err; struct userspace_loaded_module_iterator *it = container_of(_it, struct userspace_loaded_module_iterator, it); switch (it->state) { case USERSPACE_LOADED_MODULE_ITERATOR_STATE_MAIN: err = drgn_program_cache_auxv(it->it.prog); if (err) return err; it->state = USERSPACE_LOADED_MODULE_ITERATOR_STATE_VDSO; return userspace_loaded_module_iterator_yield_main(it, ret, new_ret); case USERSPACE_LOADED_MODULE_ITERATOR_STATE_VDSO: it->state = USERSPACE_LOADED_MODULE_ITERATOR_STATE_R_DEBUG; err = userspace_loaded_module_iterator_yield_vdso(it, ret, new_ret); if (err || *ret) return err; fallthrough; case USERSPACE_LOADED_MODULE_ITERATOR_STATE_R_DEBUG: it->state = USERSPACE_LOADED_MODULE_ITERATOR_STATE_LINK_MAP; err = userspace_get_link_map(it); if (err) return err; fallthrough; default: return yield_from_link_map(it, ret, new_ret); } } struct process_mapped_file_entry { dev_t dev; ino_t ino; struct drgn_mapped_file *file; }; struct process_mapped_file_key { dev_t dev; ino_t ino; const char *path; }; static struct process_mapped_file_key process_mapped_file_entry_to_key(const struct process_mapped_file_entry *entry) { return (struct process_mapped_file_key){ .dev = entry->dev, .ino = entry->ino, .path = entry->file->path, }; } static struct hash_pair process_mapped_file_key_hash_pair(const struct process_mapped_file_key *key) { size_t hash = hash_combine(key->dev, key->ino); hash = hash_combine(hash, hash_c_string(key->path)); return hash_pair_from_avalanching_hash(hash); } static bool process_mapped_file_key_eq(const struct process_mapped_file_key *a, const struct process_mapped_file_key *b) { return (a->dev == b->dev && a->ino == b->ino && strcmp(a->path, b->path) == 0); } DEFINE_HASH_TABLE(process_mapped_files, struct process_mapped_file_entry, process_mapped_file_entry_to_key, process_mapped_file_key_hash_pair, process_mapped_file_key_eq); struct process_loaded_module_iterator { struct userspace_loaded_module_iterator u; struct process_mapped_files files; }; static struct drgn_error * process_add_mapping(struct process_loaded_module_iterator *it, const char *maps_path, const char *map_files_path, int map_files_fd, bool *logged_readlink_eperm, bool *logged_stat_eperm, struct drgn_map_files_segment_vector *map_files_segments, struct drgn_mapped_file_segments *segments, char *line, size_t line_len) { struct drgn_program *prog = it->u.it.prog; struct drgn_map_files_segment segment; uint64_t segment_file_offset; unsigned int dev_major, dev_minor; uint64_t ino; int map_name_len, path_index; if (sscanf(line, "%" SCNx64 "-%" SCNx64 "%n %*s %" SCNx64 " %x:%x %" SCNu64 " %n", &segment.start, &segment.end, &map_name_len, &segment_file_offset, &dev_major, &dev_minor, &ino, &path_index) != 6) { return drgn_error_format(DRGN_ERROR_OTHER, "couldn't parse %s", maps_path); } // Skip anonymous mappings. if (ino == 0) return NULL; if (!drgn_map_files_segment_vector_append(map_files_segments, &segment)) return &drgn_enomem; struct process_mapped_file_key key = { .dev = makedev(dev_major, dev_minor), .ino = ino, .path = line + path_index, }; _cleanup_free_ char *real_path = NULL; // /proc/$pid/maps has a couple of ambiguities that // /proc/$pid/map_files/
can help with: // // 1. Newlines in the file path from /proc/$pid/maps are escaped as // \012. However, \ is not escaped, so it is ambiguous whether \012 // is a newline or appeared literally in the path. We can read the // map_files link to get the unescaped path. // 2. The device number in /proc/$pid/maps is incorrect for some // filesystems. Specifically, for Btrfs as of Linux 6.5, it refers to // a filesystem-wide device number rather than the subvolume-specific // device numbers returned by stat. We can stat the map_files link to // get the correct device number. if (map_files_fd >= 0) { char map_files_name[34]; snprintf(map_files_name, sizeof(map_files_name), "%" PRIx64 "-%" PRIx64, segment.start, segment.end); // The escaped path must be at least as long as the original // path, so use that as the readlink buffer size. size_t bufsiz = line_len - path_index + 1; real_path = malloc(bufsiz); if (!real_path) return &drgn_enomem; // Before Linux kernel commit bdb4d100afe9 ("procfs: always // expose /proc//map_files/ and make it readable") (in // v4.3), reading these links required CAP_SYS_ADMIN. Since that // commit, it only requires PTRACE_MODE_READ, which we must have // since we opened /proc/$pid/maps. // // If we can't read this link, we have to fall back to the // escaped path. Newlines and the literal sequence \012 are // unlikely to appear in a path, so it's not a big deal. ssize_t r = readlinkat(map_files_fd, map_files_name, real_path, bufsiz); if (r < 0) { if (errno == EPERM) { free(real_path); real_path = NULL; if (!*logged_readlink_eperm) { drgn_log_debug(prog, "don't have permission to read symlinks in %s", map_files_path); } *logged_readlink_eperm = true; } else if (errno == ENOENT) { // We raced with a change to the mapping. drgn_log_debug(prog, "mapping %s disappeared", map_files_name); return NULL; } else { return drgn_error_format_os("readlink", errno, "%s/%s", map_files_path, map_files_name); } } else if (r >= bufsiz) { // We didn't allocate enough for the link contents. The // only way this is possible is if we raced with the // mapping being replaced by a different path. drgn_log_debug(prog, "mapping %s path changed; skipping", map_files_name); return NULL; } else { real_path[r] = '\0'; key.path = real_path; } // Following these links requires CAP_SYS_ADMIN. If we can't, we // have to fall back to using the device number from // /proc/$pid/maps. Mapping files with the same path and inode // number in different Btrfs subvolumes is unlikely, so this is // also not a big deal. struct stat st; if (fstatat(map_files_fd, map_files_name, &st, 0) < 0) { if (errno == EPERM) { if (!*logged_stat_eperm) { drgn_log_debug(prog, "don't have permission to follow symlinks in %s", map_files_path); } *logged_stat_eperm = true; } else if (errno == ENOENT) { // We raced with a change to the mapping. drgn_log_debug(prog, "mapping %s disappeared", map_files_name); return NULL; } else { return drgn_error_format_os("stat", errno, "%s/%s", map_files_path, map_files_name); } } else { key.dev = st.st_dev; } } struct hash_pair hp = process_mapped_files_hash(&key); struct process_mapped_files_iterator files_it = process_mapped_files_search_hashed(&it->files, &key, hp); if (!files_it.entry) { if (!real_path) { real_path = strdup(key.path); if (!real_path) return &drgn_enomem; } struct drgn_mapped_file *file = drgn_mapped_file_create(real_path); if (!file) return &drgn_enomem; struct process_mapped_file_entry entry = { .dev = key.dev, .ino = key.ino, .file = file, }; if (process_mapped_files_insert_searched(&it->files, &entry, hp, &files_it) < 0) { drgn_mapped_file_destroy(file); return &drgn_enomem; } // real_path is owned by the iterator now. real_path = NULL; } return drgn_add_mapped_file_segment(segments, segment.start, segment.end, segment_file_offset, files_it.entry->file); } static struct drgn_error * process_get_mapped_files(struct process_loaded_module_iterator *it) { struct drgn_error *err; struct drgn_program *prog = it->u.it.prog; #define FORMAT "/proc/%ld/maps" char maps_path[sizeof(FORMAT) - sizeof("%ld") + max_decimal_length(long) + 1]; snprintf(maps_path, sizeof(maps_path), FORMAT, (long)prog->pid); #undef FORMAT _cleanup_fclose_ FILE *maps_file = fopen(maps_path, "r"); if (!maps_file) return drgn_error_create_os("fopen", errno, maps_path); drgn_log_debug(prog, "parsing %s", maps_path); #define FORMAT "/proc/%ld/map_files" char map_files_path[sizeof(FORMAT) - sizeof("%ld") + max_decimal_length(long) + 1]; snprintf(map_files_path, sizeof(map_files_path), FORMAT, (long)prog->pid); #undef FORMAT // Since Linux kernel commit bdb4d100afe9 ("procfs: always expose // /proc//map_files/ and make it readable") (in v4.3), // /proc/$pid/map_files always exists. Before that, it only exists if // CONFIG_CHECKPOINT_RESTORE is enabled. // // If it exists, we should always have permission to open it since we // were able to open /proc/$pid/maps. _cleanup_close_ int map_files_fd = open(map_files_path, O_RDONLY | O_DIRECTORY); if (map_files_fd < 0) { if (errno != ENOENT) { return drgn_error_create_os("open", errno, map_files_path); } drgn_log_debug(prog, "%s: %m", map_files_path); } _cleanup_free_ char *line = NULL; size_t n = 0; bool logged_readlink_eperm = false, logged_stat_eperm = false; // While we're reading /proc/$pid/maps, we might as well cache the // segments for drgn_module_try_proc_files_for_shared_library(). VECTOR(drgn_map_files_segment_vector, map_files_segments); struct drgn_mapped_file_segments segments = DRGN_MAPPED_FILE_SEGMENTS_INIT; for (;;) { errno = 0; ssize_t len; if ((len = getline(&line, &n, maps_file)) == -1) { if (errno) { err = drgn_error_create_os("getline", errno, maps_path); } else { err = NULL; } break; } // Remove the newline. if (len > 0 && line[len - 1] == '\n') line[--len] = '\0'; drgn_log_debug(prog, "read %s", line); err = process_add_mapping(it, maps_path, map_files_path, map_files_fd, &logged_readlink_eperm, &logged_stat_eperm, &map_files_segments, &segments, line, len); if (err) break; } if (err) { drgn_mapped_file_segments_abort(&segments); } else { drgn_debug_info_set_map_files_segments(&prog->dbinfo, &map_files_segments, segments.sorted); userspace_loaded_module_iterator_set_file_segments(&it->u, &segments); } return err; } static void process_loaded_module_iterator_destroy(struct drgn_module_iterator *_it) { struct process_loaded_module_iterator *it = container_of(_it, struct process_loaded_module_iterator, u.it); hash_table_for_each(process_mapped_files, files_it, &it->files) { free((char *)files_it.entry->file->path); drgn_mapped_file_destroy(files_it.entry->file); } process_mapped_files_deinit(&it->files); userspace_loaded_module_iterator_deinit(&it->u); free(it); } static struct drgn_error * process_loaded_module_iterator_create(struct drgn_program *prog, struct drgn_module_iterator **ret) { struct drgn_error *err; struct process_loaded_module_iterator *it = calloc(1, sizeof(*it)); if (!it) return &drgn_enomem; drgn_module_iterator_init(&it->u.it, prog, process_loaded_module_iterator_destroy, userspace_loaded_module_iterator_next); process_mapped_files_init(&it->files); err = process_get_mapped_files(it); if (err) { process_loaded_module_iterator_destroy(&it->u.it); return err; } *ret = &it->u.it; return NULL; } static const char * core_mapped_file_entry_to_key(struct drgn_mapped_file * const *entry) { return (*entry)->path; } DEFINE_HASH_TABLE(core_mapped_files, struct drgn_mapped_file *, core_mapped_file_entry_to_key, c_string_key_hash_pair, c_string_key_eq); struct core_loaded_module_iterator { struct userspace_loaded_module_iterator u; struct core_mapped_files files; }; static struct drgn_error *parse_nt_file_error(struct binary_buffer *bb, const char *pos, const char *message) { return drgn_error_create(DRGN_ERROR_OTHER, "couldn't parse NT_FILE"); } static struct drgn_error * core_get_mapped_files(struct core_loaded_module_iterator *it) { struct drgn_error *err; struct drgn_program *prog = it->u.it.prog; const void *note; size_t note_size; if (find_elf_note(prog->core, "CORE", NT_FILE, ¬e, ¬e_size)) return drgn_error_libelf(); if (!note) { drgn_log_debug(prog, "core doesn't have NT_FILE note"); return NULL; } drgn_log_debug(prog, "parsing NT_FILE"); bool is_64_bit = drgn_platform_is_64_bit(&prog->platform); bool little_endian = drgn_platform_is_little_endian(&prog->platform); struct binary_buffer bb; binary_buffer_init(&bb, note, note_size, little_endian, parse_nt_file_error); // fs/binfmt_elf.c in the Linux kernel source code documents the format // of NT_FILE as: // // long count -- how many files are mapped // long page_size -- units for file_ofs // array of [COUNT] elements of // long start // long end // long file_ofs // followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL... struct nt_file_segment64 { uint64_t start; uint64_t end; uint64_t file_offset; }; struct nt_file_segment32 { uint32_t start; uint32_t end; uint32_t file_offset; }; uint64_t count, page_size; if (is_64_bit) { if ((err = binary_buffer_next_u64(&bb, &count))) return err; if (count > UINT64_MAX / sizeof(struct nt_file_segment64)) return binary_buffer_error(&bb, "count is too large"); if ((err = binary_buffer_next_u64(&bb, &page_size)) || (err = binary_buffer_skip(&bb, count * sizeof(struct nt_file_segment64)))) return err; } else { if ((err = binary_buffer_next_u32_into_u64(&bb, &count))) return err; if (count > UINT64_MAX / sizeof(struct nt_file_segment32)) return binary_buffer_error(&bb, "count is too large"); if ((err = binary_buffer_next_u32_into_u64(&bb, &page_size)) || (err = binary_buffer_skip(&bb, count * sizeof(struct nt_file_segment32)))) return err; } struct drgn_mapped_file_segments segments = DRGN_MAPPED_FILE_SEGMENTS_INIT; for (uint64_t i = 0; i < count; i++) { struct nt_file_segment64 segment; #define visit_nt_file_segment_members(visit_scalar_member, visit_raw_member) do { \ visit_scalar_member(start); \ visit_scalar_member(end); \ visit_scalar_member(file_offset); \ } while (0) deserialize_struct64(&segment, struct nt_file_segment32, visit_nt_file_segment_members, (char *)note + (is_64_bit ? 16 + i * sizeof(struct nt_file_segment64) : 8 + i * sizeof(struct nt_file_segment32)), is_64_bit, bb.bswap); #undef visit_nt_file_segment_members segment.file_offset *= page_size; const char *path = bb.pos; if ((err = binary_buffer_skip_string(&bb))) goto err; drgn_log_debug(prog, "found 0x%" PRIx64 "-0x%" PRIx64 " 0x%" PRIx64 " %s", segment.start, segment.end, segment.file_offset, path); if (segment.start >= segment.end) continue; struct hash_pair hp = core_mapped_files_hash(&path); struct core_mapped_files_iterator files_it = core_mapped_files_search_hashed(&it->files, &path, hp); struct drgn_mapped_file *file; if (files_it.entry) { file = *files_it.entry; } else { file = drgn_mapped_file_create(path); if (!file) { err = &drgn_enomem; goto err; } if (core_mapped_files_insert_searched(&it->files, &file, hp, NULL) < 0) { drgn_mapped_file_destroy(file); err = &drgn_enomem; goto err; } } err = drgn_add_mapped_file_segment(&segments, segment.start, segment.end, segment.file_offset, file); if (err) goto err; } userspace_loaded_module_iterator_set_file_segments(&it->u, &segments); return NULL; err: drgn_mapped_file_segments_abort(&segments); return err; } static void core_loaded_module_iterator_destroy(struct drgn_module_iterator *_it) { struct core_loaded_module_iterator *it = container_of(_it, struct core_loaded_module_iterator, u.it); hash_table_for_each(core_mapped_files, files_it, &it->files) drgn_mapped_file_destroy(*files_it.entry); core_mapped_files_deinit(&it->files); userspace_loaded_module_iterator_deinit(&it->u); free(it); } static struct drgn_error * core_loaded_module_iterator_create(struct drgn_program *prog, struct drgn_module_iterator **ret) { struct drgn_error *err; struct core_loaded_module_iterator *it = calloc(1, sizeof(*it)); if (!it) return &drgn_enomem; drgn_module_iterator_init(&it->u.it, prog, core_loaded_module_iterator_destroy, userspace_loaded_module_iterator_next); core_mapped_files_init(&it->files); err = core_get_mapped_files(it); if (err) { core_loaded_module_iterator_destroy(&it->u.it); return err; } *ret = &it->u.it; return NULL; } static struct drgn_error * null_module_iterator_create(struct drgn_program *prog, struct drgn_module_iterator **ret) { struct drgn_module_iterator *it = calloc(1, sizeof(*it)); if (!it) return &drgn_enomem; drgn_module_iterator_init(it, prog, NULL, NULL); *ret = it; return NULL; } LIBDRGN_PUBLIC struct drgn_error * drgn_loaded_module_iterator_create(struct drgn_program *prog, struct drgn_module_iterator **ret) { if (prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL) return linux_kernel_loaded_module_iterator_create(prog, ret); else if (drgn_program_is_userspace_process(prog)) return process_loaded_module_iterator_create(prog, ret); else if (drgn_program_is_userspace_core(prog)) return core_loaded_module_iterator_create(prog, ret); else return null_module_iterator_create(prog, ret); } static inline void drgn_module_iterator_destroyp(struct drgn_module_iterator **itp) { drgn_module_iterator_destroy(*itp); } LIBDRGN_PUBLIC struct drgn_error * drgn_create_loaded_modules(struct drgn_program *prog) { _cleanup_(drgn_module_iterator_destroyp) struct drgn_module_iterator *it = NULL; struct drgn_error *err = drgn_loaded_module_iterator_create(prog, &it); if (err) return err; struct drgn_module *module; while (!(err = drgn_module_iterator_next(it, &module, NULL)) && module); return err; } struct load_debug_info_file { const char *path; // We only keep this to keep load_debug_info_provided::build_id alive // without needing to copy it. If we add a drgn_module_try_file API that // allows providing an Elf handle, we could pass it down. Elf *elf; // This may be consumed and set to -1. int fd; }; DEFINE_VECTOR(load_debug_info_file_vector, struct load_debug_info_file); struct load_debug_info_provided { const void *build_id; size_t build_id_len; struct load_debug_info_file_vector files; bool matched; }; static struct nstring load_debug_info_provided_key(const struct load_debug_info_provided *provided) { return (struct nstring){ provided->build_id, provided->build_id_len }; } DEFINE_HASH_TABLE(load_debug_info_provided_table, struct load_debug_info_provided, load_debug_info_provided_key, nstring_hash_pair, nstring_eq); struct load_debug_info_state { // Provided files grouped by build ID. struct load_debug_info_provided_table provided; // Number of entries in the provided table that haven't matched any // modules. size_t unmatched_provided; }; static struct drgn_error * load_debug_info_add_provided_file(struct drgn_program *prog, struct load_debug_info_state *state, const char *path) { _cleanup_close_ int fd = open(path, O_RDONLY); if (fd < 0) { drgn_log_warning(prog, "%s: %m; ignoring", path); return NULL; } _cleanup_elf_end_ Elf *elf = dwelf_elf_begin(fd); if (!elf) { drgn_log_warning(prog, "%s: %s; ignoring", path, elf_errmsg(-1)); return NULL; } if (elf_kind(elf) != ELF_K_ELF) { drgn_log_warning(prog, "%s: not an ELF file; ignoring", path); return NULL; } const void *build_id; ssize_t build_id_len = drgn_elf_gnu_build_id(elf, &build_id); if (build_id_len <= 0) { if (build_id_len < 0) { drgn_log_warning(prog, "%s: %s; ignoring", path, elf_errmsg(-1)); } else { drgn_log_warning(prog, "%s: no build ID; ignoring", path); } return NULL; } if (drgn_log_is_enabled(prog, DRGN_LOG_DEBUG)) { _cleanup_free_ char *build_id_str = ahexlify(build_id, build_id_len); if (!build_id_str) return &drgn_enomem; drgn_log_debug(prog, "provided file %s build ID %s", path, build_id_str); } struct load_debug_info_provided provided = { .build_id = build_id, .build_id_len = build_id_len, }; struct load_debug_info_provided_table_iterator it; int r = load_debug_info_provided_table_insert(&state->provided, &provided, &it); if (r < 0) return &drgn_enomem; if (r > 0) { load_debug_info_file_vector_init(&it.entry->files); state->unmatched_provided++; } struct load_debug_info_file file = { .path = path, .fd = fd, .elf = elf, }; if (!load_debug_info_file_vector_append(&it.entry->files, &file)) { if (load_debug_info_file_vector_empty(&it.entry->files)) { // The key will no longer be valid once we free the Elf // handle, so we need to delete the entry. load_debug_info_provided_table_delete_iterator(&state->provided, it); } return &drgn_enomem; } // fd and elf are owned by state now. fd = -1; elf = NULL; return NULL; } static void load_debug_info_state_deinit(struct load_debug_info_state *state) { hash_table_for_each(load_debug_info_provided_table, it, &state->provided) { vector_for_each(load_debug_info_file_vector, file, &it.entry->files) { elf_end(file->elf); if (file->fd >= 0) close(file->fd); } load_debug_info_file_vector_deinit(&it.entry->files); } load_debug_info_provided_table_deinit(&state->provided); } static struct load_debug_info_provided * load_debug_info_find_provided(struct load_debug_info_state *state, const void *build_id, size_t build_id_len) { struct nstring key = { build_id, build_id_len }; struct load_debug_info_provided *provided = load_debug_info_provided_table_search(&state->provided, &key).entry; if (provided && !provided->matched) { state->unmatched_provided--; provided->matched = true; } return provided; } static struct drgn_error * load_debug_info_try_provided(struct drgn_module *module, struct load_debug_info_provided *provided, enum drgn_module_file_status not_status) { struct drgn_error *err; vector_for_each(load_debug_info_file_vector, file, &provided->files) { // No need to check build ID again. err = drgn_module_try_file_internal(module, file->path, file->fd, false, NULL); // drgn_module_try_file_internal took ownership of file->fd. In // the unlikely scenario that another module has the same build // ID, we'll just have to reopen it by path. file->fd = -1; if (err) return err; if (module->loaded_file_status != not_status && module->debug_file_status != not_status) break; } return NULL; } static struct drgn_error * load_debug_info_try_provided_supplementary_files(struct drgn_module *module, struct load_debug_info_state *state) { const void *checksum; size_t checksum_len; if (drgn_module_wanted_supplementary_debug_file(module, NULL, NULL, &checksum, &checksum_len) != DRGN_SUPPLEMENTARY_FILE_GNU_DEBUGALTLINK) return NULL; struct load_debug_info_provided *provided = load_debug_info_find_provided(state, checksum, checksum_len); if (!provided) return NULL; drgn_module_try_supplementary_debug_file_log(module, "trying provided files for"); return load_debug_info_try_provided(module, provided, DRGN_MODULE_FILE_WANT_SUPPLEMENTARY); } static struct drgn_error * load_debug_info_try_provided_vmlinux(struct drgn_module *module, struct load_debug_info_state *state) { struct drgn_error *err; struct drgn_program *prog = module->prog; bool logged_trying = false; hash_table_for_each(load_debug_info_provided_table, it, &state->provided) { vector_for_each(load_debug_info_file_vector, file, &it.entry->files) { int r = elf_is_vmlinux(file->elf); if (r < 0) { drgn_log_debug(prog, "%s: %s", file->path, elf_errmsg(-1)); } if (r <= 0) continue; if (!logged_trying) { drgn_module_try_files_log(module, "(Linux version %s): trying provided files for", prog->vmcoreinfo.osrelease); logged_trying = true; } const char *release; ssize_t release_len = elf_vmlinux_release(file->elf, &release); if (release_len < 0) { drgn_log_debug(prog, "%s: %s", file->path, elf_errmsg(-1)); continue; } else if (release_len == 0) { drgn_log_debug(prog, "%s: %s Linux version not found", module->name, file->path); continue; } if (strlen(prog->vmcoreinfo.osrelease) == release_len && memcmp(release, prog->vmcoreinfo.osrelease, release_len) == 0) { drgn_log_debug(prog, "%s: %s Linux version matches", module->name, file->path); } else { drgn_log_debug(prog, "%s: %s Linux version (%.*s) does not match", module->name, file->path, release_len > INT_MAX ? INT_MAX : (int)release_len, release); continue; } if (!it.entry->matched) { state->unmatched_provided--; it.entry->matched = true; } err = drgn_module_try_file_internal(module, file->path, file->fd, true, NULL); file->fd = -1; if (err) return err; if (module->loaded_file_status != DRGN_MODULE_FILE_WANT && module->debug_file_status != DRGN_MODULE_FILE_WANT) break; } } return NULL; } static struct drgn_error * load_debug_info_try_provided_files(struct drgn_module *module, struct load_debug_info_state *state) { struct drgn_error *err; err = load_debug_info_try_provided_supplementary_files(module, state); if (err) return err; const void *build_id; size_t build_id_len; drgn_module_build_id(module, &build_id, &build_id_len); if (build_id_len > 0) { // Look up the provided file even if we don't need it so that it // counts as matched. struct load_debug_info_provided *provided = load_debug_info_find_provided(state, build_id, build_id_len); if (provided && drgn_module_wants_file(module)) { uint64_t orig_supplementary_file_generation = module->prog->dbinfo.supplementary_file_generation; drgn_module_try_files_log(module, "trying provided files for"); err = load_debug_info_try_provided(module, provided, DRGN_MODULE_FILE_WANT); if (err) return err; // If the wanted supplementary debug file changed, try // finding it again. if (drgn_module_wanted_supplementary_debug_file_is_new(module, orig_supplementary_file_generation)) { err = load_debug_info_try_provided_supplementary_files(module, state); if (err) return err; } } } else if (module->prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL && drgn_module_kind(module) == DRGN_MODULE_MAIN) { // Before Linux kernel commit 0935288c6e00 ("kdump: append // kernel build-id string to VMCOREINFO") (in v5.9) and in a few // broken stable versions (see // ignore_broken_vmcoreinfo_build_id()), we can't get the // vmlinux build ID from a kernel core dump. Fall back to // checking every provided file for a vmlinux file with a // matching version. err = load_debug_info_try_provided_vmlinux(module, state); if (err) return err; } return NULL; } static void load_debug_info_log_missing(struct drgn_module *module, unsigned int max_warnings, unsigned int *num_missing) { if (++(*num_missing) > max_warnings) return; const char *missing_loaded = ""; if (drgn_module_loaded_file_status(module) == DRGN_MODULE_FILE_WANT) { switch (drgn_module_kind(module)) { case DRGN_MODULE_MAIN: missing_loaded = "executable file"; break; case DRGN_MODULE_SHARED_LIBRARY: case DRGN_MODULE_VDSO: missing_loaded = "shared object file"; break; default: missing_loaded = "loaded file"; break; } } const char *missing_debug; switch (drgn_module_debug_file_status(module)) { case DRGN_MODULE_FILE_WANT: missing_debug = "debugging symbols"; break; case DRGN_MODULE_FILE_WANT_SUPPLEMENTARY: missing_debug = "supplementary debugging symbols"; break; default: missing_debug = ""; break; } const char *name_extra = ""; if (module->prog->flags & DRGN_PROGRAM_IS_LINUX_KERNEL && drgn_module_kind(module) == DRGN_MODULE_MAIN) name_extra = module->prog->vmcoreinfo.osrelease; drgn_log_warning(module->prog, "missing %s%s%s for %s%s%s", missing_loaded, missing_loaded[0] && missing_debug[0] ? " and ": "", missing_debug, module->name, name_extra[0] ? " " : "", name_extra); } LIBDRGN_PUBLIC struct drgn_error * drgn_program_load_debug_info(struct drgn_program *prog, const char **paths, size_t n, bool load_default, bool load_main) { struct drgn_error *err; if (n == 0 && !load_default && !load_main) { // We don't have any files to try. Don't create any modules. return NULL; } drgn_blocking_guard(blocking_state); const char *env = getenv("DRGN_MAX_DEBUG_INFO_ERRORS"); unsigned int max_warnings = env ? atoi(env) : 5; unsigned int num_missing = 0; drgn_log_debug(prog, "loading %sdebugging symbols", load_default ? "default " : load_main ? "main " : ""); _cleanup_(load_debug_info_state_deinit) struct load_debug_info_state state = { .provided = HASH_TABLE_INIT, }; for (size_t i = 0; i < n; i++) { err = load_debug_info_add_provided_file(prog, &state, paths[i]); if (err) return err; } if (load_debug_info_provided_table_empty(&state.provided) && !load_default && !load_main) { drgn_log_debug(prog, "no usable provided files"); return NULL; } uint64_t old_generation = prog->dbinfo.load_debug_info_generation; _cleanup_(drgn_module_iterator_destroyp) struct drgn_module_iterator *it = NULL; err = drgn_loaded_module_iterator_create(prog, &it); if (err) return err; it->for_load_debug_info = true; VECTOR(drgn_module_vector, modules); struct drgn_module *module; while (!(err = drgn_module_iterator_next(it, &module, NULL)) && module) { // Reset DONT_WANT to WANT. if (module->loaded_file_status == DRGN_MODULE_FILE_DONT_WANT) module->loaded_file_status = DRGN_MODULE_FILE_WANT; if (module->debug_file_status == DRGN_MODULE_FILE_DONT_WANT) module->debug_file_status = DRGN_MODULE_FILE_WANT; err = load_debug_info_try_provided_files(module, &state); if (err) return err; if (drgn_module_wants_file(module) && (load_default || (load_main && drgn_module_kind(module) == DRGN_MODULE_MAIN)) && !drgn_module_vector_append(&modules, &module)) return &drgn_enomem; } if (err) return err; struct drgn_module **wanted_modules = drgn_module_vector_begin(&modules); size_t num_wanted_modules = drgn_module_vector_size(&modules); // The module iterator may have tried to load debug info, so we need to // check each module again. if (num_wanted_modules > 0) { uint64_t new_generation = ++prog->dbinfo.load_debug_info_generation; size_t new_num_wanted_modules = 0; for (size_t i = 0; i < num_wanted_modules; i++) { module = wanted_modules[i]; if (module->load_debug_info_generation <= old_generation) { // Reset DONT_WANT to WANT. if (module->loaded_file_status == DRGN_MODULE_FILE_DONT_WANT) module->loaded_file_status = DRGN_MODULE_FILE_WANT; if (module->debug_file_status == DRGN_MODULE_FILE_DONT_WANT) module->debug_file_status = DRGN_MODULE_FILE_WANT; if (drgn_module_wants_file(module)) { wanted_modules[new_num_wanted_modules++] = module; module->load_debug_info_generation = new_generation; } } else if (drgn_module_wants_file(module)) { load_debug_info_log_missing(module, max_warnings, &num_missing); } } num_wanted_modules = new_num_wanted_modules; } if (num_wanted_modules > 0) { uint64_t orig_supplementary_file_generation = prog->dbinfo.supplementary_file_generation; drgn_handler_list_for_each_enabled(struct drgn_debug_info_finder, finder, &prog->dbinfo.debug_info_finders) { err = finder->ops.find(wanted_modules, num_wanted_modules, finder->arg); if (err) return err; size_t new_num_wanted_modules = 0; for (size_t i = 0; i < num_wanted_modules; i++) { module = wanted_modules[i]; // If there are no more finders to try after // this and a finder changed the wanted // supplementary debug file, try to find a // provided file for it one last time. if (drgn_handler_is_last_enabled(&finder->handler) && drgn_module_wanted_supplementary_debug_file_is_new(module, orig_supplementary_file_generation)) { err = load_debug_info_try_provided_supplementary_files(module, &state); if (err) return err; } if (drgn_module_wants_file(module)) { wanted_modules[new_num_wanted_modules++] = module; } } num_wanted_modules = new_num_wanted_modules; if (num_wanted_modules == 0) break; } } if (state.unmatched_provided != 0) { hash_table_for_each(load_debug_info_provided_table, pit, &state.provided) { if (!pit.entry->matched) { vector_for_each(load_debug_info_file_vector, file, &pit.entry->files) { drgn_log_warning(prog, "provided file %s did not match any loaded modules; ignoring", file->path); } } } } for (size_t i = 0; i < num_wanted_modules; i++) { load_debug_info_log_missing(wanted_modules[i], max_warnings, &num_missing); } if (num_missing > max_warnings) { drgn_log_warning(prog, "... missing %u more", num_missing - max_warnings); } // Update the DWARF index eagerly, mostly because that's what we did // back when we used libdwfl. We may want to remove this in the future. err = drgn_dwarf_info_update_index(&prog->dbinfo); if (err) return err; if (num_missing > 0) { return drgn_error_create(DRGN_ERROR_MISSING_DEBUG_INFO, "missing some debugging symbols; see https://drgn.readthedocs.io/en/latest/getting_debugging_symbols.html"); } return NULL; } LIBDRGN_PUBLIC struct drgn_error * drgn_load_module_debug_info(struct drgn_module **modules, size_t *num_modulesp) { struct drgn_error *err; const size_t orig_num_modules = *num_modulesp; if (orig_num_modules == 0) return NULL; struct drgn_program *prog = modules[0]->prog; drgn_log_debug(prog, "loading debugging symbols for %zu modules", orig_num_modules); size_t num_wanted_modules = 0; for (size_t i = 0; i < orig_num_modules; i++) { if (modules[i]->prog != prog) { return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, "modules are from different programs"); } if (drgn_module_wants_file(modules[i])) { modules[num_wanted_modules++] = modules[i]; } else if (modules[i]->loaded_file_status == DRGN_MODULE_FILE_DONT_WANT || modules[i]->loaded_file_status == DRGN_MODULE_FILE_DONT_WANT) { drgn_log_debug(prog, "debugging symbols not wanted for %s", modules[i]->name); } else { drgn_log_debug(prog, "debugging symbols already loaded for %s", modules[i]->name); } } if (num_wanted_modules == 0) { *num_modulesp = 0; return NULL; } uint64_t generation = ++prog->dbinfo.load_debug_info_generation; for (size_t i = 0; i < num_wanted_modules; i++) modules[i]->load_debug_info_generation = generation; drgn_blocking_guard(blocking_state); const size_t orig_num_wanted_modules = num_wanted_modules; drgn_handler_list_for_each_enabled(struct drgn_debug_info_finder, finder, &prog->dbinfo.debug_info_finders) { err = finder->ops.find(modules, num_wanted_modules, finder->arg); if (err) return err; size_t new_num_wanted_modules = 0; for (size_t i = 0; i < num_wanted_modules; i++) { if (drgn_module_wants_file(modules[i])) modules[new_num_wanted_modules++] = modules[i]; } num_wanted_modules = new_num_wanted_modules; if (num_wanted_modules == 0) break; } drgn_log_debug(prog, "debugging symbols loaded for %zu/%zu modules", orig_num_wanted_modules - num_wanted_modules, orig_num_wanted_modules); *num_modulesp = num_wanted_modules; return NULL; } static struct drgn_error * elf_symbols_search(const char *name, uint64_t addr, enum drgn_find_symbol_flags flags, void *data, struct drgn_symbol_result_builder *builder) { struct drgn_error *err; struct drgn_program *prog = data; if (flags & DRGN_FIND_SYMBOL_ADDR) { struct drgn_module *module = drgn_module_find_by_address(prog, addr); if (!module) return NULL; return drgn_module_elf_symbols_search(module, name, addr, flags, builder); } else { hash_table_for_each(drgn_module_table, it, &prog->dbinfo.modules) { for (struct drgn_module *module = *it.entry; module; module = module->next_same_name) { err = drgn_module_elf_symbols_search(module, name, addr, flags, builder); if (err == &drgn_stop) break; if (err) return err; } } return NULL; } } void drgn_debug_info_init(struct drgn_debug_info *dbinfo, struct drgn_program *prog) { elf_version(EV_CURRENT); dbinfo->prog = prog; drgn_module_table_init(&dbinfo->modules); drgn_module_address_tree_init(&dbinfo->modules_by_address); const struct drgn_type_finder_ops type_finder_ops = { .find = drgn_debug_info_find_type, }; drgn_program_register_type_finder_impl(prog, &dbinfo->type_finder, "dwarf", &type_finder_ops, dbinfo, 0); const struct drgn_object_finder_ops object_finder_ops = { .find = drgn_debug_info_find_object, }; drgn_program_register_object_finder_impl(prog, &dbinfo->object_finder, "dwarf", &object_finder_ops, dbinfo, 0); const struct drgn_symbol_finder_ops symbol_finder_ops = { .find = elf_symbols_search, }; drgn_program_register_symbol_finder_impl(prog, &dbinfo->symbol_finder, "elf", &symbol_finder_ops, prog, 0); const struct drgn_debug_info_finder_ops standard_debug_info_finder_ops = { .find = drgn_standard_debug_info_find, }; drgn_program_register_debug_info_finder_impl(prog, &dbinfo->standard_debug_info_finder, "standard", &standard_debug_info_finder_ops, &dbinfo->options, 0); drgn_debug_info_options_init(&dbinfo->options); #if WITH_DEBUGINFOD dbinfo->debuginfod_client = NULL; if (drgn_have_debuginfod()) { const struct drgn_debug_info_finder_ops debuginfod_debug_info_finder_ops = { .find = drgn_debuginfod_find, }; drgn_program_register_debug_info_finder_impl(prog, &dbinfo->debuginfod_debug_info_finder, "debuginfod", &debuginfod_debug_info_finder_ops, prog, DRGN_HANDLER_REGISTER_ENABLE_LAST); } #endif drgn_dwarf_info_init(dbinfo); } void drgn_debug_info_deinit(struct drgn_debug_info *dbinfo) { free(dbinfo->map_files_segments); drgn_debug_info_options_deinit(&dbinfo->options); #if WITH_DEBUGINFOD if (dbinfo->debuginfod_client) drgn_debuginfod_end(dbinfo->debuginfod_client); #endif drgn_handler_list_deinit(struct drgn_debug_info_finder, finder, &dbinfo->debug_info_finders, if (finder->ops.destroy) finder->ops.destroy(finder->arg); ); drgn_dwarf_info_deinit(dbinfo); hash_table_for_each(drgn_module_table, it, &dbinfo->modules) { struct drgn_module *module = *it.entry; do { struct drgn_module *next = module->next_same_name; drgn_module_destroy(module); module = next; } while (module); } drgn_module_table_deinit(&dbinfo->modules); } struct drgn_elf_file *drgn_module_find_dwarf_file(struct drgn_module *module, Dwarf *dwarf) { if (!module->debug_file) return NULL; if (dwarf == module->debug_file->_dwarf) return module->debug_file; if (module->supplementary_debug_file && dwarf == module->supplementary_debug_file->_dwarf) return module->supplementary_debug_file; struct drgn_elf_file_dwarf_table_iterator it = drgn_elf_file_dwarf_table_search(&module->split_dwarf_files, &dwarf); return it.entry ? *it.entry : NULL; } struct drgn_error * drgn_module_create_split_dwarf_file(struct drgn_module *module, const char *name, Dwarf *dwarf, struct drgn_elf_file **ret) { struct drgn_error *err; err = drgn_elf_file_create(module, name, -1, NULL, dwarf_getelf(dwarf), ret); if (err) return err; (*ret)->_dwarf = dwarf; int r = drgn_elf_file_dwarf_table_insert(&module->split_dwarf_files, ret, NULL); if (r < 0) { drgn_elf_file_destroy(*ret); return &drgn_enomem; } assert(r > 0); return NULL; } struct drgn_error * drgn_module_find_cfi(struct drgn_program *prog, struct drgn_module *module, uint64_t pc, struct drgn_elf_file **file_ret, struct drgn_cfi_row **row_ret, bool *interrupted_ret, drgn_register_number *ret_addr_regno_ret) { struct drgn_error *err; // If the file's platform doesn't match the program's, we can't use its // CFI. const bool can_use_loaded_file = (module->loaded_file && drgn_platforms_equal(&module->loaded_file->platform, &prog->platform)); const bool can_use_debug_file = (module->debug_file && drgn_platforms_equal(&module->debug_file->platform, &prog->platform)); bool prefer_orc = false; if (can_use_debug_file) { if (!module->parsed_debug_frame) { err = drgn_module_parse_debug_frame(module); if (err) return err; module->parsed_debug_frame = true; } if (!module->parsed_orc) { err = drgn_module_parse_orc(module, false); if (err) return err; // For some distributions, such as Fedora & derivatives, // ORC sections are stripped from the debug file. Try // using built-in ORC if nothing was loaded from the // debug_file. if (!module->orc.num_entries) err = drgn_module_parse_orc(module, true); if (err) return err; module->parsed_orc = true; } prefer_orc = drgn_module_should_prefer_orc_cfi(module, pc); *file_ret = module->debug_file; if (prefer_orc) { err = drgn_module_find_orc_cfi(module, pc, row_ret, interrupted_ret, ret_addr_regno_ret); if (err != &drgn_not_found) return err; } err = drgn_module_find_dwarf_cfi(module, pc, row_ret, interrupted_ret, ret_addr_regno_ret); if (err != &drgn_not_found) return err; } if (can_use_loaded_file) { if (!module->parsed_eh_frame) { err = drgn_module_parse_eh_frame(module); if (err) return err; module->parsed_eh_frame = true; } *file_ret = module->loaded_file; err = drgn_module_find_eh_cfi(module, pc, row_ret, interrupted_ret, ret_addr_regno_ret); if (err != &drgn_not_found) return err; } if (can_use_debug_file && !prefer_orc) { err = drgn_module_find_orc_cfi(module, pc, row_ret, interrupted_ret, ret_addr_regno_ret); if (err != &drgn_not_found) return err; } if (!can_use_debug_file) { if (!module->parsed_orc) { err = drgn_module_parse_orc(module, true); if (err) return err; module->parsed_orc = true; } *file_ret = NULL; err = drgn_module_find_orc_cfi(module, pc, row_ret, interrupted_ret, ret_addr_regno_ret); if (err != &drgn_not_found) return err; } return &drgn_not_found; }