proxygen: folly::symbolizer::ElfFile Class Reference

#include <Elf.h>

Public Types
enum	{ kSuccess = 0, kSystemError = -1, kInvalidElfFile = -2 }

typedef std::pair< const ElfShdr , const ElfSym >	Symbol

Public Member Functions
	ElfFile () noexcept

	ElfFile (const char *name, bool readOnly=true)

int	openNoThrow (const char name, bool readOnly=true, const char *msg=nullptr) noexcept

int	openAndFollow (const char name, bool readOnly=true, const char *msg=nullptr) noexcept

void	open (const char *name, bool readOnly=true)

	~ElfFile ()

	ElfFile (ElfFile &&other) noexcept

ElfFile &	operator= (ElfFile &&other)

const ElfEhdr &	elfHeader () const

uintptr_t	getBaseAddress () const

const ElfShdr *	getSectionByName (const char *name) const

const ElfShdr *	getSectionByIndex (size_t idx) const

const char *	getSectionName (const ElfShdr &section) const

folly::StringPiece	getSectionBody (const ElfShdr &section) const

const char *	getString (const ElfShdr &stringTable, size_t offset) const

template<class Fn >
const char *	iterateStrings (const ElfShdr &stringTable, Fn fn) const

template<class Fn >
const ElfPhdr *	iterateProgramHeaders (Fn fn) const

template<class Fn >
const ElfShdr *	iterateSections (Fn fn) const

template<class Fn >
const ElfShdr *	iterateSectionsWithType (uint32_t type, Fn fn) const

template<class Fn >
const ElfShdr *	iterateSectionsWithTypes (std::initializer_list< uint32_t > types, Fn fn) const

template<class Fn >
const ElfSym *	iterateSymbols (const ElfShdr &section, Fn fn) const

template<class Fn >
const ElfSym *	iterateSymbolsWithType (const ElfShdr &section, uint32_t type, Fn fn) const

template<class Fn >
const ElfSym *	iterateSymbolsWithTypes (const ElfShdr &section, std::initializer_list< uint32_t > types, Fn fn) const

Symbol	getDefinitionByAddress (uintptr_t address) const

Symbol	getSymbolByName (const char *name) const

template<class T >
const T &	getSymbolValue (const ElfSym *symbol) const

template<class T >
const T &	getAddressValue (const ElfAddr addr) const

const char *	getSymbolName (Symbol symbol) const

const ElfShdr *	getSectionContainingAddress (ElfAddr addr) const

Private Member Functions
bool	init (const char **msg)

void	reset ()

	ElfFile (const ElfFile &)=delete

ElfFile &	operator= (const ElfFile &)=delete

void	validateStringTable (const ElfShdr &stringTable) const

template<class T >
const std::enable_if< std::is_pod< T >::value, T >::type &	at (ElfOff offset) const

template<class T >
const T &	valueAt (const ElfShdr &section, const ElfAddr addr) const

Private Attributes
char	filepath_ [kFilepathMaxLen] = {}

int	fd_

char *	file_

size_t	length_

uintptr_t	baseAddress_

Static Private Attributes
static constexpr size_t	kFilepathMaxLen = 512

Detailed Description

ELF file parser.

We handle native files only (32-bit files on a 32-bit platform, 64-bit files on a 64-bit platform), and only executables (ET_EXEC) and shared objects (ET_DYN).

Definition at line 52 of file Elf.h.

Member Typedef Documentation

typedef std::pair<const ElfShdr*, const ElfSym*> folly::symbolizer::ElfFile::Symbol

Find symbol definition by address. Note that this is the file virtual address, so you need to undo any relocation that might have happened.

Returns {nullptr, nullptr} if not found.

Definition at line 182 of file Elf.h.

Member Enumeration Documentation

anonymous enum

Enumerator
kSuccess
kSystemError
kInvalidElfFile

Definition at line 64 of file Elf.h.

        {
     kSuccess = 0,
     kSystemError = -1,
     kInvalidElfFile = -2,
   };

Constructor & Destructor Documentation

folly::symbolizer::ElfFile::ElfFile ( )

noexcept

Definition at line 39 of file Elf.cpp.

