/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ // Copyright (c) 2006, 2011, 2012 Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Restructured in 2009 by: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com> // (derived from) // dump_symbols.cc: implement google_breakpad::WriteSymbolFile: // Find all the debugging info in a file and dump it as a Breakpad symbol file. // // dump_symbols.h: Read debugging information from an ELF file, and write // it out as a Breakpad symbol file. // This file is derived from the following files in // toolkit/crashreporter/google-breakpad: // src/common/linux/dump_symbols.cc // src/common/linux/elfutils.cc // src/common/linux/file_id.cc #include <errno.h> #include <fcntl.h> #include <stdio.h> #include <string.h> #include <sys/mman.h> #include <sys/stat.h> #include <unistd.h> #include <arpa/inet.h> #include <set> #include <string> #include <vector> #include "mozilla/Assertions.h" #include "mozilla/Sprintf.h" #include "LulPlatformMacros.h" #include "LulCommonExt.h" #include "LulDwarfExt.h" #include "LulElfInt.h" #include "LulMainInt.h" #if defined(LUL_PLAT_arm_android) && !defined(SHT_ARM_EXIDX) // bionic and older glibsc don't define it # define SHT_ARM_EXIDX (SHT_LOPROC + 1) #endif // This namespace contains helper functions. namespace { using lul::DwarfCFIToModule; using lul::FindElfSectionByName; using lul::GetOffset; using lul::IsValidElf; using lul::Module; using lul::UniqueStringUniverse; using lul::scoped_ptr; using lul::Summariser; using std::string; using std::vector; using std::set; // // FDWrapper // // Wrapper class to make sure opened file is closed. // class FDWrapper { public: explicit FDWrapper(int fd) : fd_(fd) {} ~FDWrapper() { if (fd_ != -1) close(fd_); } int get() { return fd_; } int release() { int fd = fd_; fd_ = -1; return fd; } private: int fd_; }; // // MmapWrapper // // Wrapper class to make sure mapped regions are unmapped. // class MmapWrapper { public: MmapWrapper() : is_set_(false), base_(NULL), size_(0){} ~MmapWrapper() { if (is_set_ && base_ != NULL) { MOZ_ASSERT(size_ > 0); munmap(base_, size_); } } void set(void *mapped_address, size_t mapped_size) { is_set_ = true; base_ = mapped_address; size_ = mapped_size; } void release() { MOZ_ASSERT(is_set_); is_set_ = false; base_ = NULL; size_ = 0; } private: bool is_set_; void *base_; size_t size_; }; // Set NUM_DW_REGNAMES to be the number of Dwarf register names // appropriate to the machine architecture given in HEADER. Return // true on success, or false if HEADER's machine architecture is not // supported. template<typename ElfClass> bool DwarfCFIRegisterNames(const typename ElfClass::Ehdr* elf_header, unsigned int* num_dw_regnames) { switch (elf_header->e_machine) { case EM_386: *num_dw_regnames = DwarfCFIToModule::RegisterNames::I386(); return true; case EM_ARM: *num_dw_regnames = DwarfCFIToModule::RegisterNames::ARM(); return true; case EM_X86_64: *num_dw_regnames = DwarfCFIToModule::RegisterNames::X86_64(); return true; default: MOZ_ASSERT(0); return false; } } template<typename ElfClass> bool LoadDwarfCFI(const string& dwarf_filename, const typename ElfClass::Ehdr* elf_header, const char* section_name, const typename ElfClass::Shdr* section, const bool eh_frame, const typename ElfClass::Shdr* got_section, const typename ElfClass::Shdr* text_section, const bool big_endian, SecMap* smap, uintptr_t text_bias, UniqueStringUniverse* usu, void (*log)(const char*)) { // Find the appropriate set of register names for this file's // architecture. unsigned int num_dw_regs = 0; if (!DwarfCFIRegisterNames<ElfClass>(elf_header, &num_dw_regs)) { fprintf(stderr, "%s: unrecognized ELF machine architecture '%d';" " cannot convert DWARF call frame information\n", dwarf_filename.c_str(), elf_header->e_machine); return false; } const lul::Endianness endianness = big_endian ? lul::ENDIANNESS_BIG : lul::ENDIANNESS_LITTLE; // Find the call frame information and its size. const char* cfi = GetOffset<ElfClass, char>(elf_header, section->sh_offset); size_t cfi_size = section->sh_size; // Plug together the parser, handler, and their entourages. // Here's a summariser, which will receive the output of the // parser, create summaries, and add them to |smap|. Summariser summ(smap, text_bias, log); lul::ByteReader reader(endianness); reader.SetAddressSize(ElfClass::kAddrSize); DwarfCFIToModule::Reporter module_reporter(log, dwarf_filename, section_name); DwarfCFIToModule handler(num_dw_regs, &module_reporter, &reader, usu, &summ); // Provide the base addresses for .eh_frame encoded pointers, if // possible. reader.SetCFIDataBase(section->sh_addr, cfi); if (got_section) reader.SetDataBase(got_section->sh_addr); if (text_section) reader.SetTextBase(text_section->sh_addr); lul::CallFrameInfo::Reporter dwarf_reporter(log, dwarf_filename, section_name); lul::CallFrameInfo parser(cfi, cfi_size, &reader, &handler, &dwarf_reporter, eh_frame); parser.Start(); return true; } bool LoadELF(const string& obj_file, MmapWrapper* map_wrapper, void** elf_header) { int obj_fd = open(obj_file.c_str(), O_RDONLY); if (obj_fd < 0) { fprintf(stderr, "Failed to open ELF file '%s': %s\n", obj_file.c_str(), strerror(errno)); return false; } FDWrapper obj_fd_wrapper(obj_fd); struct stat st; if (fstat(obj_fd, &st) != 0 && st.st_size <= 0) { fprintf(stderr, "Unable to fstat ELF file '%s': %s\n", obj_file.c_str(), strerror(errno)); return false; } // Mapping it read-only is good enough. In any case, mapping it // read-write confuses Valgrind's debuginfo acquire/discard // heuristics, making it hard to profile the profiler. void *obj_base = mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, obj_fd, 0); if (obj_base == MAP_FAILED) { fprintf(stderr, "Failed to mmap ELF file '%s': %s\n", obj_file.c_str(), strerror(errno)); return false; } map_wrapper->set(obj_base, st.st_size); *elf_header = obj_base; if (!IsValidElf(*elf_header)) { fprintf(stderr, "Not a valid ELF file: %s\n", obj_file.c_str()); return false; } return true; } // Get the endianness of ELF_HEADER. If it's invalid, return false. template<typename ElfClass> bool ElfEndianness(const typename ElfClass::Ehdr* elf_header, bool* big_endian) { if (elf_header->e_ident[EI_DATA] == ELFDATA2LSB) { *big_endian = false; return true; } if (elf_header->e_ident[EI_DATA] == ELFDATA2MSB) { *big_endian = true; return true; } fprintf(stderr, "bad data encoding in ELF header: %d\n", elf_header->e_ident[EI_DATA]); return false; } // // LoadSymbolsInfo // // Holds the state between the two calls to LoadSymbols() in case it's necessary // to follow the .gnu_debuglink section and load debug information from a // different file. // template<typename ElfClass> class LoadSymbolsInfo { public: typedef typename ElfClass::Addr Addr; explicit LoadSymbolsInfo(const vector<string>& dbg_dirs) : debug_dirs_(dbg_dirs), has_loading_addr_(false) {} // Keeps track of which sections have been loaded so sections don't // accidentally get loaded twice from two different files. void LoadedSection(const string §ion) { if (loaded_sections_.count(section) == 0) { loaded_sections_.insert(section); } else { fprintf(stderr, "Section %s has already been loaded.\n", section.c_str()); } } string debuglink_file() const { return debuglink_file_; } private: const vector<string>& debug_dirs_; // Directories in which to // search for the debug ELF file. string debuglink_file_; // Full path to the debug ELF file. bool has_loading_addr_; // Indicate if LOADING_ADDR_ is valid. set<string> loaded_sections_; // Tracks the Loaded ELF sections // between calls to LoadSymbols(). }; // Find the preferred loading address of the binary. template<typename ElfClass> typename ElfClass::Addr GetLoadingAddress( const typename ElfClass::Phdr* program_headers, int nheader) { typedef typename ElfClass::Phdr Phdr; // For non-PIC executables (e_type == ET_EXEC), the load address is // the start address of the first PT_LOAD segment. (ELF requires // the segments to be sorted by load address.) For PIC executables // and dynamic libraries (e_type == ET_DYN), this address will // normally be zero. for (int i = 0; i < nheader; ++i) { const Phdr& header = program_headers[i]; if (header.p_type == PT_LOAD) return header.p_vaddr; } return 0; } template<typename ElfClass> bool LoadSymbols(const string& obj_file, const bool big_endian, const typename ElfClass::Ehdr* elf_header, const bool read_gnu_debug_link, LoadSymbolsInfo<ElfClass>* info, SecMap* smap, void* rx_avma, size_t rx_size, UniqueStringUniverse* usu, void (*log)(const char*)) { typedef typename ElfClass::Phdr Phdr; typedef typename ElfClass::Shdr Shdr; char buf[500]; SprintfLiteral(buf, "LoadSymbols: BEGIN %s\n", obj_file.c_str()); buf[sizeof(buf)-1] = 0; log(buf); // This is how the text bias is calculated. // BEGIN CALCULATE BIAS uintptr_t loading_addr = GetLoadingAddress<ElfClass>( GetOffset<ElfClass, Phdr>(elf_header, elf_header->e_phoff), elf_header->e_phnum); uintptr_t text_bias = ((uintptr_t)rx_avma) - loading_addr; SprintfLiteral(buf, "LoadSymbols: rx_avma=%llx, text_bias=%llx", (unsigned long long int)(uintptr_t)rx_avma, (unsigned long long int)text_bias); buf[sizeof(buf)-1] = 0; log(buf); // END CALCULATE BIAS const Shdr* sections = GetOffset<ElfClass, Shdr>(elf_header, elf_header->e_shoff); const Shdr* section_names = sections + elf_header->e_shstrndx; const char* names = GetOffset<ElfClass, char>(elf_header, section_names->sh_offset); const char *names_end = names + section_names->sh_size; bool found_usable_info = false; // Dwarf Call Frame Information (CFI) is actually independent from // the other DWARF debugging information, and can be used alone. const Shdr* dwarf_cfi_section = FindElfSectionByName<ElfClass>(".debug_frame", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum); if (dwarf_cfi_section) { // Ignore the return value of this function; even without call frame // information, the other debugging information could be perfectly // useful. info->LoadedSection(".debug_frame"); bool result = LoadDwarfCFI<ElfClass>(obj_file, elf_header, ".debug_frame", dwarf_cfi_section, false, 0, 0, big_endian, smap, text_bias, usu, log); found_usable_info = found_usable_info || result; if (result) log("LoadSymbols: read CFI from .debug_frame"); } // Linux C++ exception handling information can also provide // unwinding data. const Shdr* eh_frame_section = FindElfSectionByName<ElfClass>(".eh_frame", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum); if (eh_frame_section) { // Pointers in .eh_frame data may be relative to the base addresses of // certain sections. Provide those sections if present. const Shdr* got_section = FindElfSectionByName<ElfClass>(".got", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum); const Shdr* text_section = FindElfSectionByName<ElfClass>(".text", SHT_PROGBITS, sections, names, names_end, elf_header->e_shnum); info->LoadedSection(".eh_frame"); // As above, ignore the return value of this function. bool result = LoadDwarfCFI<ElfClass>(obj_file, elf_header, ".eh_frame", eh_frame_section, true, got_section, text_section, big_endian, smap, text_bias, usu, log); found_usable_info = found_usable_info || result; if (result) log("LoadSymbols: read CFI from .eh_frame"); } SprintfLiteral(buf, "LoadSymbols: END %s\n", obj_file.c_str()); buf[sizeof(buf)-1] = 0; log(buf); return found_usable_info; } // Return the breakpad symbol file identifier for the architecture of // ELF_HEADER. template<typename ElfClass> const char* ElfArchitecture(const typename ElfClass::Ehdr* elf_header) { typedef typename ElfClass::Half Half; Half arch = elf_header->e_machine; switch (arch) { case EM_386: return "x86"; case EM_ARM: return "arm"; case EM_MIPS: return "mips"; case EM_PPC64: return "ppc64"; case EM_PPC: return "ppc"; case EM_S390: return "s390"; case EM_SPARC: return "sparc"; case EM_SPARCV9: return "sparcv9"; case EM_X86_64: return "x86_64"; default: return NULL; } } // Format the Elf file identifier in IDENTIFIER as a UUID with the // dashes removed. string FormatIdentifier(unsigned char identifier[16]) { char identifier_str[40]; lul::FileID::ConvertIdentifierToString( identifier, identifier_str, sizeof(identifier_str)); string id_no_dash; for (int i = 0; identifier_str[i] != '\0'; ++i) if (identifier_str[i] != '-') id_no_dash += identifier_str[i]; // Add an extra "0" by the end. PDB files on Windows have an 'age' // number appended to the end of the file identifier; this isn't // really used or necessary on other platforms, but be consistent. id_no_dash += '0'; return id_no_dash; } // Return the non-directory portion of FILENAME: the portion after the // last slash, or the whole filename if there are no slashes. string BaseFileName(const string &filename) { // Lots of copies! basename's behavior is less than ideal. char *c_filename = strdup(filename.c_str()); string base = basename(c_filename); free(c_filename); return base; } template<typename ElfClass> bool ReadSymbolDataElfClass(const typename ElfClass::Ehdr* elf_header, const string& obj_filename, const vector<string>& debug_dirs, SecMap* smap, void* rx_avma, size_t rx_size, UniqueStringUniverse* usu, void (*log)(const char*)) { typedef typename ElfClass::Ehdr Ehdr; unsigned char identifier[16]; if (!lul ::FileID::ElfFileIdentifierFromMappedFile(elf_header, identifier)) { fprintf(stderr, "%s: unable to generate file identifier\n", obj_filename.c_str()); return false; } const char *architecture = ElfArchitecture<ElfClass>(elf_header); if (!architecture) { fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n", obj_filename.c_str(), elf_header->e_machine); return false; } // Figure out what endianness this file is. bool big_endian; if (!ElfEndianness<ElfClass>(elf_header, &big_endian)) return false; string name = BaseFileName(obj_filename); string os = "Linux"; string id = FormatIdentifier(identifier); LoadSymbolsInfo<ElfClass> info(debug_dirs); if (!LoadSymbols<ElfClass>(obj_filename, big_endian, elf_header, !debug_dirs.empty(), &info, smap, rx_avma, rx_size, usu, log)) { const string debuglink_file = info.debuglink_file(); if (debuglink_file.empty()) return false; // Load debuglink ELF file. fprintf(stderr, "Found debugging info in %s\n", debuglink_file.c_str()); MmapWrapper debug_map_wrapper; Ehdr* debug_elf_header = NULL; if (!LoadELF(debuglink_file, &debug_map_wrapper, reinterpret_cast<void**>(&debug_elf_header))) return false; // Sanity checks to make sure everything matches up. const char *debug_architecture = ElfArchitecture<ElfClass>(debug_elf_header); if (!debug_architecture) { fprintf(stderr, "%s: unrecognized ELF machine architecture: %d\n", debuglink_file.c_str(), debug_elf_header->e_machine); return false; } if (strcmp(architecture, debug_architecture)) { fprintf(stderr, "%s with ELF machine architecture %s does not match " "%s with ELF architecture %s\n", debuglink_file.c_str(), debug_architecture, obj_filename.c_str(), architecture); return false; } bool debug_big_endian; if (!ElfEndianness<ElfClass>(debug_elf_header, &debug_big_endian)) return false; if (debug_big_endian != big_endian) { fprintf(stderr, "%s and %s does not match in endianness\n", obj_filename.c_str(), debuglink_file.c_str()); return false; } if (!LoadSymbols<ElfClass>(debuglink_file, debug_big_endian, debug_elf_header, false, &info, smap, rx_avma, rx_size, usu, log)) { return false; } } return true; } } // namespace (anon) namespace lul { bool ReadSymbolDataInternal(const uint8_t* obj_file, const string& obj_filename, const vector<string>& debug_dirs, SecMap* smap, void* rx_avma, size_t rx_size, UniqueStringUniverse* usu, void (*log)(const char*)) { if (!IsValidElf(obj_file)) { fprintf(stderr, "Not a valid ELF file: %s\n", obj_filename.c_str()); return false; } int elfclass = ElfClass(obj_file); if (elfclass == ELFCLASS32) { return ReadSymbolDataElfClass<ElfClass32>( reinterpret_cast<const Elf32_Ehdr*>(obj_file), obj_filename, debug_dirs, smap, rx_avma, rx_size, usu, log); } if (elfclass == ELFCLASS64) { return ReadSymbolDataElfClass<ElfClass64>( reinterpret_cast<const Elf64_Ehdr*>(obj_file), obj_filename, debug_dirs, smap, rx_avma, rx_size, usu, log); } return false; } bool ReadSymbolData(const string& obj_file, const vector<string>& debug_dirs, SecMap* smap, void* rx_avma, size_t rx_size, UniqueStringUniverse* usu, void (*log)(const char*)) { MmapWrapper map_wrapper; void* elf_header = NULL; if (!LoadELF(obj_file, &map_wrapper, &elf_header)) return false; return ReadSymbolDataInternal(reinterpret_cast<uint8_t*>(elf_header), obj_file, debug_dirs, smap, rx_avma, rx_size, usu, log); } namespace { template<typename ElfClass> void FindElfClassSection(const char *elf_base, const char *section_name, typename ElfClass::Word section_type, const void **section_start, int *section_size) { typedef typename ElfClass::Ehdr Ehdr; typedef typename ElfClass::Shdr Shdr; MOZ_ASSERT(elf_base); MOZ_ASSERT(section_start); MOZ_ASSERT(section_size); MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0); const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base); MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass); const Shdr* sections = GetOffset<ElfClass,Shdr>(elf_header, elf_header->e_shoff); const Shdr* section_names = sections + elf_header->e_shstrndx; const char* names = GetOffset<ElfClass,char>(elf_header, section_names->sh_offset); const char *names_end = names + section_names->sh_size; const Shdr* section = FindElfSectionByName<ElfClass>(section_name, section_type, sections, names, names_end, elf_header->e_shnum); if (section != NULL && section->sh_size > 0) { *section_start = elf_base + section->sh_offset; *section_size = section->sh_size; } } template<typename ElfClass> void FindElfClassSegment(const char *elf_base, typename ElfClass::Word segment_type, const void **segment_start, int *segment_size) { typedef typename ElfClass::Ehdr Ehdr; typedef typename ElfClass::Phdr Phdr; MOZ_ASSERT(elf_base); MOZ_ASSERT(segment_start); MOZ_ASSERT(segment_size); MOZ_ASSERT(strncmp(elf_base, ELFMAG, SELFMAG) == 0); const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base); MOZ_ASSERT(elf_header->e_ident[EI_CLASS] == ElfClass::kClass); const Phdr* phdrs = GetOffset<ElfClass,Phdr>(elf_header, elf_header->e_phoff); for (int i = 0; i < elf_header->e_phnum; ++i) { if (phdrs[i].p_type == segment_type) { *segment_start = elf_base + phdrs[i].p_offset; *segment_size = phdrs[i].p_filesz; return; } } } } // namespace (anon) bool IsValidElf(const void* elf_base) { return strncmp(reinterpret_cast<const char*>(elf_base), ELFMAG, SELFMAG) == 0; } int ElfClass(const void* elf_base) { const ElfW(Ehdr)* elf_header = reinterpret_cast<const ElfW(Ehdr)*>(elf_base); return elf_header->e_ident[EI_CLASS]; } bool FindElfSection(const void *elf_mapped_base, const char *section_name, uint32_t section_type, const void **section_start, int *section_size, int *elfclass) { MOZ_ASSERT(elf_mapped_base); MOZ_ASSERT(section_start); MOZ_ASSERT(section_size); *section_start = NULL; *section_size = 0; if (!IsValidElf(elf_mapped_base)) return false; int cls = ElfClass(elf_mapped_base); if (elfclass) { *elfclass = cls; } const char* elf_base = static_cast<const char*>(elf_mapped_base); if (cls == ELFCLASS32) { FindElfClassSection<ElfClass32>(elf_base, section_name, section_type, section_start, section_size); return *section_start != NULL; } else if (cls == ELFCLASS64) { FindElfClassSection<ElfClass64>(elf_base, section_name, section_type, section_start, section_size); return *section_start != NULL; } return false; } bool FindElfSegment(const void *elf_mapped_base, uint32_t segment_type, const void **segment_start, int *segment_size, int *elfclass) { MOZ_ASSERT(elf_mapped_base); MOZ_ASSERT(segment_start); MOZ_ASSERT(segment_size); *segment_start = NULL; *segment_size = 0; if (!IsValidElf(elf_mapped_base)) return false; int cls = ElfClass(elf_mapped_base); if (elfclass) { *elfclass = cls; } const char* elf_base = static_cast<const char*>(elf_mapped_base); if (cls == ELFCLASS32) { FindElfClassSegment<ElfClass32>(elf_base, segment_type, segment_start, segment_size); return *segment_start != NULL; } else if (cls == ELFCLASS64) { FindElfClassSegment<ElfClass64>(elf_base, segment_type, segment_start, segment_size); return *segment_start != NULL; } return false; } // (derived from) // file_id.cc: Return a unique identifier for a file // // See file_id.h for documentation // // ELF note name and desc are 32-bits word padded. #define NOTE_PADDING(a) ((a + 3) & ~3) // These functions are also used inside the crashed process, so be safe // and use the syscall/libc wrappers instead of direct syscalls or libc. template<typename ElfClass> static bool ElfClassBuildIDNoteIdentifier(const void *section, int length, uint8_t identifier[kMDGUIDSize]) { typedef typename ElfClass::Nhdr Nhdr; const void* section_end = reinterpret_cast<const char*>(section) + length; const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section); while (reinterpret_cast<const void *>(note_header) < section_end) { if (note_header->n_type == NT_GNU_BUILD_ID) break; note_header = reinterpret_cast<const Nhdr*>( reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) + NOTE_PADDING(note_header->n_namesz) + NOTE_PADDING(note_header->n_descsz)); } if (reinterpret_cast<const void *>(note_header) >= section_end || note_header->n_descsz == 0) { return false; } const char* build_id = reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) + NOTE_PADDING(note_header->n_namesz); // Copy as many bits of the build ID as will fit // into the GUID space. memset(identifier, 0, kMDGUIDSize); memcpy(identifier, build_id, std::min(kMDGUIDSize, (size_t)note_header->n_descsz)); return true; } // Attempt to locate a .note.gnu.build-id section in an ELF binary // and copy as many bytes of it as will fit into |identifier|. static bool FindElfBuildIDNote(const void *elf_mapped_base, uint8_t identifier[kMDGUIDSize]) { void* note_section; int note_size, elfclass; if ((!FindElfSegment(elf_mapped_base, PT_NOTE, (const void**)¬e_section, ¬e_size, &elfclass) || note_size == 0) && (!FindElfSection(elf_mapped_base, ".note.gnu.build-id", SHT_NOTE, (const void**)¬e_section, ¬e_size, &elfclass) || note_size == 0)) { return false; } if (elfclass == ELFCLASS32) { return ElfClassBuildIDNoteIdentifier<ElfClass32>(note_section, note_size, identifier); } else if (elfclass == ELFCLASS64) { return ElfClassBuildIDNoteIdentifier<ElfClass64>(note_section, note_size, identifier); } return false; } // Attempt to locate the .text section of an ELF binary and generate // a simple hash by XORing the first page worth of bytes into |identifier|. static bool HashElfTextSection(const void *elf_mapped_base, uint8_t identifier[kMDGUIDSize]) { void* text_section; int text_size; if (!FindElfSection(elf_mapped_base, ".text", SHT_PROGBITS, (const void**)&text_section, &text_size, NULL) || text_size == 0) { return false; } memset(identifier, 0, kMDGUIDSize); const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section); const uint8_t* ptr_end = ptr + std::min(text_size, 4096); while (ptr < ptr_end) { for (unsigned i = 0; i < kMDGUIDSize; i++) identifier[i] ^= ptr[i]; ptr += kMDGUIDSize; } return true; } // static bool FileID::ElfFileIdentifierFromMappedFile(const void* base, uint8_t identifier[kMDGUIDSize]) { // Look for a build id note first. if (FindElfBuildIDNote(base, identifier)) return true; // Fall back on hashing the first page of the text section. return HashElfTextSection(base, identifier); } // static void FileID::ConvertIdentifierToString(const uint8_t identifier[kMDGUIDSize], char* buffer, int buffer_length) { uint8_t identifier_swapped[kMDGUIDSize]; // Endian-ness swap to match dump processor expectation. memcpy(identifier_swapped, identifier, kMDGUIDSize); uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped); *data1 = htonl(*data1); uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4); *data2 = htons(*data2); uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6); *data3 = htons(*data3); int buffer_idx = 0; for (unsigned int idx = 0; (buffer_idx < buffer_length) && (idx < kMDGUIDSize); ++idx) { int hi = (identifier_swapped[idx] >> 4) & 0x0F; int lo = (identifier_swapped[idx]) & 0x0F; if (idx == 4 || idx == 6 || idx == 8 || idx == 10) buffer[buffer_idx++] = '-'; buffer[buffer_idx++] = (hi >= 10) ? 'A' + hi - 10 : '0' + hi; buffer[buffer_idx++] = (lo >= 10) ? 'A' + lo - 10 : '0' + lo; } // NULL terminate buffer[(buffer_idx < buffer_length) ? buffer_idx : buffer_idx - 1] = 0; } } // namespace lul