// Copyright (c) Meta Platforms, Inc. and affiliates. // SPDX-License-Identifier: LGPL-2.1-or-later #include #include #include "elf_notes.h" #include "util.h" bool next_elf_note(const void **p, size_t *size, unsigned int align, bool bswap, GElf_Nhdr *nhdr_ret, const char **name_ret, const void **desc_ret) { uint64_t align_mask = align - 1; if (*size < sizeof(*nhdr_ret)) return false; memcpy(nhdr_ret, *p, sizeof(*nhdr_ret)); if (bswap) { nhdr_ret->n_namesz = bswap_32(nhdr_ret->n_namesz); nhdr_ret->n_descsz = bswap_32(nhdr_ret->n_descsz); nhdr_ret->n_type = bswap_32(nhdr_ret->n_type); } if (nhdr_ret->n_namesz > *size - sizeof(*nhdr_ret)) return false; uint64_t aligned_namesz = (nhdr_ret->n_namesz + align_mask) & ~align_mask; if (nhdr_ret->n_descsz > 0 && (aligned_namesz > *size - sizeof(*nhdr_ret) || nhdr_ret->n_descsz > *size - sizeof(*nhdr_ret) - aligned_namesz)) return false; *p = (const char *)*p + sizeof(*nhdr_ret); *size -= sizeof(*nhdr_ret); *name_ret = *p; if (aligned_namesz > *size) { *p = (const char *)*p + *size; *size = 0; } else { *p = (const char *)*p + aligned_namesz; *size -= aligned_namesz; } *desc_ret = *p; uint64_t aligned_descsz = (nhdr_ret->n_descsz + align_mask) & ~align_mask; if (aligned_descsz > *size) { *p = (const char *)*p + *size; *size = 0; } else { *p = (const char *)*p + aligned_descsz; *size -= aligned_descsz; } return true; } int find_elf_note(Elf *elf, const char *name, uint32_t type, const void **ret, size_t *size_ret) { size_t phnum; if (elf_getphdrnum(elf, &phnum)) return -1; size_t name_size = strlen(name) + 1; for (size_t i = 0; i < phnum; i++) { GElf_Phdr phdr_mem, *phdr = gelf_getphdr(elf, i, &phdr_mem); if (!phdr) return -1; if (phdr->p_type != PT_NOTE) continue; Elf_Data *data = elf_getdata_rawchunk(elf, phdr->p_offset, phdr->p_filesz, note_header_type(phdr->p_align)); if (!data) return -1; GElf_Nhdr nhdr; size_t offset = 0, name_offset, desc_offset; while (offset < data->d_size && (offset = gelf_getnote(data, offset, &nhdr, &name_offset, &desc_offset))) { const char *note_name = (char *)data->d_buf + name_offset; if (nhdr.n_namesz == name_size && memcmp(note_name, name, name_size) == 0 && nhdr.n_type == type) { *ret = (char *)data->d_buf + desc_offset; *size_ret = nhdr.n_descsz; return 0; } } } *ret = NULL; *size_ret = 0; return 0; } size_t parse_gnu_build_id_from_notes(const void *buf, size_t size, unsigned int align, bool bswap, const void **ret) { GElf_Nhdr nhdr; const char *name; const void *desc; while (next_elf_note(&buf, &size, align, bswap, &nhdr, &name, &desc)) { if (nhdr.n_namesz == sizeof("GNU") && memcmp(name, "GNU", sizeof("GNU")) == 0 && nhdr.n_type == NT_GNU_BUILD_ID && nhdr.n_descsz > 0) { *ret = desc; return nhdr.n_descsz; } } *ret = NULL; return 0; } #if _ELFUTILS_PREREQ(0, 175) ssize_t drgn_elf_gnu_build_id(Elf *elf, const void **ret) { GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr(elf, &ehdr_mem); if (!ehdr) return -1; bool bswap = (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) != HOST_LITTLE_ENDIAN; Elf_Data *nhdr8_data = NULL; size_t num_note_sections = 0; Elf_Scn *scn = elf_nextscn(elf, NULL); if (scn) { do { GElf_Shdr shdr_mem, *shdr = gelf_getshdr(scn, &shdr_mem); if (!shdr || shdr->sh_type != SHT_NOTE) continue; num_note_sections++; Elf_Data *data = elf_rawdata(scn, NULL); if (!data) continue; if (data->d_type == ELF_T_NHDR8) nhdr8_data = data; unsigned int align = data->d_type == ELF_T_NHDR8 ? 8 : 4; const void *build_id; size_t size = parse_gnu_build_id_from_notes(data->d_buf, data->d_size, align, bswap, &build_id); if (size) { *ret = build_id; return size; } } while ((scn = elf_nextscn(elf, scn))); } else { size_t phnum; if (elf_getphdrnum(elf, &phnum)) return -1; for (size_t i = 0; i < phnum; i++) { GElf_Phdr phdr_mem, *phdr = gelf_getphdr(elf, i, &phdr_mem); if (!phdr || phdr->p_type != PT_NOTE) continue; num_note_sections++; Elf_Data *data = elf_getdata_rawchunk(elf, phdr->p_offset, phdr->p_filesz, note_header_type(phdr->p_align)); if (!data) continue; if (data->d_type == ELF_T_NHDR8) nhdr8_data = data; unsigned int align = data->d_type == ELF_T_NHDR8 ? 8 : 4; const void *build_id; size_t size = parse_gnu_build_id_from_notes(data->d_buf, data->d_size, align, bswap, &build_id); if (size) { *ret = build_id; return size; } } } // Before Linux kernel commit f7ba52f302fd ("vmlinux.lds.h: Discard // .note.gnu.property section") (in v6.4), the vmlinux .notes section // may specify an 8-byte alignment even though it is actually 4-byte // aligned. This fix was backported to several stable and longterm // kernels, but it never made it to the 4.14 and 4.19 longterm branches. // So, we try to work around this bug here. // // If there is only one note section (or segment) and it specifies // 8-byte alignment, then it might be affected by this bug, so we retry // with 4-byte alignment. // // Whenever we drop Linux 4.14 and 4.19 support, we can probably drop // this workaround and just use dwelf_elf_gnu_build_id(). if (nhdr8_data && num_note_sections == 1) { return parse_gnu_build_id_from_notes(nhdr8_data->d_buf, nhdr8_data->d_size, 4, bswap, ret); } *ret = NULL; return 0; } #endif