Referenced by getAddressValue().

     : fd_(-1),
       file_(static_cast<char*>(MAP_FAILED)),
       length_(0),
       baseAddress_(0) {}

folly::symbolizer::ElfFile::ElfFile	(	const char *	name,
		bool	readOnly = `true`
	)

explicit

Definition at line 45 of file Elf.cpp.

References open().

     : fd_(-1),
       file_(static_cast<char*>(MAP_FAILED)),
       length_(0),
       baseAddress_(0) {
   open(name, readOnly);
 }

folly::symbolizer::ElfFile::~ElfFile ( )

Definition at line 154 of file Elf.cpp.

References reset().

                   {
   reset();
 }

folly::symbolizer::ElfFile::ElfFile ( ElfFile && other )

noexcept

Definition at line 158 of file Elf.cpp.

References filepath_, and kFilepathMaxLen.

     : fd_(other.fd_),
       file_(other.file_),
       length_(other.length_),
       baseAddress_(other.baseAddress_) {
   // copy other.filepath_, leaving filepath_ zero-terminated, always.
   strncat(filepath_, other.filepath_, kFilepathMaxLen - 1);
   other.filepath_[0] = 0;
   other.fd_ = -1;
   other.file_ = static_cast<char*>(MAP_FAILED);
   other.length_ = 0;
   other.baseAddress_ = 0;
 }

folly::symbolizer::ElfFile::ElfFile ( const ElfFile & )

privatedelete

Member Function Documentation

template<class T >

const std::enable_if<std::is_pod<T>::value, T>::type& folly::symbolizer::ElfFile::at ( ElfOff offset ) const

inlineprivate

Definition at line 242 of file Elf.h.

References file_, filepath_, FOLLY_SAFE_CHECK, kFilepathMaxLen, length_, and folly::T.

                            {
     if (offset + sizeof(T) > length_) {
       char msg[kFilepathMaxLen + 128];
       snprintf(
           msg,
           sizeof(msg),
           "Offset (%zu + %zu) is not contained within our mmapped"
           " file (%s) of length %zu",
           offset,
           sizeof(T),
           filepath_,
           length_);
       FOLLY_SAFE_CHECK(offset + sizeof(T) <= length_, msg);
     }
 
     return *reinterpret_cast<T*>(file_ + offset);
   }

const ElfEhdr& folly::symbolizer::ElfFile::elfHeader ( ) const

inline

Retrieve the ELF header

Definition at line 90 of file Elf.h.

Referenced by getSectionByIndex(), getSectionByName(), getSectionName(), init(), iterateProgramHeaders(), iterateSections(), and valueAt().

                                    {
     return at<ElfEhdr>(0);
   }

template<class T >

const T& folly::symbolizer::ElfFile::getAddressValue ( const ElfAddr addr ) const

inline

Get the value of the object stored at the given address.

This is the function that you want to use in conjunction with getSymbolValue() to follow pointers. For example, to get the value of a char* symbol, you'd do something like this:

auto sym = getSymbolByName("someGlobalValue"); auto addr = getSymbolValue<ElfAddr>(sym.second); const char* str = &getSymbolValue<const char>(addr);

Definition at line 218 of file Elf.h.

References addr, ElfFile(), FOLLY_SAFE_CHECK, getSectionContainingAddress(), getSymbolName(), init(), operator=(), reset(), and validateStringTable().

Referenced by TEST_F().

                                                      {
     const ElfShdr* section = getSectionContainingAddress(addr);
     FOLLY_SAFE_CHECK(section, "Address does not refer to existing section");
 
     return valueAt<T>(*section, addr);
   }

uintptr_t folly::symbolizer::ElfFile::getBaseAddress ( ) const

inline

Get the base address, the address where the file should be loaded if no relocations happened.

Definition at line 98 of file Elf.h.

References baseAddress_, getSectionBody(), getSectionByIndex(), getSectionByName(), getSectionName(), getString(), iterateProgramHeaders(), iterateSections(), iterateSectionsWithType(), iterateSectionsWithTypes(), iterateStrings(), iterateSymbols(), iterateSymbolsWithType(), iterateSymbolsWithTypes(), type, and uint32_t.

                                    {
     return baseAddress_;
   }

ElfFile::Symbol folly::symbolizer::ElfFile::getDefinitionByAddress ( uintptr_t address ) const

Definition at line 370 of file Elf.cpp.

References iterateSectionsWithType(), iterateSymbolsWithTypes(), and STT_GNU_IFUNC.

                                                                      {
   Symbol foundSymbol{nullptr, nullptr};
 
   auto findSection = [&](const ElfShdr& section) {
     auto findSymbols = [&](const ElfSym& sym) {
       if (sym.st_shndx == SHN_UNDEF) {
         return false; // not a definition
       }
       if (address >= sym.st_value && address < sym.st_value + sym.st_size) {
         foundSymbol.first = &section;
         foundSymbol.second = &sym;
         return true;
       }
 
       return false;
     };
 
     return iterateSymbolsWithTypes(
         section, {STT_OBJECT, STT_FUNC, STT_GNU_IFUNC}, findSymbols);
   };
 
   // Try the .dynsym section first if it exists, it's smaller.
   (iterateSectionsWithType(SHT_DYNSYM, findSection) ||
    iterateSectionsWithType(SHT_SYMTAB, findSection));
 
   return foundSymbol;
 }

folly::StringPiece folly::symbolizer::ElfFile::getSectionBody ( const ElfShdr & section ) const

Get the actual section body

Definition at line 318 of file Elf.cpp.

References file_.

Referenced by getBaseAddress(), folly::symbolizer::Dwarf::getSection(), and openAndFollow().

                                                                      {
   return folly::StringPiece(file_ + section.sh_offset, section.sh_size);
 }

const ElfShdr * folly::symbolizer::ElfFile::getSectionByIndex ( size_t idx ) const

Find a section given its index in the section header table

Definition at line 313 of file Elf.cpp.

References elfHeader(), and FOLLY_SAFE_CHECK.

Referenced by getBaseAddress(), getSectionByName(), getSectionName(), getSymbolByName(), getSymbolName(), and getSymbolValue().

                                                           {
   FOLLY_SAFE_CHECK(idx < elfHeader().e_shnum, "invalid section index");
   return &at<ElfShdr>(elfHeader().e_shoff + idx * sizeof(ElfShdr));
 }

const ElfShdr * folly::symbolizer::ElfFile::getSectionByName ( const char * name ) const

Find a section given its name

Definition at line 352 of file Elf.cpp.

References elfHeader(), file_, getSectionByIndex(), iterateSections(), and start.

Referenced by getBaseAddress(), folly::symbolizer::Dwarf::getSection(), and openAndFollow().

                                                                {
   if (elfHeader().e_shstrndx == SHN_UNDEF) {
     return nullptr; // no section name string table
   }
 
   const ElfShdr& sectionNames = *getSectionByIndex(elfHeader().e_shstrndx);
   const char* start = file_ + sectionNames.sh_offset;
 
   // Find section with the appropriate sh_name offset
   const ElfShdr* foundSection = iterateSections([&](const ElfShdr& sh) {
     if (sh.sh_name >= sectionNames.sh_size) {
       return false;
     }
     return !strcmp(start + sh.sh_name, name);
   });
   return foundSection;
 }

const ElfShdr * folly::symbolizer::ElfFile::getSectionContainingAddress ( ElfAddr addr ) const

Find the section containing the given address

Definition at line 437 of file Elf.cpp.

References iterateSections().

Referenced by getAddressValue().

                                                                       {
   return iterateSections([&](const ElfShdr& sh) -> bool {
     return (addr >= sh.sh_addr) && (addr < (sh.sh_addr + sh.sh_size));
   });
 }

const char * folly::symbolizer::ElfFile::getSectionName ( const ElfShdr & section ) const

Retrieve the name of a section

Definition at line 343 of file Elf.cpp.

References elfHeader(), getSectionByIndex(), and getString().

Referenced by getBaseAddress().

                                                                 {
   if (elfHeader().e_shstrndx == SHN_UNDEF) {
     return nullptr; // no section name string table
   }
 
   const ElfShdr& sectionNames = *getSectionByIndex(elfHeader().e_shstrndx);
   return getString(sectionNames, section.sh_name);
 }

const char * folly::symbolizer::ElfFile::getString	(	const ElfShdr &	stringTable,
		size_t	offset
	)		const

Retrieve a string from a string table section

Definition at line 334 of file Elf.cpp.

References file_, FOLLY_SAFE_CHECK, and validateStringTable().

Referenced by getBaseAddress(), getSectionName(), getSymbolByName(), and getSymbolName().

           {
   validateStringTable(stringTable);
   FOLLY_SAFE_CHECK(
       offset < stringTable.sh_size, "invalid offset in string table");
 
   return file_ + stringTable.sh_offset + offset;
 }

ElfFile::Symbol folly::symbolizer::ElfFile::getSymbolByName ( const char * name ) const

Find symbol definition by name.

If a symbol with this name cannot be found, a <nullptr, nullptr> Symbol will be returned. This is O(N) in the number of symbols in the file.

Returns {nullptr, nullptr} if not found.

Definition at line 398 of file Elf.cpp.

References getSectionByIndex(), getString(), iterateSectionsWithType(), iterateSymbolsWithTypes(), and STT_GNU_IFUNC.

Referenced by TEST_F().

                                                              {
   Symbol foundSymbol{nullptr, nullptr};
 
   auto findSection = [&](const ElfShdr& section) -> bool {
     // This section has no string table associated w/ its symbols; hence we
     // can't get names for them
     if (section.sh_link == SHN_UNDEF) {
       return false;
     }
 
     auto findSymbols = [&](const ElfSym& sym) -> bool {
       if (sym.st_shndx == SHN_UNDEF) {
         return false; // not a definition
       }
       if (sym.st_name == 0) {
         return false; // no name for this symbol
       }
       const char* sym_name =
           getString(*getSectionByIndex(section.sh_link), sym.st_name);
       if (strcmp(sym_name, name) == 0) {
         foundSymbol.first = &section;
         foundSymbol.second = &sym;
         return true;
       }
 
       return false;
     };
 
     return iterateSymbolsWithTypes(
         section, {STT_OBJECT, STT_FUNC, STT_GNU_IFUNC}, findSymbols);
   };
 
   // Try the .dynsym section first if it exists, it's smaller.
   iterateSectionsWithType(SHT_DYNSYM, findSection) ||
       iterateSectionsWithType(SHT_SYMTAB, findSection);
 
   return foundSymbol;
 }

const char * folly::symbolizer::ElfFile::getSymbolName ( Symbol symbol ) const

Retrieve symbol name.

Definition at line 443 of file Elf.cpp.

References getSectionByIndex(), and getString().

Referenced by getAddressValue().

                                                       {
   if (!symbol.first || !symbol.second) {
     return nullptr;
   }
 
   if (symbol.second->st_name == 0) {
     return nullptr; // symbol has no name
   }
 
   if (symbol.first->sh_link == SHN_UNDEF) {
     return nullptr; // symbol table has no strings
   }
 
   return getString(
       *getSectionByIndex(symbol.first->sh_link), symbol.second->st_name);
 }

template<class T >

const T& folly::symbolizer::ElfFile::getSymbolValue ( const ElfSym * symbol ) const

inline

Get the value of a symbol.

Definition at line 199 of file Elf.h.

References FOLLY_SAFE_CHECK, and getSectionByIndex().

Referenced by TEST_F().

                                                       {
     const ElfShdr* section = getSectionByIndex(symbol->st_shndx);
     FOLLY_SAFE_CHECK(section, "Symbol's section index is invalid");
 
     return valueAt<T>(*section, symbol->st_value);
   }

bool folly::symbolizer::ElfFile::init ( const char ** msg )

private

Definition at line 206 of file Elf.cpp.

References baseAddress_, elfHeader(), EXPECTED_CLASS, fd_, h, iterateProgramHeaders(), folly::kIsLittleEndian, length_, and fizz::detail::read().

Referenced by getAddressValue(), and openNoThrow().

                                    {
   if (length_ < 4) {
     if (msg) {
       *msg = "not an ELF file (too short)";
     }
     return false;
   }
 
   std::array<char, 5> elfMagBuf = {{0, 0, 0, 0, 0}};
   if (::lseek(fd_, 0, SEEK_SET) != 0 || ::read(fd_, elfMagBuf.data(), 4) != 4) {
     if (msg) {
       *msg = "unable to read ELF file for magic number";
     }
     return false;
   }
   if (std::strncmp(elfMagBuf.data(), ELFMAG, sizeof(ELFMAG)) != 0) {
     if (msg) {
       *msg = "invalid ELF magic";
     }
     return false;
   }
   if (::lseek(fd_, 0, SEEK_SET) != 0) {
     if (msg) {
       *msg = "unable to reset file descriptor after reading ELF magic number";
     }
     return false;
   }
 
   auto& elfHeader = this->elfHeader();
 
 #define EXPECTED_CLASS P1(ELFCLASS, __ELF_NATIVE_CLASS)
 #define P1(a, b) P2(a, b)
 #define P2(a, b) a##b
   // Validate ELF class (32/64 bits)
   if (elfHeader.e_ident[EI_CLASS] != EXPECTED_CLASS) {
     if (msg) {
       *msg = "invalid ELF class";
     }
     return false;
   }
 #undef P1
 #undef P2
 #undef EXPECTED_CLASS
 
   // Validate ELF data encoding (LSB/MSB)
   static constexpr auto kExpectedEncoding =
       kIsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
   if (elfHeader.e_ident[EI_DATA] != kExpectedEncoding) {
     if (msg) {
       *msg = "invalid ELF encoding";
     }
     return false;
   }
 
   // Validate ELF version (1)
   if (elfHeader.e_ident[EI_VERSION] != EV_CURRENT ||
       elfHeader.e_version != EV_CURRENT) {
     if (msg) {
       *msg = "invalid ELF version";
     }
     return false;
   }
 
   // We only support executable and shared object files
   if (elfHeader.e_type != ET_EXEC && elfHeader.e_type != ET_DYN) {
     if (msg) {
       *msg = "invalid ELF file type";
     }
     return false;
   }
 
   if (elfHeader.e_phnum == 0) {
     if (msg) {
       *msg = "no program header!";
     }
     return false;
   }
 
   if (elfHeader.e_phentsize != sizeof(ElfPhdr)) {
     if (msg) {
       *msg = "invalid program header entry size";
     }
     return false;
   }
 
   if (elfHeader.e_shentsize != sizeof(ElfShdr)) {
     if (msg) {
       *msg = "invalid section header entry size";
     }
   }
 
   // Program headers are sorted by load address, so the first PT_LOAD
   // header gives us the base address.
   const ElfPhdr* programHeader =
       iterateProgramHeaders([](auto& h) { return h.p_type == PT_LOAD; });
 
   if (!programHeader) {
     if (msg) {
       *msg = "could not find base address";
     }
     return false;
   }
   baseAddress_ = programHeader->p_vaddr;
 
   return true;
 }

template<class Fn >

const ElfPhdr * folly::symbolizer::ElfFile::iterateProgramHeaders ( Fn fn ) const

Iterate over program headers as long as fn(section) returns false. Returns a pointer to the current ("found") section when fn returned true, or nullptr if fn returned false for all sections.

Definition at line 25 of file Elf-inl.h.

References elfHeader(), i, length_, and ptr.

Referenced by getBaseAddress(), init(), and TEST_F().

                                                          {
   // there exist ELF binaries which execute correctly, but have invalid internal
   // offset(s) to program/section headers; most probably due to invalid
   // stripping of symbols
   if (elfHeader().e_phoff + sizeof(ElfPhdr) >= length_) {
     return nullptr;
   }
 
   const ElfPhdr* ptr = &at<ElfPhdr>(elfHeader().e_phoff);
   for (size_t i = 0; i < elfHeader().e_phnum; i++, ptr++) {
     if (fn(*ptr)) {
       return ptr;
     }
   }
   return nullptr;
 }

template<class Fn >

const ElfShdr * folly::symbolizer::ElfFile::iterateSections ( Fn fn ) const

Iterate over all sections for as long as fn(section) returns false. Returns a pointer to the current ("found") section when fn returned true, or nullptr if fn returned false for all sections.

Definition at line 43 of file Elf-inl.h.

References elfHeader(), i, length_, and ptr.

Referenced by getBaseAddress(), getSectionByName(), getSectionContainingAddress(), iterateSectionsWithType(), and iterateSectionsWithTypes().

                                                    {
   // there exist ELF binaries which execute correctly, but have invalid internal
   // offset(s) to program/section headers; most probably due to invalid
   // stripping of symbols
   if (elfHeader().e_shoff + sizeof(ElfShdr) >= length_) {
     return nullptr;
   }
 
   const ElfShdr* ptr = &at<ElfShdr>(elfHeader().e_shoff);
   for (size_t i = 0; i < elfHeader().e_shnum; i++, ptr++) {
     if (fn(*ptr)) {
       return ptr;
     }
   }
   return nullptr;
 }

template<class Fn >

const ElfShdr * folly::symbolizer::ElfFile::iterateSectionsWithType	(	uint32_t	type,
		Fn	fn
	)		const

Iterate over all sections with a given type. Similar to iterateSections(), but filtered only for sections with the given type.

Definition at line 61 of file Elf-inl.h.

References iterateSections().

Referenced by getBaseAddress(), getDefinitionByAddress(), and getSymbolByName().

                                                                           {
   return iterateSections(
       [&](const ElfShdr& sh) { return sh.sh_type == type && fn(sh); });
 }

template<class Fn >

const ElfShdr * folly::symbolizer::ElfFile::iterateSectionsWithTypes	(	std::initializer_list< uint32_t >	types,
		Fn	fn
	)		const

Iterate over all sections with a given types. Similar to iterateSectionWithTypes(), but filtered on multiple types.

Definition at line 67 of file Elf-inl.h.

References iterateSections().

Referenced by getBaseAddress().

                  {
   return iterateSections([&](const ElfShdr& sh) {
     auto const it = std::find(types.begin(), types.end(), sh.sh_type);
     return it != types.end() && fn(sh);
   });
 }

template<class Fn >

const char * folly::symbolizer::ElfFile::iterateStrings	(	const ElfShdr &	stringTable,
		Fn	fn
	)		const

Iterate over all strings in a string table section for as long as fn(str) returns false. Returns the current ("found") string when fn returned true, or nullptr if fn returned false for all strings in the table.

Definition at line 77 of file Elf-inl.h.

References folly::test::end(), file_, ptr, start, and validateStringTable().

Referenced by getBaseAddress().

                                                                            {
   validateStringTable(stringTable);
 
   const char* start = file_ + stringTable.sh_offset;
   const char* end = start + stringTable.sh_size;
 
   const char* ptr = start;
   while (ptr != end && !fn(ptr)) {
     ptr += strlen(ptr) + 1;
   }
 
   return ptr != end ? ptr : nullptr;
 }

template<class Fn >

const ElfSym * folly::symbolizer::ElfFile::iterateSymbols	(	const ElfShdr &	section,
		Fn	fn
	)		const

Iterate over all symbols witin a given section.

Returns a pointer to the current ("found") symbol when fn returned true, or nullptr if fn returned false for all symbols.

Definition at line 92 of file Elf-inl.h.

References folly::test::end(), and FOLLY_SAFE_CHECK.

Referenced by getBaseAddress(), iterateSymbolsWithType(), and iterateSymbolsWithTypes().

                                                                          {
   FOLLY_SAFE_CHECK(
       section.sh_entsize == sizeof(ElfSym),
       "invalid entry size in symbol table");
 
   const ElfSym* sym = &at<ElfSym>(section.sh_offset);
   const ElfSym* end = sym + (section.sh_size / section.sh_entsize);
 
   while (sym < end) {
     if (fn(*sym)) {
       return sym;
     }
 
     ++sym;
   }
 
   return nullptr;
 }

template<class Fn >

const ElfSym * folly::symbolizer::ElfFile::iterateSymbolsWithType	(	const ElfShdr &	section,
		uint32_t	type,
		Fn	fn
	)		const

Definition at line 112 of file Elf-inl.h.

References iterateSymbols().

Referenced by getBaseAddress().

                  {
   // N.B. st_info has the same representation on 32- and 64-bit platforms
   return iterateSymbols(section, [&](const ElfSym& sym) -> bool {
     return ELF32_ST_TYPE(sym.st_info) == type && fn(sym);
   });
 }

template<class Fn >

const ElfSym * folly::symbolizer::ElfFile::iterateSymbolsWithTypes	(	const ElfShdr &	section,
		std::initializer_list< uint32_t >	types,
		Fn	fn
	)		const

Definition at line 123 of file Elf-inl.h.

References iterateSymbols().

Referenced by getBaseAddress(), getDefinitionByAddress(), and getSymbolByName().

                  {
   // N.B. st_info has the same representation on 32- and 64-bit platforms
   return iterateSymbols(section, [&](const ElfSym& sym) -> bool {
     auto const elfType = ELF32_ST_TYPE(sym.st_info);
     auto const it = std::find(types.begin(), types.end(), elfType);
     return it != types.end() && fn(sym);
   });
 }

void folly::symbolizer::ElfFile::open	(	const char *	name,
		bool	readOnly = `true`
	)

Definition at line 53 of file Elf.cpp.

References kSuccess, kSystemError, openNoThrow(), and folly::throwSystemError().

Referenced by ElfFile(), and openNoThrow().

                                                   {
   const char* msg = "";
   int r = openNoThrow(name, readOnly, &msg);
   if (r == kSystemError) {
     throwSystemError(msg);
   } else {
     CHECK_EQ(r, kSuccess) << msg;
   }
 }

int folly::symbolizer::ElfFile::openAndFollow	(	const char *	name,
		bool	readOnly = `true`,
		const char **	msg = `nullptr`
	)

noexcept

Definition at line 110 of file Elf.cpp.

References getSectionBody(), getSectionByName(), kSuccess, name, openNoThrow(), and reset().

                                {
   auto result = openNoThrow(name, readOnly, msg);
   if (!readOnly || result != kSuccess) {
     return result;
   }
 
   /* NOTE .gnu_debuglink specifies only the name of the debugging info file
    * (with no directory components). GDB checks 3 different directories, but
    * ElfFile only supports the first version:
    *     - dirname(name)
    *     - dirname(name) + /.debug/
    *     - X/dirname(name)/ - where X is set in gdb's `debug-file-directory`.
    */
   auto dirend = strrchr(name, '/');
   // include ending '/' if any.
   auto dirlen = dirend != nullptr ? dirend + 1 - name : 0;
 
   auto debuginfo = getSectionByName(".gnu_debuglink");
   if (!debuginfo) {
     return result;
   }
 
   // The section starts with the filename, with any leading directory
   // components removed, followed by a zero byte.
   auto debugFileName = getSectionBody(*debuginfo);
   auto debugFileLen = strlen(debugFileName.begin());
   if (dirlen + debugFileLen >= PATH_MAX) {
     return result;
   }
 
   char linkname[PATH_MAX];
   memcpy(linkname, name, dirlen);
   memcpy(linkname + dirlen, debugFileName.begin(), debugFileLen + 1);
   reset();
   result = openNoThrow(linkname, readOnly, msg);
   if (result == kSuccess) {
     return result;
   }
   return openNoThrow(name, readOnly, msg);
 }

int folly::symbolizer::ElfFile::openNoThrow	(	const char *	name,
		bool	readOnly = `true`,
		const char **	msg = `nullptr`
	)

noexcept

Definition at line 63 of file Elf.cpp.

References fd_, file_, filepath_, FOLLY_SAFE_CHECK, folly::gen::guard(), init(), kFilepathMaxLen, kInvalidElfFile, kSuccess, kSystemError, length_, folly::makeGuard(), name, open(), and reset().

Referenced by open(), openAndFollow(), and TEST_F().

                                {
   FOLLY_SAFE_CHECK(fd_ == -1, "File already open");
   strncat(filepath_, name, kFilepathMaxLen - 1);
   fd_ = ::open(name, readOnly ? O_RDONLY : O_RDWR);
   if (fd_ == -1) {
     if (msg) {
       *msg = "open";
     }
     return kSystemError;
   }
   // Always close fd and unmap in case of failure along the way to avoid
   // check failure above if we leave fd != -1 and the object is recycled
   // like it is inside SignalSafeElfCache
   auto guard = makeGuard([&] { reset(); });
   struct stat st;
   int r = fstat(fd_, &st);
   if (r == -1) {
     if (msg) {
       *msg = "fstat";
     }
     return kSystemError;
   }
 
   length_ = st.st_size;
   int prot = PROT_READ;
   if (!readOnly) {
     prot |= PROT_WRITE;
   }
   file_ = static_cast<char*>(mmap(nullptr, length_, prot, MAP_SHARED, fd_, 0));
   if (file_ == MAP_FAILED) {
     if (msg) {
       *msg = "mmap";
     }
     return kSystemError;
   }
   if (!init(msg)) {
     reset();
     errno = EINVAL;
     return kInvalidElfFile;
   }
   guard.dismiss();
   return kSuccess;
 }

ElfFile & folly::symbolizer::ElfFile::operator= ( ElfFile && other )

Definition at line 172 of file Elf.cpp.

References baseAddress_, fd_, file_, filepath_, kFilepathMaxLen, length_, and reset().

Referenced by getAddressValue().

                                            {
   assert(this != &other);
   reset();
 
   // copy other.filepath_, leaving filepath_ zero-terminated, always.
   strncat(filepath_, other.filepath_, kFilepathMaxLen - 1);
   fd_ = other.fd_;
   file_ = other.file_;
   length_ = other.length_;
   baseAddress_ = other.baseAddress_;
 
   other.filepath_[0] = 0;
   other.fd_ = -1;
   other.file_ = static_cast<char*>(MAP_FAILED);
   other.length_ = 0;
   other.baseAddress_ = 0;
 
   return *this;
 }

ElfFile& folly::symbolizer::ElfFile::operator= ( const ElfFile & )

privatedelete

void folly::symbolizer::ElfFile::reset ( )

private

Definition at line 192 of file Elf.cpp.

References folly::netops::close(), fd_, file_, filepath_, and length_.

Referenced by getAddressValue(), openAndFollow(), openNoThrow(), operator=(), and ~ElfFile().

                     {
   filepath_[0] = 0;
 
   if (file_ != MAP_FAILED) {
     munmap(file_, length_);
     file_ = static_cast<char*>(MAP_FAILED);
   }
 
   if (fd_ != -1) {
     close(fd_);
     fd_ = -1;
   }
 }

void folly::symbolizer::ElfFile::validateStringTable ( const ElfShdr & stringTable ) const

private

Definition at line 322 of file Elf.cpp.

References file_, FOLLY_SAFE_CHECK, and start.

Referenced by getAddressValue(), getString(), and iterateStrings().

                                                                   {
   FOLLY_SAFE_CHECK(
       stringTable.sh_type == SHT_STRTAB, "invalid type for string table");
 
   const char* start = file_ + stringTable.sh_offset;
   // First and last bytes must be 0
   FOLLY_SAFE_CHECK(
       stringTable.sh_size == 0 ||
           (start[0] == '\0' && start[stringTable.sh_size - 1] == '\0'),
       "invalid string table");
 }

template<class T >

const T& folly::symbolizer::ElfFile::valueAt	(	const ElfShdr &	section,
		const ElfAddr	addr
	)		const

inlineprivate

Definition at line 262 of file Elf.h.

References elfHeader(), FOLLY_SAFE_CHECK, and folly::T.

                                                                      {
     // For exectuables and shared objects, st_value holds a virtual address
     // that refers to the memory owned by sections. Since we didn't map the
     // sections into the addresses that they're expecting (sh_addr), but
     // instead just mmapped the entire file directly, we need to translate
     // between addresses and offsets into the file.
     //
     // TODO: For other file types, st_value holds a file offset directly. Since
     //       I don't have a use-case for that right now, just assert that
     //       nobody wants this. We can always add it later.
     FOLLY_SAFE_CHECK(
         elfHeader().e_type == ET_EXEC || elfHeader().e_type == ET_DYN,
         "Only exectuables and shared objects are supported");
     FOLLY_SAFE_CHECK(
         addr >= section.sh_addr &&
             (addr + sizeof(T)) <= (section.sh_addr + section.sh_size),
         "Address is not contained within the provided segment");
 
     return at<T>(section.sh_offset + (addr - section.sh_addr));
   }